Added better map support (#452)

* Added better map support

* Made map still output properties even with additional enabled.

* Removed early return

* Handled multiple patterns or properties with the same value.

---------

Co-authored-by: Sammy Harris <41593264+stegaBOB@users.noreply.github.com>

Author: Buzzec

schemars/src/generate.rs

@@ -611,7 +611,7 @@ impl SchemaGenerator {
 
     /// Returns `self.settings.definitions_path` as a plain JSON pointer to the definitions object,
     /// i.e. without a leading '#' or trailing '/'
-    fn definitions_path_stripped(&self) -> &str {
+    pub(crate) fn definitions_path_stripped(&self) -> &str {
         let path = &self.settings.definitions_path;
         let path = path.strip_prefix('#').unwrap_or(path);
         path.strip_suffix('/').unwrap_or(path)

schemars/src/json_schema_impls/maps.rs

@@ -1,8 +1,15 @@
 use crate::_alloc_prelude::*;
 use crate::{json_schema, JsonSchema, Schema, SchemaGenerator};
 use alloc::borrow::Cow;
-use alloc::collections::BTreeMap;
-use serde_json::{json, Value};
+use alloc::collections::{BTreeMap, BTreeSet};
+use serde_json::{Map, Value};
+
+#[derive(Ord, PartialOrd, Eq, PartialEq, Copy, Clone)]
+enum IntegerSupport {
+    None,
+    Unsigned,
+    Signed,
+}
 
 impl<K, V> JsonSchema for BTreeMap<K, V>
 where
@@ -35,25 +42,104 @@ where
             "type": "object",
         });
 
-        let key_pattern = key_schema.get("pattern").and_then(Value::as_str);
-        let key_type = key_schema.get("type").and_then(Value::as_str);
-        let key_minimum = key_schema.get("minimum").and_then(Value::as_u64);
-
-        let pattern = match (key_pattern, key_type) {
-            (Some(pattern), Some("string")) => pattern,
-            (_, Some("integer")) if key_minimum == Some(0) => r"^\d+$",
-            (_, Some("integer")) => r"^-?\d+$",
-            _ => {
-                map_schema.insert("additionalProperties".to_owned(), value_schema.to_value());
-                return map_schema;
-            }
+        let Some(mut options) = key_schema
+            .get("anyOf")
+            .and_then(Value::as_array)
+            .and_then(|a| a.iter().map(Value::as_object).collect::<Option<Vec<_>>>())
+            .or_else(|| Some(vec![key_schema.as_object()?]))
+        else {
+            return json_schema!({
+                "additionalProperties": value_schema,
+                "type": "object",
+            });
         };
 
-        map_schema.insert(
-            "patternProperties".to_owned(),
-            json!({ pattern: value_schema }),
-        );
-        map_schema.insert("additionalProperties".to_owned(), Value::Bool(false));
+        // Handle refs
+        let prefix = format!("#{}/", generator.definitions_path_stripped());
+        for option in &mut options {
+            if let Some(d) = option
+                .get("$ref")
+                .and_then(Value::as_str)
+                .and_then(|r| r.strip_prefix(&prefix))
+                .and_then(|r| generator.definitions().get(r))
+                .and_then(Value::as_object)
+            {
+                *option = d;
+            }
+        }
+
+        let mut additional_properties = false;
+        let mut support_integers = IntegerSupport::None;
+        let mut patterns = BTreeSet::new();
+        let mut properties = BTreeSet::new();
+        for option in options {
+            let key_pattern = option.get("pattern").and_then(Value::as_str);
+            let key_enum = option
+                .get("enum")
+                .and_then(Value::as_array)
+                .and_then(|a| a.iter().map(Value::as_str).collect::<Option<Vec<_>>>());
+            let key_type = option.get("type").and_then(Value::as_str);
+            let key_minimum = option.get("minimum").and_then(Value::as_u64);
+
+            match (key_pattern, key_enum, key_type) {
+                (Some(pattern), _, Some("string")) => {
+                    patterns.insert(pattern);
+                }
+                (None, Some(enum_values), Some("string")) => {
+                    for value in enum_values {
+                        properties.insert(value);
+                    }
+                }
+                (_, _, Some("integer")) if key_minimum == Some(0) => {
+                    support_integers = support_integers.max(IntegerSupport::Unsigned);
+                }
+                (_, _, Some("integer")) => {
+                    support_integers = support_integers.max(IntegerSupport::Signed);
+                }
+                _ => {
+                    additional_properties = true;
+                }
+            }
+        }
+
+        if additional_properties {
+            map_schema.insert(
+                "additionalProperties".to_owned(),
+                value_schema.clone().to_value(),
+            );
+        } else {
+            map_schema.insert("additionalProperties".to_owned(), Value::Bool(false));
+        }
+
+        match support_integers {
+            IntegerSupport::None => {}
+            IntegerSupport::Unsigned => {
+                patterns.insert(r"^\d+$");
+            }
+            IntegerSupport::Signed => {
+                patterns.insert(r"^-?\d+$");
+            }
+        }
+
+        if !patterns.is_empty() {
+            let mut patterns_map = Map::new();
+
+            for pattern in patterns {
+                patterns_map.insert(pattern.to_owned(), value_schema.clone().to_value());
+            }
+
+            map_schema.insert("patternProperties".to_owned(), Value::Object(patterns_map));
+        }
+
+        if !properties.is_empty() {
+            let mut properties_map = Map::new();
+
+            for property in properties {
+                properties_map.insert(property.to_owned(), value_schema.clone().to_value());
+            }
+
+            map_schema.insert("properties".to_owned(), Value::Object(properties_map));
+        }
 
         map_schema
     }