feat: Add string validation support (pattern, minLength, maxLength) (#51)

* feat: Add string validation support (pattern, minLength, maxLength)

Implements detection of JSON Schema string validation constraints.

Changes:
- Add 9 new change types for pattern, minLength, and maxLength
- Pattern changes conservatively treated as breaking (regex subset
  detection is complex and out of scope)
- MinLength/MaxLength with smart directional breaking logic:
  - Increasing minLength: breaking (rejects shorter strings)
  - Decreasing minLength: non-breaking (accepts more strings)
  - Decreasing maxLength: breaking (rejects longer strings)
  - Increasing maxLength: non-breaking (accepts more strings)
- Comprehensive test coverage: 14 test fixtures covering all scenarios

Fixes #23
Fixes #50

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>

* cargo fmt

---------

Co-authored-by: Claude <noreply@anthropic.com>
Co-authored-by: Markus Unterwaditzer <markus-tarpit+git@unterwaditzer.net>

Author: 3 people

src/diff_walker.rs

@@ -387,6 +387,104 @@ impl<F: FnMut(Change)> DiffWalker<F> {
         }
     }
 
+    fn diff_pattern(&mut self, json_path: &str, lhs: &mut SchemaObject, rhs: &mut SchemaObject) {
+        let lhs_pattern = &lhs.string().pattern;
+        let rhs_pattern = &rhs.string().pattern;
+
+        match (lhs_pattern, rhs_pattern) {
+            (Some(lhs_pat), Some(rhs_pat)) if lhs_pat != rhs_pat => {
+                (self.cb)(Change {
+                    path: json_path.to_owned(),
+                    change: ChangeKind::PatternChange {
+                        old_pattern: lhs_pat.clone(),
+                        new_pattern: rhs_pat.clone(),
+                    },
+                });
+            }
+            (Some(removed_pat), None) => {
+                (self.cb)(Change {
+                    path: json_path.to_owned(),
+                    change: ChangeKind::PatternRemove {
+                        removed: removed_pat.clone(),
+                    },
+                });
+            }
+            (None, Some(added_pat)) => {
+                (self.cb)(Change {
+                    path: json_path.to_owned(),
+                    change: ChangeKind::PatternAdd {
+                        added: added_pat.clone(),
+                    },
+                });
+            }
+            _ => {} // No change or both None
+        }
+    }
+
+    fn diff_min_length(&mut self, json_path: &str, lhs: &mut SchemaObject, rhs: &mut SchemaObject) {
+        let lhs_min = lhs.string().min_length;
+        let rhs_min = rhs.string().min_length;
+
+        match (lhs_min, rhs_min) {
+            (Some(lhs_val), Some(rhs_val)) if lhs_val != rhs_val => {
+                (self.cb)(Change {
+                    path: json_path.to_owned(),
+                    change: ChangeKind::MinLengthChange {
+                        old_value: lhs_val,
+                        new_value: rhs_val,
+                    },
+                });
+            }
+            (Some(removed_val), None) => {
+                (self.cb)(Change {
+                    path: json_path.to_owned(),
+                    change: ChangeKind::MinLengthRemove {
+                        removed: removed_val,
+                    },
+                });
+            }
+            (None, Some(added_val)) => {
+                (self.cb)(Change {
+                    path: json_path.to_owned(),
+                    change: ChangeKind::MinLengthAdd { added: added_val },
+                });
+            }
+            _ => {} // No change or both None
+        }
+    }
+
+    fn diff_max_length(&mut self, json_path: &str, lhs: &mut SchemaObject, rhs: &mut SchemaObject) {
+        let lhs_max = lhs.string().max_length;
+        let rhs_max = rhs.string().max_length;
+
+        match (lhs_max, rhs_max) {
+            (Some(lhs_val), Some(rhs_val)) if lhs_val != rhs_val => {
+                (self.cb)(Change {
+                    path: json_path.to_owned(),
+                    change: ChangeKind::MaxLengthChange {
+                        old_value: lhs_val,
+                        new_value: rhs_val,
+                    },
+                });
+            }
+            (Some(removed_val), None) => {
+                (self.cb)(Change {
+                    path: json_path.to_owned(),
+                    change: ChangeKind::MaxLengthRemove {
+                        removed: removed_val,
+                    },
+                });
+            }
+            (None, Some(added_val)) => {
+                (self.cb)(Change {
+                    path: json_path.to_owned(),
+                    change: ChangeKind::MaxLengthAdd { added: added_val },
+                });
+            }
+            _ => {} // No change or both None
+        }
+    }
+
     fn resolve_references(
         &self,
         lhs: &mut SchemaObject,
@@ -496,6 +594,9 @@ impl<F: FnMut(Change)> DiffWalker<F> {
         }
         self.diff_const(json_path, lhs, rhs);
         self.diff_format(json_path, lhs, rhs);
+        self.diff_pattern(json_path, lhs, rhs);
+        self.diff_min_length(json_path, lhs, rhs);
+        self.diff_max_length(json_path, lhs, rhs);
         // If we split the types, we don't want to compare type-specific properties
         // because they are already compared in the `Self::diff_any_of`
         if !is_lhs_split && !is_rhs_split {

src/types.rs

@@ -124,6 +124,57 @@ pub enum ChangeKind {
         /// The new format value.
         new_format: String,
     },
+    /// A pattern constraint has been added.
+    PatternAdd {
+        /// The pattern that was added.
+        added: String,
+    },
+    /// A pattern constraint has been removed.
+    PatternRemove {
+        /// The pattern that was removed.
+        removed: String,
+    },
+    /// A pattern constraint has been changed.
+    PatternChange {
+        /// The old pattern value.
+        old_pattern: String,
+        /// The new pattern value.
+        new_pattern: String,
+    },
+    /// A minLength constraint has been added.
+    MinLengthAdd {
+        /// The minLength value that was added.
+        added: u32,
+    },
+    /// A minLength constraint has been removed.
+    MinLengthRemove {
+        /// The minLength value that was removed.
+        removed: u32,
+    },
+    /// A minLength constraint has been changed.
+    MinLengthChange {
+        /// The old minLength value.
+        old_value: u32,
+        /// The new minLength value.
+        new_value: u32,
+    },
+    /// A maxLength constraint has been added.
+    MaxLengthAdd {
+        /// The maxLength value that was added.
+        added: u32,
+    },
+    /// A maxLength constraint has been removed.
+    MaxLengthRemove {
+        /// The maxLength value that was removed.
+        removed: u32,
+    },
+    /// A maxLength constraint has been changed.
+    MaxLengthChange {
+        /// The old maxLength value.
+        old_value: u32,
+        /// The new maxLength value.
+        new_value: u32,
+    },
 }
 
 impl ChangeKind {
@@ -170,6 +221,25 @@ impl ChangeKind {
             Self::FormatAdd { .. } => true,
             Self::FormatRemove { .. } => false,
             Self::FormatChange { .. } => true,
+            // Pattern changes are conservatively treated as breaking.
+            // Determining if one regex is a subset of another requires complex analysis.
+            Self::PatternAdd { .. } => true,
+            Self::PatternRemove { .. } => false,
+            Self::PatternChange { .. } => true,
+            // MinLength: increasing restricts (breaking), decreasing relaxes (non-breaking)
+            Self::MinLengthAdd { .. } => true,
+            Self::MinLengthRemove { .. } => false,
+            Self::MinLengthChange {
+                old_value,
+                new_value,
+            } => new_value > old_value,
+            // MaxLength: decreasing restricts (breaking), increasing relaxes (non-breaking)
+            Self::MaxLengthAdd { .. } => true,
+            Self::MaxLengthRemove { .. } => false,
+            Self::MaxLengthChange {
+                old_value,
+                new_value,
+            } => new_value < old_value,
         }
     }
 }

tests/fixtures/max_length/max_length_add.json

@@ -0,0 +1,4 @@
+{
+  "lhs": { "type": "string" },
+  "rhs": { "type": "string", "maxLength": 10 }
+}

tests/fixtures/max_length/max_length_decrease.json

@@ -0,0 +1,4 @@
+{
+  "lhs": { "type": "string", "maxLength": 10 },
+  "rhs": { "type": "string", "maxLength": 5 }
+}

tests/fixtures/max_length/max_length_increase.json

@@ -0,0 +1,4 @@
+{
+  "lhs": { "type": "string", "maxLength": 5 },
+  "rhs": { "type": "string", "maxLength": 10 }
+}

tests/fixtures/max_length/max_length_remove.json

@@ -0,0 +1,4 @@
+{
+  "lhs": { "type": "string", "maxLength": 10 },
+  "rhs": { "type": "string" }
+}

tests/fixtures/max_length/max_length_unchanged.json

@@ -0,0 +1,4 @@
+{
+  "lhs": { "type": "string", "maxLength": 10 },
+  "rhs": { "type": "string", "maxLength": 10 }
+}

tests/fixtures/min_length/min_length_add.json

@@ -0,0 +1,4 @@
+{
+  "lhs": { "type": "string" },
+  "rhs": { "type": "string", "minLength": 5 }
+}

tests/fixtures/min_length/min_length_decrease.json

@@ -0,0 +1,4 @@
+{
+  "lhs": { "type": "string", "minLength": 5 },
+  "rhs": { "type": "string", "minLength": 3 }
+}

tests/fixtures/min_length/min_length_increase.json

@@ -0,0 +1,4 @@
+{
+  "lhs": { "type": "string", "minLength": 3 },
+  "rhs": { "type": "string", "minLength": 5 }
+}