lutaml-model 0.8.17 → 0.8.18

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

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

@@ -1,61 +0,0 @@
-require "spec_helper"
-require "support/xml/schema_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 do
-        simple_content.instances.size
-      end)
-    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

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

@@ -1,184 +0,0 @@
-require "spec_helper"
-require "support/xml/schema_helper"
-
-RSpec.describe Lutaml::Model::Schema::XmlCompiler::SimpleType do
-  let(:class_name) { "TestType" }
-  let(:base_class) { "string" }
-  let(:unions) { [] }
-  let(:simple_type) { described_class.new(class_name, unions) }
-
-  describe "#initialize" do
-    it "sets class_name and unions" do
-      expect(simple_type.class_name).to eq(class_name)
-      expect(simple_type.unions).to eq([])
-    end
-
-    it "allows unions to be set" do
-      st = described_class.new("UnionType", ["foo", "bar"])
-      expect(st.unions).to eq(["foo", "bar"])
-    end
-  end
-
-  describe "attribute accessors" do
-    it "allows reading and writing base_class and instance" do
-      simple_type.base_class = "integer"
-      expect(simple_type.base_class).to eq("integer")
-      simple_type.instance = :foo
-      expect(simple_type.instance).to eq(:foo)
-    end
-  end
-
-  describe "#to_class" do
-    before do
-      simple_type.base_class = base_class
-      simple_type.instance = Lutaml::Model::Schema::XmlCompiler::Restriction.new
-    end
-
-    it "renders the instance model template when no unions" do
-      result = simple_type.to_class
-      expect(result).to include("class TestType")
-      expect(result).to include("def self.cast")
-      expect(result).to include("register_class_with_id")
-    end
-
-    it "renders the union model template when unions are present" do
-      st = described_class.new("UnionType", ["foo", "bar"])
-      st.base_class = base_class
-      st.instance = Lutaml::Model::Schema::XmlCompiler::Restriction.new
-      result = st.to_class
-      expect(result).to include("class UnionType < Lutaml::Model::Type::Value")
-      expect(result).to include("def self.cast")
-      expect(result).to include("register_class_with_id")
-    end
-
-    it "respects the :indent option" do
-      result = simple_type.to_class(options: { indent: 4 })
-      expect(result).to include("    def self.cast") # 4 spaces
-    end
-  end
-
-  describe "#required_files" do
-    it "returns nil if instance is nil" do
-      expect(simple_type.required_files).to be_empty
-    end
-
-    it "returns required files from instance and parent class when not using module namespace" do
-      restriction = Lutaml::Model::Schema::XmlCompiler::Restriction.new
-      allow(restriction).to receive(:required_files).and_return(["require 'foo'"])
-      simple_type.instance = restriction
-      allow(simple_type).to receive_messages(require_parent?: true,
-                                             parent_class: "ParentClass")
-      expect(simple_type.required_files).to include("require 'foo'")
-      # When not using module_namespace, require_relative is added for parent
-      expect(simple_type.required_files).to include("require_relative \"parent_class\"")
-    end
-  end
-
-  describe "private methods" do
-    it "klass_name returns camel case" do
-      expect(simple_type.send(:klass_name)).to eq("TestType")
-    end
-
-    it "parent_class returns correct class for skippable and non-skippable" do
-      simple_type.base_class = "string"
-      expect(simple_type.send(:parent_class)).to eq("Lutaml::Model::Type::String")
-      simple_type.base_class = "nonNegativeInteger"
-      expect(simple_type.send(:parent_class)).to eq("NonNegativeInteger")
-      simple_type.base_class = nil
-      expect(simple_type.send(:parent_class)).to eq("Lutaml::Model::Type::Value")
-    end
-
-    it "require_parent? returns correct boolean" do
-      simple_type.base_class = "string"
-      expect(simple_type.send(:require_parent?)).to be false
-      simple_type.base_class = "unknownType"
-      expect(simple_type.send(:require_parent?)).to be true
-    end
-
-    it "union_class_method_body returns correct code" do
-      st = described_class.new("UnionType", ["foo:Bar", "baz:Qux"])
-      expect(st.send(:union_class_method_body)).to include("Lutaml::Model::GlobalContext.resolve_type(:bar, @register).cast(value, options)")
-      expect(st.send(:union_class_method_body)).to include("Lutaml::Model::GlobalContext.resolve_type(:qux, @register).cast(value, options)")
-    end
-
-    it "union_required_files returns require_relative for non-skippable union type" do
-      st = described_class.new("UnionType", ["foo:Bar", "baz:string"])
-      expect(st.send(:union_required_files)).to include("require_relative \"bar\"")
-    end
-  end
-
-  describe ".setup_supported_types" do
-    it "returns a hash of supported types with correct instances" do
-      types = described_class.setup_supported_types
-      expect(types).to be_a(Hash)
-      expect(types.keys).to include("nonNegativeInteger")
-      expect(types["nonNegativeInteger"]).to be_a(described_class)
-      expect(types["nonNegativeInteger"].base_class).to eq("string")
-    end
-  end
-
-  describe ".setup_restriction" do
-    it "returns nil if validations is nil" do
-      expect(described_class.setup_restriction("string", nil)).to be_nil
-    end
-
-    it "returns a Restriction with correct values" do
-      validations = { min_inclusive: 1, max_inclusive: 10, pattern: /foo/,
-                      transform: "bar" }
-      restriction = described_class.setup_restriction("string", validations)
-      expect(restriction).to be_a(Lutaml::Model::Schema::XmlCompiler::Restriction)
-      expect(restriction.base_class).to eq("string")
-      expect(restriction.min_inclusive).to eq(1)
-      expect(restriction.max_inclusive).to eq(10)
-      expect(restriction.pattern).to eq(/foo/)
-      expect(restriction.transform).to eq("bar")
-    end
-  end
-
-  describe ".skippable?" do
-    it "returns true for skippable types" do
-      expect(described_class.skippable?("string")).to be true
-      expect(described_class.skippable?("int")).to be true
-    end
-
-    it "returns false for non-skippable types" do
-      expect(described_class.skippable?("nonNegativeInteger")).to be false
-      expect(described_class.skippable?("id")).to be false
-    end
-  end
-
-  describe "edge cases" do
-    it "handles unknown base_class gracefully" do
-      simple_type.base_class = nil
-      expect { simple_type.send(:parent_class) }.not_to raise_error
-      expect(simple_type.send(:parent_class)).to eq("Lutaml::Model::Type::Value")
-    end
-
-    it "handles unions with skippable and non-skippable types" do
-      st = described_class.new("UnionType", ["foo:string", "bar:CustomType"])
-      expect(st.send(:union_required_files)).to include("require_relative \"custom_type\"")
-      expect(st.send(:union_required_files)).not_to include("string")
-    end
-  end
-
-  describe "integration" do
-    it "generates valid Ruby code for a simple type" do
-      simple_type.base_class = "string"
-      simple_type.instance = Lutaml::Model::Schema::XmlCompiler::Restriction.new
-      code = simple_type.to_class
-      expect(code).to include("class TestType")
-      expect(code).to include("def self.cast")
-      expect(code).to include("register_class_with_id")
-    end
-
-    it "generates valid Ruby code for a union type" do
-      st = described_class.new("UnionType", ["foo:Bar", "baz:Qux"])
-      st.base_class = "string"
-      st.instance = Lutaml::Model::Schema::XmlCompiler::Restriction.new
-      code = st.to_class
-      expect(code).to include("class UnionType < Lutaml::Model::Type::Value")
-      expect(code).to include("def self.cast")
-      expect(code).to include("register_class_with_id")
-    end
-  end
-end