cellular/jspg
4
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

cleaned out raits_debug_val

Browse Source
This commit is contained in:
Alex Groleau
2026-05-28 14:56:17 -04:00
parent ea03584bbd
commit 8bb7085f76
2 changed files with 141 additions and 36 deletions
Download Patch File Download Diff File Expand all files Collapse all files

164
src/database/compose/mod.rs
View File

@ -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()) {
let mut set: HashSet<String> = arr_existing.iter().filter_map(|x| x.as_str().map(String::from)).collect();
if let (Some(arr_existing), Some(arr_target)) =
(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,
);
}
}
}

13
traits_debug_val.json
View File

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