cleaned out raits_debug_val

src/database/compose/mod.rs

@@ -1,8 +1,7 @@
-use std::collections::{HashMap, HashSet};
 use serde_json::Value;
+use std::collections::{HashMap, HashSet};
 
 pub fn compose(val: &mut Value, errors: &mut Vec<crate::drop::Error>) -> Result<(), String> {
-  let _ = std::fs::write("/Users/awgneo/Repositories/thoughtpatterns/cellular/jspg/traits_debug_val.json", serde_json::to_string_pretty(val).unwrap());
   let mut traits = HashMap::new();
   let mut schemas = HashMap::new();
 
@@ -74,7 +73,9 @@ fn resolve_in_place(
     return;
   }
 
-  let include_opt = current.as_object_mut().and_then(|obj| obj.remove("include"));
+  let include_opt = current
+    .as_object_mut()
+    .and_then(|obj| obj.remove("include"));
   if let Some(include_val) = include_opt {
     if let Some(include_arr) = include_val.as_array() {
       let mut merged_props = serde_json::Map::new();
@@ -145,7 +146,10 @@ fn resolve_in_place(
             visited.remove(inc_name);
 
             // Merge properties (host overrides trait)
-            if let Some(target_props) = resolved_target.get("properties").and_then(|v| v.as_object()) {
+            if let Some(target_props) = resolved_target
+              .get("properties")
+              .and_then(|v| v.as_object())
+            {
               for (k, v) in target_props {
                 if !merged_props.contains_key(k) {
                   merged_props.insert(k.clone(), v.clone());
@@ -154,7 +158,10 @@ fn resolve_in_place(
             }
 
             // Merge patternProperties (host overrides trait)
-            if let Some(target_pat_props) = resolved_target.get("patternProperties").and_then(|v| v.as_object()) {
+            if let Some(target_pat_props) = resolved_target
+              .get("patternProperties")
+              .and_then(|v| v.as_object())
+            {
               for (k, v) in target_pat_props {
                 if !merged_pattern_props.contains_key(k) {
                   merged_pattern_props.insert(k.clone(), v.clone());
@@ -181,11 +188,19 @@ fn resolve_in_place(
             }
 
             // Merge dependencies
-            if let Some(target_deps) = resolved_target.get("dependencies").and_then(|v| v.as_object()) {
+            if let Some(target_deps) = resolved_target
+              .get("dependencies")
+              .and_then(|v| v.as_object())
+            {
               for (dep_prop, dep_val) in target_deps {
                 if let Some(existing_val) = merged_dependencies.get_mut(dep_prop) {
-                  if let (Some(arr_existing), Some(arr_target)) = (existing_val.as_array_mut(), dep_val.as_array()) {
+                  if let (Some(arr_existing), Some(arr_target)) =
-                    let mut set: HashSet<String> = arr_existing.iter().filter_map(|x| x.as_str().map(String::from)).collect();
+                    (existing_val.as_array_mut(), dep_val.as_array())
+                  {
+                    let mut set: HashSet<String> = arr_existing
+                      .iter()
+                      .filter_map(|x| x.as_str().map(String::from))
+                      .collect();
                     for x in arr_target {
                       if let Some(s) = x.as_str() {
                         if set.insert(s.to_string()) {
@@ -203,7 +218,13 @@ fn resolve_in_place(
             // Inherit other non-merged schemas/scalars if not defined in host (type, items, cases, family, format, etc.)
             if let Some(obj) = current.as_object_mut() {
               for (k, v) in resolved_target.as_object().unwrap() {
-                if k != "properties" && k != "patternProperties" && k != "required" && k != "display" && k != "dependencies" && k != "include" {
+                if k != "properties"
+                  && k != "patternProperties"
+                  && k != "required"
+                  && k != "display"
+                  && k != "dependencies"
+                  && k != "include"
+                {
                   if !obj.contains_key(k) {
                     obj.insert(k.clone(), v.clone());
                   }
@@ -229,7 +250,10 @@ fn resolve_in_place(
           obj.insert("properties".to_string(), Value::Object(merged_props));
         }
         if !merged_pattern_props.is_empty() {
-          obj.insert("patternProperties".to_string(), Value::Object(merged_pattern_props));
+          obj.insert(
+            "patternProperties".to_string(),
+            Value::Object(merged_pattern_props),
+          );
         }
         if !merged_required.is_empty() {
           let mut req_vec: Vec<Value> = merged_required.into_iter().map(Value::String).collect();
@@ -242,7 +266,10 @@ fn resolve_in_place(
           obj.insert("display".to_string(), Value::Array(disp_vec));
         }
         if !merged_dependencies.is_empty() {
-          obj.insert("dependencies".to_string(), Value::Object(merged_dependencies));
+          obj.insert(
+            "dependencies".to_string(),
+            Value::Object(merged_dependencies),
+          );
         }
       }
     }
@@ -252,47 +279,138 @@ fn resolve_in_place(
   if let Some(obj) = current.as_object_mut() {
     if let Some(props) = obj.get_mut("properties").and_then(|v| v.as_object_mut()) {
       for (k, v) in props {
-        resolve_in_place(v, traits, schemas, errors, schema_id, &format!("{}/{}", path, k), visited);
+        resolve_in_place(
+          v,
+          traits,
+          schemas,
+          errors,
+          schema_id,
+          &format!("{}/{}", path, k),
+          visited,
+        );
       }
     }
-    if let Some(pat_props) = obj.get_mut("patternProperties").and_then(|v| v.as_object_mut()) {
+    if let Some(pat_props) = obj
+      .get_mut("patternProperties")
+      .and_then(|v| v.as_object_mut())
+    {
       for (k, v) in pat_props {
-        resolve_in_place(v, traits, schemas, errors, schema_id, &format!("{}/{}", path, k), visited);
+        resolve_in_place(
+          v,
+          traits,
+          schemas,
+          errors,
+          schema_id,
+          &format!("{}/{}", path, k),
+          visited,
+        );
       }
     }
     if let Some(items) = obj.get_mut("items") {
-      resolve_in_place(items, traits, schemas, errors, schema_id, &format!("{}/items", path), visited);
+      resolve_in_place(
+        items,
+        traits,
+        schemas,
+        errors,
+        schema_id,
+        &format!("{}/items", path),
+        visited,
+      );
     }
     if let Some(prefix_items) = obj.get_mut("prefixItems").and_then(|v| v.as_array_mut()) {
       for (i, v) in prefix_items.iter_mut().enumerate() {
-        resolve_in_place(v, traits, schemas, errors, schema_id, &format!("{}/prefixItems/{}", path, i), visited);
+        resolve_in_place(
+          v,
+          traits,
+          schemas,
+          errors,
+          schema_id,
+          &format!("{}/prefixItems/{}", path, i),
+          visited,
+        );
       }
     }
     if let Some(additional_props) = obj.get_mut("additionalProperties") {
-      resolve_in_place(additional_props, traits, schemas, errors, schema_id, &format!("{}/additionalProperties", path), visited);
+      resolve_in_place(
+        additional_props,
+        traits,
+        schemas,
+        errors,
+        schema_id,
+        &format!("{}/additionalProperties", path),
+        visited,
+      );
     }
     if let Some(one_of) = obj.get_mut("oneOf").and_then(|v| v.as_array_mut()) {
       for (i, v) in one_of.iter_mut().enumerate() {
-        resolve_in_place(v, traits, schemas, errors, schema_id, &format!("{}/oneOf/{}", path, i), visited);
+        resolve_in_place(
+          v,
+          traits,
+          schemas,
+          errors,
+          schema_id,
+          &format!("{}/oneOf/{}", path, i),
+          visited,
+        );
       }
     }
     if let Some(contains) = obj.get_mut("contains") {
-      resolve_in_place(contains, traits, schemas, errors, schema_id, &format!("{}/contains", path), visited);
+      resolve_in_place(
+        contains,
+        traits,
+        schemas,
+        errors,
+        schema_id,
+        &format!("{}/contains", path),
+        visited,
+      );
     }
     if let Some(not) = obj.get_mut("not") {
-      resolve_in_place(not, traits, schemas, errors, schema_id, &format!("{}/not", path), visited);
+      resolve_in_place(
+        not,
+        traits,
+        schemas,
+        errors,
+        schema_id,
+        &format!("{}/not", path),
+        visited,
+      );
     }
     if let Some(cases) = obj.get_mut("cases").and_then(|v| v.as_array_mut()) {
       for (i, c_val) in cases.iter_mut().enumerate() {
         if let Some(c_obj) = c_val.as_object_mut() {
           if let Some(when) = c_obj.get_mut("when") {
-            resolve_in_place(when, traits, schemas, errors, schema_id, &format!("{}/cases/{}/when", path, i), visited);
+            resolve_in_place(
+              when,
+              traits,
+              schemas,
+              errors,
+              schema_id,
+              &format!("{}/cases/{}/when", path, i),
+              visited,
+            );
           }
           if let Some(then) = c_obj.get_mut("then") {
-            resolve_in_place(then, traits, schemas, errors, schema_id, &format!("{}/cases/{}/then", path, i), visited);
+            resolve_in_place(
+              then,
+              traits,
+              schemas,
+              errors,
+              schema_id,
+              &format!("{}/cases/{}/then", path, i),
+              visited,
+            );
           }
           if let Some(else_) = c_obj.get_mut("else") {
-            resolve_in_place(else_, traits, schemas, errors, schema_id, &format!("{}/cases/{}/else", path, i), visited);
+            resolve_in_place(
+              else_,
+              traits,
+              schemas,
+              errors,
+              schema_id,
+              &format!("{}/cases/{}/else", path, i),
+              visited,
+            );
           }
         }
       }

traits_debug_val.json

@@ -1,13 +0,0 @@
-{
-  "types": [
-    {
-      "name": "uniqueItems_6_0",
-      "schemas": {
-        "uniqueItems_6_0": {
-          "uniqueItems": true,
-          "extensible": true
-        }
-      }
-    }
-  ]
-}