lutaml-model 0.8.17 → 0.8.18

data/spec/lutaml/xml/schema/compiler/attribute_spec.rb

@@ -1,67 +0,0 @@
-require "spec_helper"
-require "support/xml/schema_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
-      attribute = described_class.new(name: "test")
-      attribute.type = "decimal"
-      expect(attribute.required_files).to eq(["require \"bigdecimal\""])
-    end
-
-    it "returns require_relative for non-skippable type" do
-      attribute = described_class.new(name: "test")
-      attribute.type = "foo"
-      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/xml/schema/compiler/choice_spec.rb

@@ -1,74 +0,0 @@
-require "spec_helper"
-require "support/xml/schema_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/xml/schema/compiler/complex_content_restriction_spec.rb

@@ -1,60 +0,0 @@
-require "spec_helper"
-require "support/xml/schema_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 do
-        restriction.instances.size
-      end)
-    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/xml/schema/compiler/complex_content_spec.rb

@@ -1,41 +0,0 @@
-require "spec_helper"
-require "support/xml/schema_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) do
-    instance_double(dummy_class, to_attributes: "attr", to_xml_mapping: "xml",
-                                 required_files: "files")
-  end
-  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

data/spec/lutaml/xml/schema/compiler/complex_type_spec.rb

@@ -1,202 +0,0 @@
-require "spec_helper"
-require "support/xml/schema_helper"
-
-RSpec.describe Lutaml::Model::Schema::XmlCompiler::ComplexType do
-  let(:complex_type) { 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
-  let(:simple_content_class) do
-    Class.new do
-      def base_class; end
-      def to_attributes(indent); end
-      def to_xml_mapping(indent); end
-      def required_files; end
-    end
-  end
-
-  describe "#initialize" do
-    it "sets default base_class and empty instances" do
-      expect(complex_type.base_class).to eq(described_class::SERIALIZABLE_BASE_CLASS)
-      expect(complex_type.instances).to eq([])
-    end
-
-    it "allows custom base_class" do
-      ct = described_class.new(base_class: "CustomBase")
-      expect(ct.base_class).to eq("CustomBase")
-    end
-  end
-
-  describe "attribute accessors" do
-    it "allows reading and writing id, name, mixed, simple_content" do
-      complex_type.id = "id"
-      complex_type.name = "Name"
-      complex_type.mixed = true
-      complex_type.simple_content = instance_double(simple_content_class)
-      expect(complex_type.id).to eq("id")
-      expect(complex_type.name).to eq("Name")
-      expect(complex_type.mixed).to be true
-      expect(complex_type.simple_content).to be_a(RSpec::Mocks::InstanceVerifyingDouble)
-    end
-  end
-
-  describe "#<<" do
-    it "adds instances to the list" do
-      instance = instance_double(dummy_class)
-      expect { complex_type << instance }.to change {
-        complex_type.instances.size
-      }.by(1)
-      expect(complex_type.instances).to include(instance)
-    end
-
-    it "ignores nil instances" do
-      expect { complex_type << nil }.not_to(change do
-        complex_type.instances.size
-      end)
-    end
-  end
-
-  describe "#simple_content?" do
-    it "returns false if simple_content is nil or blank" do
-      expect(complex_type.simple_content?).to be false
-      complex_type.simple_content = nil
-      expect(complex_type.simple_content?).to be false
-    end
-
-    it "returns true if simple_content is present" do
-      complex_type.simple_content = instance_double(simple_content_class)
-      expect(complex_type.simple_content?).to be true
-    end
-  end
-
-  describe "#to_class" do
-    it "renders a class with no instances or simple_content" do
-      complex_type.name = "TestClass"
-      code = complex_type.to_class
-      expect(code).to include("class TestClass < Lutaml::Model::Serializable")
-      expect(code).to include("def self.register_class_with_id")
-    end
-
-    it "renders a class with instances" do
-      instance = instance_double(dummy_class,
-                                 to_attributes: "  attribute :foo, :string\n", to_xml_mapping: "  map_element 'foo', to: :foo\n", required_files: [])
-      complex_type.name = "TestClass"
-      complex_type << instance
-      code = complex_type.to_class
-      expect(code).to include("attribute :foo, :string")
-      expect(code).to include("map_element 'foo', to: :foo")
-    end
-
-    it "renders a class with simple_content" do
-      simple_content = instance_double(simple_content_class,
-                                       base_class: "string", to_attributes: "  attribute :content, :string\n", to_xml_mapping: "  map_content to: :content\n", required_files: ["require 'simple_content'"])
-      complex_type.name = "TestClass"
-      complex_type.simple_content = simple_content
-      code = complex_type.to_class
-      expect(code).to include("attribute :content, :string")
-      expect(code).to include("map_content to: :content")
-      expect(code).to include("require 'simple_content'")
-    end
-
-    it "renders a class with mixed content" do
-      complex_type.name = "TestClass"
-      complex_type.mixed = true
-      code = complex_type.to_class
-      expect(code).to include("mixed_content")
-    end
-
-    it "renders a class with mixed content and no simple_content has collection: true" do
-      complex_type.name = "TestClass"
-      complex_type.mixed = true
-      # simple_content is nil by default, so simple_content? returns false
-      code = complex_type.to_class
-      expect(code).to include("mixed_content")
-      expect(code).to include("attribute :content, :string, collection: true")
-    end
-
-    it "renders a class with mixed content and simple_content does not have collection: true" do
-      simple_content = instance_double(simple_content_class,
-                                       base_class: "string", to_attributes: "  attribute :content, :string\n", to_xml_mapping: "  map_content to: :content\n", required_files: [])
-      complex_type.name = "TestClass"
-      complex_type.mixed = true
-      complex_type.simple_content = simple_content
-      code = complex_type.to_class
-      expect(code).to include("mixed_content")
-      expect(code).to include("attribute :content, :string")
-      expect(code).not_to include("collection: true")
-    end
-
-    it "renders a class with namespace and prefix options" do
-      complex_type.name = "TestClass"
-      code = complex_type.to_class(options: { namespace: "http://example.com",
-                                              indent: 2 })
-      # Without namespace classes registered in XmlCompiler.namespace_classes,
-      # no namespace directive will be output. This reflects the new architecture
-      # where namespace classes must be pre-created.
-      expect(code).not_to include("namespace")
-    end
-  end
-
-  describe "#required_files" do
-    it "returns empty array for default base_class (require lutaml/model is in template)" do
-      expect(complex_type.required_files).to eq([])
-    end
-
-    it "returns empty array for custom base_class (autoload handles dependencies)" do
-      ct = described_class.new(base_class: "foo:BarBase")
-      expect(ct.required_files).to eq([])
-    end
-
-    it "includes required_files from instances and simple_content" do
-      instance = instance_double(dummy_class,
-                                 required_files: ["require 'foo'"])
-      simple_content = instance_double(simple_content_class,
-                                       required_files: ["require 'bar'"])
-      complex_type << instance
-      complex_type.simple_content = simple_content
-      expect(complex_type.required_files).to include("require 'foo'")
-      expect(complex_type.required_files).to include("require 'bar'")
-    end
-  end
-
-  describe "private methods" do
-    it "base_class_name returns correct value" do
-      expect(complex_type.send(:base_class_name)).to eq("Lutaml::Model::Serializable")
-      ct = described_class.new(base_class: "foo:BarBase")
-      expect(ct.send(:base_class_name)).to eq("BarBase")
-    end
-
-    it "last_of_split returns last part after colon" do
-      expect(complex_type.send(:last_of_split,
-                               "foo:BarBase")).to eq("BarBase")
-      expect(complex_type.send(:last_of_split, "BarBase")).to eq("BarBase")
-      expect(complex_type.send(:last_of_split, nil)).to be_nil
-    end
-  end
-
-  describe "edge cases" do
-    it "handles no instances or simple_content" do
-      complex_type.name = "TestClass"
-      expect { complex_type.to_class }.not_to raise_error
-    end
-
-    it "handles unusual base_class values" do
-      ct = described_class.new(base_class: nil)
-      ct.name = "TestClass"
-      expect { ct.to_class }.not_to raise_error
-    end
-  end
-
-  describe "integration" do
-    it "generates valid Ruby code for a complex type" do
-      complex_type.name = "TestClass"
-      code = complex_type.to_class
-      expect(code).to include("class TestClass < Lutaml::Model::Serializable")
-      expect(code).to include("def self.register_class_with_id")
-    end
-  end
-end

data/spec/lutaml/xml/schema/compiler/element_spec.rb

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

data/spec/lutaml/xml/schema/compiler/group_spec.rb

@@ -1,90 +0,0 @@
-require "spec_helper"
-require "support/xml/schema_helper"
-
-RSpec.describe Lutaml::Model::Schema::XmlCompiler::Group do
-  let(:group) { described_class.new("GroupName", 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 and ref" do
-      g = described_class.new("foo", "bar")
-      expect(g.name).to eq("foo")
-      expect(g.ref).to eq("bar")
-    end
-  end
-
-  describe "#to_xml_mapping" do
-    it "returns import_model_mappings if ref is present" do
-      group.ref = "foo:Bar"
-      group.name = nil
-      expect(group.to_xml_mapping("  ")).to include("import_model_mappings :bar")
-    end
-
-    it "delegates to instance if ref is not present" do
-      instance = instance_double(dummy_class,
-                                 to_xml_mapping: "  map_element :foo, to: :foo\n")
-      group.instance = instance
-      group.ref = nil
-      expect(group.to_xml_mapping("  ")).to include("map_element :foo, to: :foo")
-    end
-  end
-
-  describe "#to_class" do
-    it "renders the group template" do
-      group.name = "GroupName"
-      group.instance = instance_double(dummy_class,
-                                       to_attributes: "  attribute :foo, :string\n", to_xml_mapping: "  map_element :foo, to: :foo\n", required_files: [])
-      expect(group.to_class).to include("class GroupName")
-      expect(group.to_class).to include("attribute :foo, :string")
-      expect(group.to_class).to include("map_element :foo, to: :foo")
-    end
-  end
-
-  describe "#required_files" do
-    it "returns require_relative for ref type when name is blank" do
-      group.name = nil
-      group.ref = "foo:Bar"
-      expect(group.required_files).to eq("require_relative \"bar\"")
-    end
-
-    it "delegates to instance if name is present" do
-      instance = instance_double(dummy_class, required_files: "require 'foo'")
-      group.instance = instance
-      group.name = "GroupName"
-      group.ref = nil
-      expect(group.required_files).to eq("require 'foo'")
-    end
-  end
-
-  describe "#to_attributes" do
-    it "returns import_model_attributes if ref is present" do
-      group.ref = "foo:Bar"
-      group.name = nil
-      expect(group.to_attributes("  ")).to include("import_model_attributes :bar")
-    end
-
-    it "delegates to instance if ref is not present" do
-      instance = instance_double(dummy_class,
-                                 to_attributes: "  attribute :foo, :string\n")
-      group.instance = instance
-      group.ref = nil
-      expect(group.to_attributes("  ")).to include("attribute :foo, :string")
-    end
-  end
-
-  describe "#base_name" do
-    it "returns last part of name or ref" do
-      group.name = "foo:Bar"
-      expect(group.base_name).to eq("Bar")
-      group.name = nil
-      group.ref = "foo:Baz"
-      expect(group.base_name).to eq("Baz")
-    end
-  end
-end

data/spec/lutaml/xml/schema/compiler/restriction_spec.rb

@@ -1,77 +0,0 @@
-require "spec_helper"
-require "support/xml/schema_helper"
-
-RSpec.describe Lutaml::Model::Schema::XmlCompiler::Restriction do
-  let(:restriction) { described_class.new }
-
-  describe "attribute accessors" do
-    it "allows reading and writing all attributes" do
-      restriction.min_inclusive = 1
-      restriction.max_inclusive = 10
-      restriction.min_exclusive = 2
-      restriction.max_exclusive = 9
-      restriction.enumerations = ["A", "B"]
-      restriction.max_length = 5
-      restriction.min_length = 1
-      restriction.base_class = "foo:Bar"
-      restriction.pattern = /abc/
-      restriction.length = 3
-      restriction.transform = "value.upcase"
-      expect(restriction.min_inclusive).to eq(1)
-      expect(restriction.max_inclusive).to eq(10)
-      expect(restriction.enumerations).to eq(["A", "B"])
-      expect(restriction.pattern).to eq(/abc/)
-      expect(restriction.transform).to eq("value.upcase")
-    end
-  end
-
-  describe "#to_method_body" do
-    it "returns method body for all present attributes" do
-      restriction.enumerations = ["A", "B"]
-      restriction.min_inclusive = 1
-      restriction.max_inclusive = 10
-      restriction.pattern = /abc/
-      restriction.transform = "value.upcase"
-      body = restriction.to_method_body("  ")
-      expect(body).to include("options[:values]")
-      expect(body).to include("options[:min]")
-      expect(body).to include("options[:max]")
-      expect(body).to include("options[:pattern]")
-      expect(body).to include("value = value.upcase")
-    end
-
-    it "returns empty string if no attributes are set" do
-      expect(restriction.to_method_body("  ")).to eq("")
-    end
-  end
-
-  describe "#required_files" do
-    it "returns require 'bigdecimal' for decimal base_class" do
-      restriction.base_class = "decimal"
-      expect(restriction.required_files).to eq("require \"bigdecimal\"")
-    end
-
-    it "returns require_relative for non-skippable base_class" do
-      restriction.base_class = "foo:Base"
-      expect(restriction.required_files).to eq("require_relative \"base\"")
-    end
-
-    it "returns nil for skippable base_class" do
-      restriction.base_class = "string"
-      expect(restriction.required_files).to be_nil
-    end
-  end
-
-  describe "private methods" do
-    it "base_class_name returns last part as symbol" do
-      restriction.base_class = "foo:Bar"
-      expect(restriction.send(:base_class_name)).to eq(:Bar)
-    end
-
-    it "casted_enumerations returns super calls for each enumeration" do
-      restriction.enumerations = ["A", "B"]
-      expect(restriction.send(:casted_enumerations)).to include("super(\"A\")")
-      expect(restriction.send(:casted_enumerations)).to include("super(\"B\")")
-    end
-  end
-end