Access Token Check Input Validation - Rust Implementation

// /[;&|`\$\(\)\{\}\[\]<>]/ - Professional Rust Implementation
use regex::Regex;
use std::error::Error;
use std::fmt;
use std::time::{Duration, Instant};

#[derive(Debug, Clone)]
pub struct ValidationError {
    message: String,
}

impl fmt::Display for ValidationError {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "Validation error: {}", self.message)
    }
}

impl Error for ValidationError {}

#[derive(Debug)]
pub struct ValidationResult {
    pub is_valid: bool,
    pub error: Option<ValidationError>,
    pub duration: Duration,
    pub metadata: std::collections::HashMap<String, String>,
}

pub struct PatternValidator {
    pattern: Regex,
    name: String,
}

impl PatternValidator {
    pub fn new(pattern: &str, name: &str) -> Result<Self, Box<dyn Error>> {
        let compiled = Regex::new(pattern)?;
        
        Ok(PatternValidator {
            pattern: compiled,
            name: name.to_string(),
        })
    }
    
    pub fn validate(&self, input: &str) -> ValidationResult {
        let start = Instant::now();
        
        if input.is_empty() {
            return ValidationResult {
                is_valid: false,
                error: Some(ValidationError {
                    message: "Input cannot be empty".to_string(),
                }),
                duration: start.elapsed(),
                metadata: self.create_metadata(),
            };
        }
        
        let cleaned = input.trim();
        let is_valid = self.pattern.is_match(cleaned);
        
        ValidationResult {
            is_valid,
            error: if !is_valid {
                Some(ValidationError {
                    message: "Pattern validation failed".to_string(),
                })
            } else {
                None
            },
            duration: start.elapsed(),
            metadata: self.create_metadata(),
        }
    }
    
    fn create_metadata(&self) -> std::collections::HashMap<String, String> {
        let mut metadata = std::collections::HashMap::new();
        metadata.insert("pattern".to_string(), self.pattern.as_str().to_string());
        metadata.insert("ecosystem".to_string(), "systems".to_string());
        metadata.insert("name".to_string(), self.name.clone());
        metadata
    }
}

// Usage with comprehensive error handling
fn main() -> Result<(), Box<dyn Error>> {
    let validator = PatternValidator::new(r"/[;&|`\$\(\)\{\}\[\]<>]/", "primary-validator")?;
    
    let result = validator.validate(&user_input);
    
    match result.error {
        None => println!("✅ Validation passed in {:?}", result.duration),
        Some(err) => eprintln!("❌ Validation failed: {}", err),
    }
    
    Ok(())
}

const regex = //[;&|`\$\(\)\{\}\[\]<>]//;
const isValid = regex.test(input.trim());

import re
regex = re.compile(r"/[;&|`\$\(\)\{\}\[\]<>]/")
is_valid = bool(regex.match(input.strip()))