cargo fmt

validation-core/src/rules/pattern_rules.rs

@@ -84,8 +84,12 @@ impl PositionRange {
     pub fn positions_up_to(&self, max_length: usize) -> Vec<usize> {
         match self {
             PositionRange::Single(pos) => {
-                if *pos < max_length { vec![*pos] } else { vec![] }
-            },
+                if *pos < max_length {
+                    vec![*pos]
+                } else {
+                    vec![]
+                }
+            }
             PositionRange::Range(start, end) => {
                 let actual_end = (*end).min(max_length.saturating_sub(1));
                 if *start <= actual_end {
@@ -93,20 +97,19 @@ impl PositionRange {
                 } else {
                     vec![]
                 }
-            },
+            }
             PositionRange::From(start) => {
                 if *start < max_length {
                     (*start..max_length).collect()
                 } else {
                     vec![]
                 }
-            },
-            PositionRange::Multiple(positions) => {
-                positions.iter()
-                    .filter(|&&pos| pos < max_length)
-                    .copied()
-                    .collect()
-            },
+            }
+            PositionRange::Multiple(positions) => positions
+                .iter()
+                .filter(|&&pos| pos < max_length)
+                .copied()
+                .collect(),
         }
     }
 }
@@ -134,7 +137,7 @@ impl CharacterFilter {
             CharacterFilter::OneOf(chars) => {
                 let char_list: String = chars.iter().collect();
                 format!("one of: {char_list}")
-            },
+            }
             CharacterFilter::Custom(_) => "custom filter".to_string(),
         }
     }
@@ -195,7 +198,11 @@ impl PatternFilters {
     }
 
     /// Validate a character at a specific position against all applicable filters
-    pub fn validate_char_at_position(&self, position: usize, character: char) -> Result<(), String> {
+    pub fn validate_char_at_position(
+        &self,
+        position: usize,
+        character: char,
+    ) -> Result<(), String> {
         for filter in &self.filters {
             if let Some(error) = filter.error_message(position, character) {
                 return Err(error);
@@ -252,7 +259,10 @@ mod tests {
 
         assert_eq!(PositionRange::From(2).positions_up_to(5), vec![2, 3, 4]);
 
-        assert_eq!(PositionRange::Multiple(vec![0, 2, 5]).positions_up_to(4), vec![0, 2]);
+        assert_eq!(
+            PositionRange::Multiple(vec![0, 2, 5]).positions_up_to(4),
+            vec![0, 2]
+        );
     }
 
     #[test]
@@ -277,10 +287,7 @@ mod tests {
 
     #[test]
     fn test_position_filter_validation() {
-        let filter = PositionFilter::new(
-            PositionRange::Range(0, 1),
-            CharacterFilter::Alphabetic,
-        );
+        let filter = PositionFilter::new(PositionRange::Range(0, 1), CharacterFilter::Alphabetic);
 
         assert!(filter.validate_position(0, 'A'));
         assert!(filter.validate_position(1, 'b'));
@@ -312,11 +319,10 @@ mod tests {
 
     #[test]
     fn test_custom_filter() {
-        let pattern = PatternFilters::new()
-            .add_filter(PositionFilter::new(
-                PositionRange::From(0),
-                CharacterFilter::Custom(Arc::new(|c| c.is_lowercase())),
-            ));
+        let pattern = PatternFilters::new().add_filter(PositionFilter::new(
+            PositionRange::From(0),
+            CharacterFilter::Custom(Arc::new(|c| c.is_lowercase())),
+        ));
 
         assert!(pattern.validate_text("hello").is_ok());
         assert!(pattern.validate_text("Hello").is_err()); // Uppercase not allowed