jspg progress

src/schema.rs

@@ -0,0 +1,212 @@
+use serde::{Deserialize, Serialize};
+use serde_json::Value;
+use std::collections::BTreeMap;
+use std::sync::Arc;
+
+// Schema mirrors the Go Punc Generator's schema struct for consistency.
+// It is an order-preserving representation of a JSON Schema.
+#[derive(Debug, Clone, Serialize, Deserialize, Default)]
+pub struct SchemaObject {
+  // Core Schema Keywords
+  #[serde(rename = "$id")]
+  pub id: Option<String>,
+  #[serde(rename = "$ref")]
+  pub ref_string: Option<String>,
+  #[serde(rename = "$anchor")]
+  pub anchor: Option<String>,
+  #[serde(rename = "$dynamicAnchor")]
+  pub dynamic_anchor: Option<String>,
+  #[serde(rename = "$dynamicRef")]
+  pub dynamic_ref: Option<String>,
+  /*
+     Note: The `Ref` field in the Go struct is a pointer populated by the linker.
+     In Rust, we might handle this differently (e.g., separate lookup or Rc/Arc),
+     so we omit the direct recursive `Ref` field for now and rely on `ref_string`.
+  */
+  pub description: Option<String>,
+  pub title: Option<String>,
+  #[serde(default)] // Allow missing type
+  #[serde(rename = "type")]
+  pub type_: Option<SchemaTypeOrArray>, // Handles string or array of strings
+
+  // Object Keywords
+  pub properties: Option<BTreeMap<String, Arc<Schema>>>,
+  #[serde(rename = "patternProperties")]
+  pub pattern_properties: Option<BTreeMap<String, Arc<Schema>>>,
+  pub required: Option<Vec<String>>,
+  // additionalProperties can be checks against a schema or boolean (handled by Schema wrapper)
+
+  // dependencies can be schema dependencies or property dependencies
+  pub dependencies: Option<BTreeMap<String, Dependency>>,
+
+  // Definitions (for $ref resolution)
+  #[serde(rename = "$defs")]
+  pub defs: Option<BTreeMap<String, Arc<Schema>>>,
+  #[serde(rename = "definitions")]
+  pub definitions: Option<BTreeMap<String, Arc<Schema>>>,
+
+  // Array Keywords
+  #[serde(rename = "items")]
+  pub items: Option<Arc<Schema>>,
+  #[serde(rename = "prefixItems")]
+  pub prefix_items: Option<Vec<Arc<Schema>>>,
+
+  // String Validation
+  #[serde(rename = "minLength")]
+  pub min_length: Option<f64>,
+  #[serde(rename = "maxLength")]
+  pub max_length: Option<f64>,
+  pub pattern: Option<String>,
+
+  // Array Validation
+  #[serde(rename = "minItems")]
+  pub min_items: Option<f64>,
+  #[serde(rename = "maxItems")]
+  pub max_items: Option<f64>,
+  #[serde(rename = "uniqueItems")]
+  pub unique_items: Option<bool>,
+  #[serde(rename = "contains")]
+  pub contains: Option<Arc<Schema>>,
+  #[serde(rename = "minContains")]
+  pub min_contains: Option<f64>,
+  #[serde(rename = "maxContains")]
+  pub max_contains: Option<f64>,
+
+  // Object Validation
+  #[serde(rename = "minProperties")]
+  pub min_properties: Option<f64>,
+  #[serde(rename = "maxProperties")]
+  pub max_properties: Option<f64>,
+  #[serde(rename = "propertyNames")]
+  pub property_names: Option<Arc<Schema>>,
+  #[serde(rename = "dependentRequired")]
+  pub dependent_required: Option<BTreeMap<String, Vec<String>>>,
+  #[serde(rename = "dependentSchemas")]
+  pub dependent_schemas: Option<BTreeMap<String, Arc<Schema>>>,
+
+  // Numeric Validation
+  pub format: Option<String>,
+  #[serde(rename = "enum")]
+  pub enum_: Option<Vec<Value>>, // `enum` is a reserved keyword in Rust
+  #[serde(default, rename = "const")]
+  pub const_: Option<Value>,
+
+  // Numeric Validation
+  #[serde(rename = "multipleOf")]
+  pub multiple_of: Option<f64>,
+  pub minimum: Option<f64>,
+  pub maximum: Option<f64>,
+  #[serde(rename = "exclusiveMinimum")]
+  pub exclusive_minimum: Option<f64>,
+  #[serde(rename = "exclusiveMaximum")]
+  pub exclusive_maximum: Option<f64>,
+
+  // Combining Keywords
+  #[serde(rename = "allOf")]
+  pub all_of: Option<Vec<Arc<Schema>>>,
+  #[serde(rename = "anyOf")]
+  pub any_of: Option<Vec<Arc<Schema>>>,
+  #[serde(rename = "oneOf")]
+  pub one_of: Option<Vec<Arc<Schema>>>,
+  #[serde(rename = "not")]
+  pub not: Option<Arc<Schema>>,
+  #[serde(rename = "if")]
+  pub if_: Option<Arc<Schema>>,
+  #[serde(rename = "then")]
+  pub then_: Option<Arc<Schema>>,
+  #[serde(rename = "else")]
+  pub else_: Option<Arc<Schema>>,
+
+  // Custom Vocabularies
+  pub form: Option<Vec<String>>,
+  pub display: Option<Vec<String>>,
+  #[serde(rename = "enumNames")]
+  pub enum_names: Option<Vec<String>>,
+  pub control: Option<String>,
+  pub actions: Option<BTreeMap<String, Action>>,
+  pub computer: Option<String>,
+  #[serde(default)]
+  pub extensible: Option<bool>,
+
+  // Compiled Fields (Hidden from JSON/Serde)
+  #[serde(skip)]
+  pub compiled_format: Option<crate::compiler::CompiledFormat>,
+  #[serde(skip)]
+  pub compiled_pattern: Option<crate::compiler::CompiledRegex>,
+  #[serde(skip)]
+  pub compiled_pattern_properties: Option<Vec<(crate::compiler::CompiledRegex, Arc<Schema>)>>,
+}
+
+#[derive(Debug, Clone, Serialize)]
+pub struct Schema {
+  #[serde(flatten)]
+  pub obj: SchemaObject,
+  #[serde(skip)]
+  pub always_fail: bool,
+}
+
+impl Default for Schema {
+  fn default() -> Self {
+    Schema {
+      obj: SchemaObject::default(),
+      always_fail: false,
+    }
+  }
+}
+
+impl std::ops::Deref for Schema {
+  type Target = SchemaObject;
+  fn deref(&self) -> &Self::Target {
+    &self.obj
+  }
+}
+impl std::ops::DerefMut for Schema {
+  fn deref_mut(&mut self) -> &mut Self::Target {
+    &mut self.obj
+  }
+}
+
+impl<'de> Deserialize<'de> for Schema {
+  fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+  where
+    D: serde::Deserializer<'de>,
+  {
+    let v: Value = Deserialize::deserialize(deserializer)?;
+
+    if let Some(b) = v.as_bool() {
+      let mut obj = SchemaObject::default();
+      if b {
+        obj.extensible = Some(true);
+      }
+      return Ok(Schema {
+        obj,
+        always_fail: !b,
+      });
+    }
+    let obj: SchemaObject = serde_json::from_value(v).map_err(serde::de::Error::custom)?;
+
+    Ok(Schema {
+      obj,
+      always_fail: false,
+    })
+  }
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(untagged)]
+pub enum SchemaTypeOrArray {
+  Single(String),
+  Multiple(Vec<String>),
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct Action {
+  pub navigate: Option<String>,
+  pub punc: Option<String>,
+}
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(untagged)]
+pub enum Dependency {
+  Props(Vec<String>),
+  Schema(Arc<Schema>),
+}