lutaml-model 0.7.3 → 0.7.5

data/spec/lutaml/model/schema/json_schema_to_models_spec.rb

@@ -0,0 +1,383 @@
+require "lutaml/model/schema"
+
+RSpec.describe Lutaml::Model::Schema::JsonSchema do
+  describe ".generate_model_classes" do
+    context "with basic model schema" do
+      let(:schema) do
+        {
+          "$schema" => "https://json-schema.org/draft/2020-12/schema",
+          "$id" => "https://example.com/vase.schema.json",
+          "description" => "A vase schema",
+          "$ref" => "#/$defs/JsonSchemaSpec_Vase",
+          "$defs" => {
+            "JsonSchemaSpec_Vase" => {
+              "type" => "object",
+              "additionalProperties" => false,
+              "properties" => {
+                "height" => { "type" => ["number", "null"] },
+                "diameter" => { "type" => ["number", "null"] },
+                "glaze" => { "$ref" => "#/$defs/JsonSchemaSpec_Glaze" },
+                "materials" => {
+                  "type" => "array",
+                  "items" => { "type" => "string" },
+                },
+              },
+            },
+            "JsonSchemaSpec_Glaze" => {
+              "type" => "object",
+              "additionalProperties" => false,
+              "properties" => {
+                "color" => { "type" => ["string", "null"] },
+                "finish" => { "type" => ["string", "null"] },
+              },
+            },
+          },
+        }
+      end
+
+      let(:glaze_class) do
+        <<~RUBY
+          require "lutaml/model"
+
+          module JsonSchemaSpec
+            class Glaze < Lutaml::Model::Serializable
+              attribute :color, :string
+              attribute :finish, :string
+            end
+          end
+        RUBY
+      end
+
+      let(:vase_class) do
+        <<~RUBY
+          require "lutaml/model"
+
+          module JsonSchemaSpec
+            class Vase < Lutaml::Model::Serializable
+              attribute :height, :float
+              attribute :diameter, :float
+              attribute :glaze, JsonSchemaSpec::Glaze
+              attribute :materials, :string, collection: true
+            end
+          end
+        RUBY
+      end
+
+      let(:expected_classes) do
+        {
+          "JsonSchemaSpec_Glaze" => glaze_class,
+          "JsonSchemaSpec_Vase" => vase_class,
+        }
+      end
+
+      it "generates Ruby model classes from schema" do
+        generated = described_class.generate_model_classes(schema)
+
+        expect(generated["JsonSchemaSpec_Vase"].strip).to eq(vase_class.strip)
+        expect(generated["JsonSchemaSpec_Glaze"].strip).to eq(glaze_class.strip)
+      end
+    end
+
+    context "with choice validation schema" do
+      let(:schema) do
+        {
+          "$schema" => "https://json-schema.org/draft/2020-12/schema",
+          "$ref" => "#/$defs/JsonSchemaSpec_ChoiceModel",
+          "$defs" => {
+            "JsonSchemaSpec_ChoiceModel" => {
+              "type" => "object",
+              "additionalProperties" => false,
+              "properties" => {
+                "name" => { "type" => ["string", "null"] },
+                "email" => { "type" => ["string", "null"] },
+                "phone" => { "type" => ["string", "null"] },
+              },
+              "oneOf" => [
+                {
+                  "type" => "object",
+                  "properties" => {
+                    "email" => { "type" => ["string", "null"] },
+                    "phone" => { "type" => ["string", "null"] },
+                  },
+                },
+              ],
+            },
+          },
+        }
+      end
+
+      let(:expected_classes) do
+        <<~RUBY
+          require "lutaml/model"
+
+          module JsonSchemaSpec
+            class ChoiceModel < Lutaml::Model::Serializable
+              attribute :name, :string
+
+              choice do
+                attribute :email, :string
+                attribute :phone, :string
+              end
+            end
+          end
+        RUBY
+      end
+
+      it "generates Ruby model classes with choice constraints from schema" do
+        generated = described_class.generate_model_classes(schema)
+        expect(generated["JsonSchemaSpec_ChoiceModel"].strip).to eq(expected_classes.strip)
+      end
+    end
+
+    context "with validation constraints schema" do
+      let(:schema) do
+        {
+          "$schema" => "https://json-schema.org/draft/2020-12/schema",
+          "$ref" => "#/$defs/JsonSchemaSpec_ValidationModel",
+          "$defs" => {
+            "JsonSchemaSpec_ValidationModel" => {
+              "type" => "object",
+              "additionalProperties" => false,
+              "properties" => {
+                "name" => {
+                  "type" => ["string", "null"],
+                  "enum" => ["Alice", "Bob", "Charlie"],
+                },
+                "email" => {
+                  "type" => ["string", "null"],
+                  "pattern" => ".*?\\S+@.+\\.\\S+",
+                },
+                "age" => {
+                  "type" => "array",
+                  "items" => { "type" => "integer" },
+                  "minItems" => 1,
+                  "maxItems" => 3,
+                },
+                "score" => {
+                  "type" => ["number", "null"],
+                  "default" => 0.0,
+                },
+              },
+            },
+          },
+        }
+      end
+
+      let(:expected_classes) do
+        <<~RUBY
+          require "lutaml/model"
+
+          module JsonSchemaSpec
+            class ValidationModel < Lutaml::Model::Serializable
+              attribute :name, :string, values: ["Alice", "Bob", "Charlie"]
+              attribute :email, :string, pattern: /.*?\\S+@.+\\.\\S+/
+              attribute :age, :integer, collection: 1..3
+              attribute :score, :float, default: 0.0
+            end
+          end
+        RUBY
+      end
+
+      it "generates Ruby model classes with validation constraints from schema" do
+        generated = described_class.generate_model_classes(schema)
+        expect(generated["JsonSchemaSpec_ValidationModel"].strip).to eq(expected_classes.strip)
+      end
+    end
+
+    context "with polymorphic types schema" do
+      let(:schema) do
+        {
+          "$schema" => "https://json-schema.org/draft/2020-12/schema",
+          "$ref" => "#/$defs/JsonSchemaSpec_PolymorphicModel",
+          "$defs" => {
+            "JsonSchemaSpec_PolymorphicModel" => {
+              "type" => "object",
+              "additionalProperties" => false,
+              "properties" => {
+                "shape" => {
+                  "type" => ["object", "null"],
+                  "oneOf" => [
+                    { "$ref" => "#/$defs/JsonSchemaSpec_Circle" },
+                    { "$ref" => "#/$defs/JsonSchemaSpec_Square" },
+                    { "$ref" => "#/$defs/JsonSchemaSpec_Shape" },
+                  ],
+                },
+              },
+            },
+            "JsonSchemaSpec_Circle" => {
+              "type" => "object",
+              "additionalProperties" => false,
+              "properties" => {
+                "area" => { "type" => ["number", "null"] },
+                "radius" => { "type" => ["number", "null"] },
+              },
+            },
+            "JsonSchemaSpec_Square" => {
+              "type" => "object",
+              "additionalProperties" => false,
+              "properties" => {
+                "area" => { "type" => ["number", "null"] },
+                "side" => { "type" => ["number", "null"] },
+              },
+            },
+            "JsonSchemaSpec_Shape" => {
+              "type" => "object",
+              "additionalProperties" => false,
+              "properties" => {
+                "area" => { "type" => ["number", "null"] },
+              },
+            },
+          },
+        }
+      end
+
+      let(:expected_classes) do
+        {
+          "JsonSchemaSpec_Shape" => <<~RUBY.strip,
+            require "lutaml/model"
+
+            module JsonSchemaSpec
+              class Shape < Lutaml::Model::Serializable
+                attribute :area, :float
+              end
+            end
+          RUBY
+
+          "JsonSchemaSpec_Circle" => <<~RUBY.strip,
+            require "lutaml/model"
+
+            module JsonSchemaSpec
+              class Circle < JsonSchemaSpec::Shape
+                attribute :radius, :float
+              end
+            end
+          RUBY
+
+          "JsonSchemaSpec_Square" => <<~RUBY.strip,
+            require "lutaml/model"
+
+            module JsonSchemaSpec
+              class Square < JsonSchemaSpec::Shape
+                attribute :side, :float
+              end
+            end
+          RUBY
+
+          "JsonSchemaSpec_PolymorphicModel" => <<~RUBY.strip,
+            require "lutaml/model"
+
+            module JsonSchemaSpec
+              class PolymorphicModel < Lutaml::Model::Serializable
+                attribute :shape, JsonSchemaSpec::Shape, polymorphic: [JsonSchemaSpec::Circle, JsonSchemaSpec::Square]
+              end
+            end
+          RUBY
+        }
+      end
+
+      it "generates Ruby model classes with polymorphic types from schema" do
+        generated = described_class.generate_model_classes(schema)
+        expect(generated.transform_values(&:strip)).to eq(expected_classes)
+      end
+    end
+
+    context "with deeply nested classes schema" do
+      let(:schema) do
+        {
+          "$schema" => "https://json-schema.org/draft/2020-12/schema",
+          "$ref" => "#/$defs/JsonSchemaSpec_Container",
+          "$defs" => {
+            "JsonSchemaSpec_Container" => {
+              "type" => "object",
+              "additionalProperties" => false,
+              "properties" => {
+                "id" => { "type" => ["string", "null"] },
+                "box" => { "$ref" => "#/$defs/JsonSchemaSpec_Box" },
+              },
+            },
+            "JsonSchemaSpec_Box" => {
+              "type" => "object",
+              "additionalProperties" => false,
+              "properties" => {
+                "size" => { "type" => ["string", "null"] },
+                "items" => {
+                  "type" => "array",
+                  "items" => { "$ref" => "#/$defs/JsonSchemaSpec_Item" },
+                },
+              },
+            },
+            "JsonSchemaSpec_Item" => {
+              "type" => "object",
+              "additionalProperties" => false,
+              "properties" => {
+                "name" => { "type" => ["string", "null"] },
+                "detail" => { "$ref" => "#/$defs/JsonSchemaSpec_Detail" },
+              },
+            },
+            "JsonSchemaSpec_Detail" => {
+              "type" => "object",
+              "additionalProperties" => false,
+              "properties" => {
+                "weight" => { "type" => ["number", "null"] },
+                "color" => { "type" => ["string", "null"] },
+              },
+            },
+          },
+        }
+      end
+
+      let(:expected_classes) do
+        {
+          "JsonSchemaSpec_Detail" => <<~RUBY.strip,
+            require "lutaml/model"
+
+            module JsonSchemaSpec
+              class Detail < Lutaml::Model::Serializable
+                attribute :weight, :float
+                attribute :color, :string
+              end
+            end
+          RUBY
+
+          "JsonSchemaSpec_Item" => <<~RUBY.strip,
+            require "lutaml/model"
+
+            module JsonSchemaSpec
+              class Item < Lutaml::Model::Serializable
+                attribute :name, :string
+                attribute :detail, JsonSchemaSpec::Detail
+              end
+            end
+          RUBY
+
+          "JsonSchemaSpec_Box" => <<~RUBY.strip,
+            require "lutaml/model"
+
+            module JsonSchemaSpec
+              class Box < Lutaml::Model::Serializable
+                attribute :size, :string
+                attribute :items, JsonSchemaSpec::Item, collection: true
+              end
+            end
+          RUBY
+
+          "JsonSchemaSpec_Container" => <<~RUBY.strip,
+            require "lutaml/model"
+
+            module JsonSchemaSpec
+              class Container < Lutaml::Model::Serializable
+                attribute :id, :string
+                attribute :box, JsonSchemaSpec::Box
+              end
+            end
+          RUBY
+        }
+      end
+
+      it "generates Ruby model classes for deeply nested classes from schema" do
+        generated = described_class.generate_model_classes(schema)
+        expect(generated.transform_values(&:strip)).to eq(expected_classes)
+      end
+    end
+  end
+end

data/spec/lutaml/model/schema/xml_compiler/attribute_group_spec.rb

@@ -0,0 +1,65 @@
+require "spec_helper"
+
+RSpec.describe Lutaml::Model::Schema::XmlCompiler::AttributeGroup do
+  let(:attribute_group) { described_class.new(name: "foo", ref: nil) }
+  let(:dummy_class) do
+    Class.new do
+      def to_attributes(indent); end
+      def to_xml_mapping(indent); end
+      def required_files; end
+    end
+  end
+
+  describe "#initialize" do
+    it "sets name, ref, and empty instances" do
+      ag = described_class.new(name: "bar", ref: "baz")
+      expect(ag.name).to eq("bar")
+      expect(ag.ref).to eq("baz")
+      expect(ag.instances).to eq([])
+    end
+  end
+
+  describe "#<<" do
+    it "adds instances to the list" do
+      instance = instance_double(dummy_class, to_attributes: "attr", to_xml_mapping: "xml", required_files: "files")
+      expect { attribute_group << instance }.to change { attribute_group.instances.size }.by(1)
+      expect(attribute_group.instances).to include(instance)
+    end
+
+    it "ignores nil instances" do
+      expect { attribute_group << nil }.not_to(change { attribute_group.instances.size })
+    end
+  end
+
+  describe "#to_attributes" do
+    it "returns attributes from resolved_instances" do
+      instance = instance_double(dummy_class, to_attributes: "attr")
+      attribute_group.instances = [instance]
+      expect(attribute_group.to_attributes("  ").join).to include("attr")
+    end
+  end
+
+  describe "#to_xml_mapping" do
+    it "returns xml mappings from resolved_instances" do
+      instance = instance_double(dummy_class, to_xml_mapping: "xml")
+      attribute_group.instances = [instance]
+      expect(attribute_group.to_xml_mapping("  ").join).to include("xml")
+    end
+  end
+
+  describe "#required_files" do
+    it "collects required_files from resolved_instances" do
+      instance = instance_double(dummy_class, required_files: "files")
+      attribute_group.instances = [instance]
+      expect(attribute_group.required_files.join).to include("files")
+    end
+  end
+
+  describe "private methods" do
+    it "resolved_instances returns @instances if ref is not present" do
+      attribute_group.instances = [1, 2]
+      attribute_group.ref = nil
+      expect(attribute_group.send(:resolved_instances)).to eq([1, 2])
+    end
+  end
+end

data/spec/lutaml/model/schema/xml_compiler/attribute_spec.rb

@@ -0,0 +1,63 @@
+require "spec_helper"
+
+RSpec.describe Lutaml::Model::Schema::XmlCompiler::Attribute do
+  let(:attribute) { described_class.new(name: "foo", ref: "bar:Ref") }
+
+  describe "#initialize" do
+    it "sets name and ref" do
+      a = described_class.new(name: "foo", ref: "bar")
+      expect(a.name).to eq("foo")
+      expect(a.ref).to eq("bar")
+    end
+  end
+
+  describe "#to_attributes" do
+    it "returns attribute line if not skippable" do
+      allow(attribute).to receive_messages(skippable?: false, resolved_name: "foo", resolved_type: "string")
+      expect(attribute.to_attributes("  ")).to include("attribute :foo, :string")
+    end
+
+    it "returns nil if skippable" do
+      allow(attribute).to receive(:skippable?).and_return(true)
+      expect(attribute.to_attributes("  ")).to be_nil
+    end
+  end
+
+  describe "#to_xml_mapping" do
+    it "returns map_attribute line if not skippable" do
+      allow(attribute).to receive_messages(skippable?: false, resolved_name: "foo")
+      expect(attribute.to_xml_mapping("  ")).to include("map_attribute :foo, to: :foo")
+    end
+
+    it "returns nil if skippable" do
+      allow(attribute).to receive(:skippable?).and_return(true)
+      expect(attribute.to_xml_mapping("  ")).to be_nil
+    end
+  end
+
+  describe "#required_files" do
+    it "returns require 'bigdecimal' for decimal type" do
+      allow(attribute).to receive_messages(skippable?: false, resolved_type: "decimal")
+      expect(attribute.required_files).to eq("require \"bigdecimal\"")
+    end
+
+    it "returns require_relative for non-skippable type" do
+      allow(attribute).to receive_messages(skippable?: false, resolved_type: "foo")
+      allow(Lutaml::Model::Schema::XmlCompiler::SimpleType).to receive(:skippable?).and_return(false)
+      expect(attribute.required_files).to eq("require_relative \"foo\"")
+    end
+
+    it "returns nil for skippable type" do
+      allow(attribute).to receive(:skippable?).and_return(true)
+      expect(attribute.required_files).to be_nil
+    end
+  end
+
+  describe "private methods" do
+    it "last_of_split returns last part after colon" do
+      expect(attribute.send(:last_of_split, "foo:Bar")).to eq("Bar")
+      expect(attribute.send(:last_of_split, "Bar")).to eq("Bar")
+      expect(attribute.send(:last_of_split, nil)).to be_nil
+    end
+  end
+end

data/spec/lutaml/model/schema/xml_compiler/choice_spec.rb

@@ -0,0 +1,71 @@
+require "spec_helper"
+
+RSpec.describe Lutaml::Model::Schema::XmlCompiler::Choice do
+  let(:choice) { described_class.new }
+  let(:dummy_class) do
+    Class.new do
+      def to_attributes(indent); end
+      def to_xml_mapping(indent); end
+      def required_files; end
+    end
+  end
+
+  describe "#initialize" do
+    it "starts with empty instances" do
+      expect(choice.instances).to eq([])
+    end
+  end
+
+  describe "#<<" do
+    it "adds instances to the list" do
+      instance = instance_double(dummy_class)
+      expect { choice << instance }.to change { choice.instances.size }.by(1)
+      expect(choice.instances).to include(instance)
+    end
+
+    it "ignores nil instances" do
+      expect { choice << nil }.not_to(change { choice.instances.size })
+    end
+  end
+
+  describe "#to_attributes" do
+    it "renders the choice block with min/max options" do
+      instance = instance_double(dummy_class, to_attributes: "    attribute :foo, :string\n")
+      choice << instance
+      choice.min_occurs = 1
+      choice.max_occurs = 2
+      expect(choice.to_attributes("  ")).to include("choice(")
+      expect(choice.to_attributes("  ")).to include("attribute :foo, :string")
+    end
+  end
+
+  describe "#to_xml_mapping" do
+    it "returns joined xml mappings from instances" do
+      instance = instance_double(dummy_class, to_xml_mapping: "    map_element :foo, to: :foo\n")
+      choice << instance
+      expect(choice.to_xml_mapping("  ")).to include("map_element :foo, to: :foo")
+    end
+  end
+
+  describe "#required_files" do
+    it "collects required_files from all instances" do
+      instance = instance_double(dummy_class, required_files: "require 'foo'")
+      choice << instance
+      expect(choice.required_files).to include("require 'foo'")
+    end
+  end
+
+  describe "private methods" do
+    it "min_option returns correct min" do
+      choice.min_occurs = 3
+      expect(choice.send(:min_option)).to include("min: 3")
+    end
+
+    it "max_option returns correct max" do
+      choice.max_occurs = "unbounded"
+      expect(choice.send(:max_option)).to include("Float::INFINITY")
+      choice.max_occurs = 5
+      expect(choice.send(:max_option)).to include("max: 5")
+    end
+  end
+end

data/spec/lutaml/model/schema/xml_compiler/complex_content_restriction_spec.rb

@@ -0,0 +1,55 @@
+require "spec_helper"
+
+RSpec.describe Lutaml::Model::Schema::XmlCompiler::ComplexContentRestriction do
+  let(:restriction) { described_class.new(base: "Base", instances: []) }
+  let(:dummy_class) do
+    Class.new do
+      def to_attributes(indent); end
+      def to_xml_mapping(indent); end
+      def required_files; end
+    end
+  end
+
+  describe "#initialize" do
+    it "sets base and instances" do
+      r = described_class.new(base: "foo", instances: [1, 2])
+      expect(r.base).to eq("foo")
+      expect(r.instances).to eq([1, 2])
+    end
+  end
+
+  describe "#<<" do
+    it "adds instances to the list" do
+      expect { restriction << 1 }.to change { restriction.instances.size }.by(1)
+      expect(restriction.instances).to include(1)
+    end
+
+    it "ignores nil instances" do
+      expect { restriction << nil }.not_to(change { restriction.instances.size })
+    end
+  end
+
+  describe "#to_attributes" do
+    it "returns attributes from all instances" do
+      instance = instance_double(dummy_class, to_attributes: "attr")
+      restriction.instances = [instance]
+      expect(restriction.to_attributes("  ")).to include("attr")
+    end
+  end
+
+  describe "#to_xml_mapping" do
+    it "returns xml mappings from all instances" do
+      instance = instance_double(dummy_class, to_xml_mapping: "xml")
+      restriction.instances = [instance]
+      expect(restriction.to_xml_mapping("  ")).to include("xml")
+    end
+  end
+
+  describe "#required_files" do
+    it "collects required_files from all instances" do
+      instance = instance_double(dummy_class, required_files: "files")
+      restriction.instances = [instance]
+      expect(restriction.required_files).to include("files")
+    end
+  end
+end

data/spec/lutaml/model/schema/xml_compiler/complex_content_spec.rb

@@ -0,0 +1,37 @@
+require "spec_helper"
+
+RSpec.describe Lutaml::Model::Schema::XmlCompiler::ComplexContent do
+  let(:dummy_class) do
+    Class.new do
+      def to_attributes(indent); end
+      def to_xml_mapping(indent); end
+      def required_files; end
+    end
+  end
+  let(:restriction) { instance_double(dummy_class, to_attributes: "attr", to_xml_mapping: "xml", required_files: "files") }
+  let(:complex_content) { described_class.new(restriction) }
+
+  describe "#initialize" do
+    it "sets restriction" do
+      expect(complex_content.restriction).to eq(restriction)
+    end
+  end
+
+  describe "#to_attributes" do
+    it "delegates to restriction" do
+      expect(complex_content.to_attributes("  ")).to eq("attr")
+    end
+  end
+
+  describe "#to_xml_mapping" do
+    it "delegates to restriction" do
+      expect(complex_content.to_xml_mapping("  ")).to eq("xml")
+    end
+  end
+
+  describe "#required_files" do
+    it "delegates to restriction" do
+      expect(complex_content.required_files).to eq("files")
+    end
+  end
+end