support const keyword (#27)

Author: 6293

src/diff_walker.rs

@@ -1,8 +1,8 @@
-use std::collections::BTreeSet;
+use std::collections::{BTreeMap, BTreeSet};
 
 use schemars::schema::{
-    InstanceType, NumberValidation, RootSchema, Schema, SchemaObject, SingleOrVec,
-    SubschemaValidation,
+    InstanceType, NumberValidation, ObjectValidation, RootSchema, Schema, SchemaObject,
+    SingleOrVec, SubschemaValidation,
 };
 use serde_json::Value;
 
@@ -77,6 +77,37 @@ impl DiffWalker {
         }
     }
 
+    fn diff_const(&mut self, json_path: &str, lhs: &mut SchemaObject, rhs: &mut SchemaObject) {
+        Self::normalize_const(lhs);
+        Self::normalize_const(rhs);
+        match (&lhs.const_value, &rhs.const_value) {
+            (Some(value), None) => self.changes.push(Change {
+                path: json_path.to_owned(),
+                change: ChangeKind::ConstRemove {
+                    removed: value.clone(),
+                },
+            }),
+            (None, Some(value)) => self.changes.push(Change {
+                path: json_path.to_owned(),
+                change: ChangeKind::ConstAdd {
+                    added: value.clone(),
+                },
+            }),
+            (Some(l), Some(r)) if l != r => {
+                if l.is_object() && r.is_object() {}
+                self.changes.push(Change {
+                    path: json_path.to_owned(),
+                    change: ChangeKind::ConstRemove { removed: l.clone() },
+                });
+                self.changes.push(Change {
+                    path: json_path.to_owned(),
+                    change: ChangeKind::ConstAdd { added: r.clone() },
+                });
+            }
+            _ => (),
+        }
+    }
+
     fn diff_properties(
         &mut self,
         json_path: &str,
@@ -384,6 +415,33 @@ impl DiffWalker {
         is_split
     }
 
+    fn normalize_const(schema_object: &mut SchemaObject) {
+        fn do_normalize(value: Value) -> SchemaObject {
+            match value {
+                Value::Object(obj) => {
+                    let properties = obj
+                        .into_iter()
+                        .map(|(k, v)| (k, Schema::Object(do_normalize(v))))
+                        .collect::<BTreeMap<_, _>>();
+                    SchemaObject {
+                        object: Some(Box::new(ObjectValidation {
+                            properties,
+                            ..Default::default()
+                        })),
+                        ..Default::default()
+                    }
+                }
+                _ => SchemaObject {
+                    const_value: Some(value),
+                    ..Default::default()
+                },
+            }
+        }
+        if let Some(value) = schema_object.const_value.take() {
+            *schema_object = do_normalize(value)
+        }
+    }
+
     fn do_diff(
         &mut self,
         json_path: &str,
@@ -399,6 +457,7 @@ impl DiffWalker {
         if !comparing_any_of {
             self.diff_instance_types(json_path, lhs, rhs);
         }
+        self.diff_const(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

@@ -26,6 +26,16 @@ pub enum ChangeKind {
         /// The type in question.
         removed: JsonSchemaType,
     },
+    /// A const value has been added as an allowed value.
+    ConstAdd {
+        /// The value of the added const.
+        added: serde_json::Value,
+    },
+    /// A const has been removed as an allowed value.
+    ConstRemove {
+        /// The value of the removed const.
+        removed: serde_json::Value,
+    },
     /// A property has been added and (depending on additionalProperties) is now additionally
     /// allowed.
     PropertyAdd {
@@ -117,6 +127,8 @@ impl ChangeKind {
         match self {
             Self::TypeAdd { .. } => false,
             Self::TypeRemove { .. } => true,
+            Self::ConstAdd { .. } => true,
+            Self::ConstRemove { .. } => false,
             Self::PropertyAdd {
                 lhs_additional_properties,
                 ..

tests/fixtures/const/const_in_any_of_1.json

@@ -0,0 +1,4 @@
+{
+  "lhs": { "anyOf": [{ "type": "number" }, { "type": "string" }] },
+  "rhs": { "anyOf": [{ "const": 1 }, { "const": "1" }] }
+}

tests/fixtures/const/const_in_any_of_2.json

@@ -0,0 +1,4 @@
+{
+  "lhs": { "anyOf": [{ "type": "number" }, { "type": "string" }, { "const": 1 }] },
+  "rhs": { "anyOf": [{ "const": 1 }, { "const": "1" }] }
+}

tests/fixtures/const/const_in_any_of_3.json

@@ -0,0 +1,4 @@
+{
+  "lhs": { "anyOf": [{ "type": "object" }, { "type": "string" }, { "const": { "key": "value" } }] },
+  "rhs": { "anyOf": [{ "properties": { "key": { "const": "value" } } }, { "const": "1" }] }
+}

tests/fixtures/const/const_in_properties.json

@@ -0,0 +1,4 @@
+{
+  "lhs": { "const": { "key": "value" } },
+  "rhs": { "properties": { "key": { "const": "value" } } }
+}

tests/fixtures/const/const_string_to_const_number.json

@@ -0,0 +1,4 @@
+{
+  "lhs": { "const": "foo" },
+  "rhs": { "const": 1 }
+}

tests/fixtures/const/const_string_to_other_const_string.json

@@ -0,0 +1,4 @@
+{
+  "lhs": { "const": "foo" },
+  "rhs": { "const": "bar" }
+}

tests/fixtures/const/integer_to_const_string.json

@@ -0,0 +1,4 @@
+{
+  "lhs": { "type": "integer" },
+  "rhs": { "const": "foo" }
+}

tests/fixtures/const/number_to_const_string.json

@@ -0,0 +1,4 @@
+{
+  "lhs": { "type": "number" },
+  "rhs": { "const": "foo" }
+}