Skip to main content

ass_editor/utils/validator/
lazy_validator.rs

1//! Lazy validator type and its construction/configuration.
2//!
3//! Defines `LazyValidator`, holding validation configuration, cached results,
4//! and the ass-core analysis configuration used during validation.
5
6use super::{ValidationResult, ValidatorConfig};
7
8#[cfg(feature = "analysis")]
9use ass_core::analysis::{AnalysisConfig, ScriptAnalysisOptions};
10
11#[cfg(feature = "std")]
12use std::time::Instant;
13
14/// Lazy validator that wraps ass-core's ScriptAnalysis
15///
16/// Provides on-demand validation with caching and incremental updates
17/// as specified in the architecture (line 164).
18#[derive(Debug)]
19pub struct LazyValidator {
20    /// Configuration for validation behavior
21    pub(super) config: ValidatorConfig,
22
23    /// Cached validation result
24    pub(super) cached_result: Option<ValidationResult>,
25
26    /// Hash of last validated content
27    pub(super) content_hash: u64,
28
29    /// Last validation timestamp
30    #[cfg(feature = "std")]
31    pub(super) last_validation: Option<Instant>,
32
33    /// Core analysis configuration
34    #[cfg(feature = "analysis")]
35    pub(super) analysis_config: AnalysisConfig,
36}
37
38impl LazyValidator {
39    /// Create a new lazy validator with default configuration
40    pub fn new() -> Self {
41        Self::with_config(ValidatorConfig::default())
42    }
43
44    /// Create a new lazy validator with custom configuration
45    pub fn with_config(config: ValidatorConfig) -> Self {
46        Self {
47            #[cfg(feature = "analysis")]
48            analysis_config: AnalysisConfig {
49                options: {
50                    let mut options = ScriptAnalysisOptions::empty();
51                    if config.enable_unicode_checks {
52                        options |= ScriptAnalysisOptions::UNICODE_LINEBREAKS;
53                    }
54                    if config.enable_performance_hints {
55                        options |= ScriptAnalysisOptions::PERFORMANCE_HINTS;
56                    }
57                    if config.enable_spec_compliance {
58                        options |= ScriptAnalysisOptions::STRICT_COMPLIANCE;
59                    }
60                    if config.enable_accessibility_checks {
61                        options |= ScriptAnalysisOptions::BIDI_ANALYSIS;
62                    }
63                    options
64                },
65                max_events_threshold: 1000,
66            },
67            config,
68            cached_result: None,
69            content_hash: 0,
70            #[cfg(feature = "std")]
71            last_validation: None,
72        }
73    }
74
75    /// Update configuration
76    pub fn set_config(&mut self, config: ValidatorConfig) {
77        self.config = config;
78        self.clear_cache(); // Config change invalidates cache
79
80        #[cfg(feature = "analysis")]
81        {
82            self.analysis_config = AnalysisConfig {
83                options: {
84                    let mut options = ScriptAnalysisOptions::empty();
85                    if self.config.enable_unicode_checks {
86                        options |= ScriptAnalysisOptions::UNICODE_LINEBREAKS;
87                    }
88                    if self.config.enable_performance_hints {
89                        options |= ScriptAnalysisOptions::PERFORMANCE_HINTS;
90                    }
91                    if self.config.enable_spec_compliance {
92                        options |= ScriptAnalysisOptions::STRICT_COMPLIANCE;
93                    }
94                    if self.config.enable_accessibility_checks {
95                        options |= ScriptAnalysisOptions::BIDI_ANALYSIS;
96                    }
97                    options
98                },
99                max_events_threshold: 1000,
100            };
101        }
102    }
103}
104
105impl Default for LazyValidator {
106    fn default() -> Self {
107        Self::new()
108    }
109}