lutaml-model 0.7.3 → 0.7.5

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

@@ -0,0 +1,173 @@
+require "spec_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 { complex_type.instances.size })
+    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: 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", prefix: "ex", indent: 2 })
+      expect(code).to include("namespace \"http://example.com\"", "\"ex\"")
+    end
+  end
+
+  describe "#required_files" do
+    it "returns require lutaml/model for default base_class" do
+      expect(complex_type.required_files).to include("require \"lutaml/model\"")
+    end
+
+    it "returns require_relative for custom base_class" do
+      ct = described_class.new(base_class: "foo:BarBase")
+      expect(ct.required_files).to include("require_relative \"bar_base\"")
+    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 "base_class_require returns correct require line" do
+      expect(complex_type.send(:base_class_require)).to eq("require \"lutaml/model\"")
+      ct = described_class.new(base_class: "foo:BarBase")
+      expect(ct.send(:base_class_require)).to eq("require_relative \"bar_base\"")
+    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/model/schema/xml_compiler/element_spec.rb

@@ -0,0 +1,63 @@
+require "spec_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/model/schema/xml_compiler/group_spec.rb

@@ -0,0 +1,86 @@
+require "spec_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 if name is blank and ref is present" do
+      group.name = nil
+      group.ref = "foo:Bar"
+      expect(group.required_files).to include("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/model/schema/xml_compiler/restriction_spec.rb

@@ -0,0 +1,76 @@
+require "spec_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

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

@@ -0,0 +1,59 @@
+require "spec_helper"
+
+RSpec.describe Lutaml::Model::Schema::XmlCompiler::Sequence do
+  let(:sequence) { 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(sequence.instances).to eq([])
+    end
+  end
+
+  describe "#<<" do
+    it "adds instances to the list" do
+      instance = instance_double(dummy_class, to_attributes: "  attribute :foo, :string\n", to_xml_mapping: "    map_element :foo, to: :foo\n", required_files: "require 'foo'")
+      expect { sequence << instance }.to change { sequence.instances.size }.by(1)
+      expect(sequence.instances).to include(instance)
+    end
+
+    it "ignores nil instances" do
+      expect { sequence << nil }.not_to(change { sequence.instances.size })
+    end
+  end
+
+  describe "#to_attributes" do
+    it "returns joined attributes from instances" do
+      instance = instance_double(dummy_class, to_attributes: "  attribute :foo, :string\n")
+      sequence << instance
+      expect(sequence.to_attributes("  ")).to include("attribute :foo, :string")
+    end
+  end
+
+  describe "#to_xml_mapping" do
+    it "returns empty string if no content" do
+      expect(sequence.to_xml_mapping("  ")).to eq("")
+    end
+
+    it "returns xml mapping block if content exists" do
+      instance = instance_double(dummy_class, to_xml_mapping: "    map_element :foo, to: :foo\n")
+      sequence << instance
+      expect(sequence.to_xml_mapping("  ")).to include("sequence do")
+      expect(sequence.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'")
+      sequence << instance
+      expect(sequence.required_files).to include("require 'foo'")
+    end
+  end
+end

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

@@ -0,0 +1,55 @@
+require "spec_helper"
+
+RSpec.describe Lutaml::Model::Schema::XmlCompiler::SimpleContent do
+  let(:simple_content) { 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 and nil base_class" do
+      expect(simple_content.instances).to eq([])
+      expect(simple_content.base_class).to be_nil
+    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 { simple_content << instance }.to change { simple_content.instances.size }.by(1)
+      expect(simple_content.instances).to include(instance)
+    end
+
+    it "ignores nil instances" do
+      expect { simple_content << nil }.not_to(change { simple_content.instances.size })
+    end
+  end
+
+  describe "#to_attributes" do
+    it "returns joined attributes from instances" do
+      instance = instance_double(dummy_class, to_attributes: "attr")
+      simple_content << instance
+      expect(simple_content.to_attributes("  ")).to include("attr")
+    end
+  end
+
+  describe "#to_xml_mapping" do
+    it "returns joined xml mappings from instances" do
+      instance = instance_double(dummy_class, to_xml_mapping: "xml")
+      simple_content << instance
+      expect(simple_content.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")
+      simple_content << instance
+      expect(simple_content.required_files).to include("files")
+    end
+  end
+end