lutaml-model 0.8.2 → 0.8.4

data/spec/lutaml/model/transform_cache_spec.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe "Transform caching" do
+  after { Lutaml::Model::Transform.clear_cache! }
+
+  describe ".cached_transform" do
+    it "returns same instance for same context and register" do
+      klass = Class.new(Lutaml::Model::Serializable) do
+        attribute :name, :string
+      end
+
+      t1 = Lutaml::Model::Transform.cached_transform(klass, :default)
+      t2 = Lutaml::Model::Transform.cached_transform(klass, :default)
+      expect(t1).to equal(t2)
+    end
+
+    it "returns different instances for different contexts" do
+      klass_a = Class.new(Lutaml::Model::Serializable) do
+        attribute :name, :string
+      end
+      klass_b = Class.new(Lutaml::Model::Serializable) do
+        attribute :title, :string
+      end
+
+      t1 = Lutaml::Model::Transform.cached_transform(klass_a, :default)
+      t2 = Lutaml::Model::Transform.cached_transform(klass_b, :default)
+      expect(t1).not_to equal(t2)
+    end
+  end
+
+  describe ".clear_cache!" do
+    it "clears the cache" do
+      klass = Class.new(Lutaml::Model::Serializable) do
+        attribute :name, :string
+      end
+
+      Lutaml::Model::Transform.cached_transform(klass, :default)
+      expect(Lutaml::Model::Transform.cache_size).to be > 0
+
+      Lutaml::Model::Transform.clear_cache!
+      expect(Lutaml::Model::Transform.cache_size).to eq(0)
+    end
+  end
+
+  describe "cache eviction" do
+    it "evicts entries when exceeding MAX_CACHE_SIZE" do
+      stub_const("Lutaml::Model::Transform::MAX_CACHE_SIZE", 4)
+
+      classes = Array.new(6) do |i|
+        Class.new(Lutaml::Model::Serializable) do
+          attribute :"attr_#{i}", :string
+        end
+      end
+
+      classes.each { |k| Lutaml::Model::Transform.cached_transform(k, :default) }
+
+      expect(Lutaml::Model::Transform.cache_size).to be <= 4
+    end
+  end
+end

data/spec/lutaml/model/transform_dynamic_attributes_spec.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe "Transform with dynamically added attributes" do
+  before do
+    Lutaml::Model::GlobalContext.clear_caches
+  end
+
+  it "picks up attributes added after initial class definition" do
+    base_class = Class.new(Lutaml::Model::Serializable) do
+      attribute :name, :string
+
+      xml do
+        root "test"
+        map_element "name", to: :name
+      end
+
+      def self.name
+        "DynamicAttributeTestClass"
+      end
+    end
+
+    # Parse once to populate Transform cache
+    base_class.from_xml("<test><name>initial</name></test>")
+
+    # Dynamically add a new attribute and mapping (like xmi EaRoot.load_extension)
+    base_class.class_eval do
+      attribute :extra, :string
+
+      xml do
+        map_element "extra", to: :extra
+      end
+    end
+
+    # The Transform must see the newly added attribute
+    result = base_class.from_xml("<test><name>hello</name><extra>world</extra></test>")
+    expect(result.name).to eq("hello")
+    expect(result.extra).to eq("world")
+  end
+end

data/spec/lutaml/model/uninitialized_class_deep_dup_spec.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe "UninitializedClass deep_dup compatibility" do
+  let(:uninitialized) { Lutaml::Model::UninitializedClass.instance }
+
+  # Replicates the rng gem's ExternalRefResolver#deep_dup pattern
+  def deep_dup(obj)
+    case obj
+    when Array
+      obj.map { |o| deep_dup(o) }
+    when Hash
+      obj.each_with_object({}) { |(k, v), h| h[deep_dup(k)] = deep_dup(v) }
+    when NilClass, Symbol, Numeric, TrueClass, FalseClass
+      obj
+    else
+      obj.dup
+    end
+  end
+
+  it "does not raise TypeError when deep_dup encounters UninitializedClass in a hash value" do
+    data = { "key" => "value", "missing" => uninitialized }
+    result = deep_dup(data)
+    expect(result["missing"]).to equal(uninitialized)
+  end
+
+  it "does not raise TypeError when deep_dup encounters UninitializedClass in an array" do
+    data = ["hello", uninitialized, "world"]
+    result = deep_dup(data)
+    expect(result[1]).to equal(uninitialized)
+  end
+
+  it "does not raise TypeError when deep_dup encounters UninitializedClass as hash key" do
+    data = { uninitialized => "value" }
+    result = deep_dup(data)
+    expect(result.keys.first).to equal(uninitialized)
+  end
+end

data/spec/lutaml/model/uninitialized_class_spec.rb

@@ -77,8 +77,8 @@ RSpec.describe Lutaml::Model::UninitializedClass do
     end
 
     context "when method doesn't end with '?'" do
-      it "raises NoMethodError" do
-        expect { uninitialized.unknown_method }.to raise_error(NoMethodError)
+      it "returns nil" do
+        expect(uninitialized.unknown_method).to be_nil
       end
     end
   end
@@ -93,4 +93,16 @@ RSpec.describe Lutaml::Model::UninitializedClass do
       expect(uninitialized.respond_to?(:unknown_method)).to be false
     end
   end
+
+  describe "#dup" do
+    it "returns self" do
+      expect(uninitialized.dup).to equal(uninitialized)
+    end
+  end
+
+  describe "#clone" do
+    it "returns self" do
+      expect(uninitialized.clone).to equal(uninitialized)
+    end
+  end
 end

data/spec/lutaml/model/validation/concerns/has_issues_spec.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require "lutaml/model/validation_framework"
+
+RSpec.describe Lutaml::Model::Validation::HasIssues do
+  let(:error_issue) do
+    Lutaml::Model::Validation::Issue.new(
+      severity: "error", code: "E-001", message: "bad",
+    )
+  end
+
+  let(:warning_issue) do
+    Lutaml::Model::Validation::Issue.new(
+      severity: "warning", code: "W-001", message: "meh",
+    )
+  end
+
+  let(:info_issue) do
+    Lutaml::Model::Validation::Issue.new(
+      severity: "info", code: "I-001", message: "fyi",
+    )
+  end
+
+  let(:notice_issue) do
+    Lutaml::Model::Validation::Issue.new(
+      severity: "notice", code: "N-001", message: "note",
+    )
+  end
+
+  let(:container) do
+    all_issues = [error_issue, warning_issue, info_issue, notice_issue]
+    klass = Class.new do
+      include Lutaml::Model::Validation::HasIssues
+
+      attr_reader :issues
+
+      def initialize(issues)
+        @issues = issues
+      end
+    end
+    klass.new(all_issues)
+  end
+
+  it "filters errors" do
+    expect(container.errors).to eq([error_issue])
+  end
+
+  it "filters warnings" do
+    expect(container.warnings).to eq([warning_issue])
+  end
+
+  it "filters infos" do
+    expect(container.infos).to eq([info_issue])
+  end
+
+  it "filters notices" do
+    expect(container.notices).to eq([notice_issue])
+  end
+
+  it "returns empty arrays when no matching severity" do
+    only_errors = Class.new do
+      include Lutaml::Model::Validation::HasIssues
+
+      def issues
+        [Lutaml::Model::Validation::Issue.new(
+          severity: "error", code: "X", message: "y",
+        )]
+      end
+    end.new
+
+    expect(only_errors.warnings).to be_empty
+    expect(only_errors.infos).to be_empty
+    expect(only_errors.notices).to be_empty
+  end
+end

data/spec/lutaml/model/validation/context_spec.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require "lutaml/model/validation_framework"
+
+RSpec.describe Lutaml::Model::Validation::Context do
+  subject(:context) { described_class.new }
+
+  it "starts with empty errors" do
+    expect(context.errors).to be_empty
+  end
+
+  describe "#add_error" do
+    it "accumulates errors" do
+      issue = Lutaml::Model::Validation::Issue.new(
+        severity: "error", code: "T-001", message: "bad",
+      )
+      context.add_error(issue)
+      expect(context.errors.length).to eq(1)
+      expect(context.errors.first).to eq(issue)
+    end
+  end
+
+  describe "#add_errors" do
+    it "concatenates multiple errors" do
+      issues = Array.new(2) do |i|
+        Lutaml::Model::Validation::Issue.new(
+          severity: "error", code: "T-#{i}", message: "bad #{i}",
+        )
+      end
+      context.add_errors(issues)
+      expect(context.errors.length).to eq(2)
+    end
+  end
+
+  describe "#rule_state" do
+    it "provides per-rule state hash" do
+      state = context.rule_state("R-001")
+      state[:count] = 5
+      expect(context.rule_state("R-001")[:count]).to eq(5)
+    end
+
+    it "isolates state between rules" do
+      context.rule_state("R-001")[:val] = "a"
+      context.rule_state("R-002")[:val] = "b"
+      expect(context.rule_state("R-001")[:val]).to eq("a")
+      expect(context.rule_state("R-002")[:val]).to eq("b")
+    end
+  end
+
+  describe "#reset!" do
+    it "clears errors and state" do
+      context.add_error(double("issue"))
+      context.rule_state("R")[:x] = 1
+      context.reset!
+      expect(context.errors).to be_empty
+      expect(context.rule_state("R")).to be_empty
+    end
+  end
+end

data/spec/lutaml/model/validation/issue_spec.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require "lutaml/model/validation_framework"
+
+RSpec.describe Lutaml::Model::Validation::Issue do
+  subject(:issue) do
+    described_class.new(
+      severity: "error",
+      code: "TEST-001",
+      message: "Something is wrong",
+      location: "file.xml",
+      line: 42,
+      suggestion: "Fix it",
+    )
+  end
+
+  describe "SEVERITIES constant" do
+    it "defines allowed severity levels" do
+      expect(described_class::SEVERITIES).to eq(%w[error warning info notice])
+    end
+  end
+
+  describe "severity validation" do
+    it "accepts valid severities" do
+      described_class::SEVERITIES.each do |sev|
+        expect { described_class.new(severity: sev, code: "T", message: "m") }
+          .not_to raise_error
+      end
+    end
+
+    it "rejects invalid severity" do
+      expect do
+        described_class.new(severity: "critical", code: "T", message: "m")
+      end.to raise_error(ArgumentError, /Invalid severity: critical/)
+    end
+
+    it "allows nil severity" do
+      expect { described_class.new(severity: nil, code: "T", message: "m") }
+        .not_to raise_error
+    end
+  end
+
+  describe "serialization" do
+    it "serializes to JSON" do
+      parsed = JSON.parse(issue.to_json)
+      expect(parsed["severity"]).to eq("error")
+      expect(parsed["code"]).to eq("TEST-001")
+      expect(parsed["message"]).to eq("Something is wrong")
+      expect(parsed["location"]).to eq("file.xml")
+      expect(parsed["line"]).to eq(42)
+      expect(parsed["suggestion"]).to eq("Fix it")
+    end
+
+    it "round-trips through JSON" do
+      restored = described_class.from_json(issue.to_json)
+      expect(restored.code).to eq("TEST-001")
+      expect(restored.message).to eq("Something is wrong")
+    end
+  end
+
+  describe "severity predicates" do
+    it "returns correct predicate for error" do
+      expect(issue).to be_error
+      expect(issue).not_to be_warning
+      expect(issue).not_to be_info
+      expect(issue).not_to be_notice
+    end
+
+    it "returns correct predicate for warning" do
+      warning = described_class.new(severity: "warning", code: "W",
+                                    message: "m")
+      expect(warning).to be_warning
+      expect(warning).not_to be_error
+    end
+  end
+end

data/spec/lutaml/model/validation/layer_result_spec.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require "lutaml/model/validation_framework"
+
+RSpec.describe Lutaml::Model::Validation::LayerResult do
+  subject(:layer) do
+    described_class.new(
+      name: "Structure",
+      status: "fail",
+      duration_ms: 15,
+      issues: [error_issue, warning_issue],
+    )
+  end
+
+  let(:error_issue) do
+    Lutaml::Model::Validation::Issue.new(
+      severity: "error", code: "E-001", message: "bad",
+    )
+  end
+
+  let(:warning_issue) do
+    Lutaml::Model::Validation::Issue.new(
+      severity: "warning", code: "W-001", message: "meh",
+    )
+  end
+
+  it "serializes to JSON" do
+    parsed = JSON.parse(layer.to_json)
+    expect(parsed["name"]).to eq("Structure")
+    expect(parsed["status"]).to eq("fail")
+    expect(parsed["issues"].length).to eq(2)
+  end
+
+  describe "#pass? / #fail?" do
+    it "checks status" do
+      expect(layer).not_to be_pass
+      expect(layer).to be_fail
+    end
+
+    it "returns true for pass status" do
+      passing = described_class.new(name: "x", status: "pass")
+      expect(passing).to be_pass
+    end
+  end
+
+  describe "severity filtering via HasIssues" do
+    it "filters errors" do
+      expect(layer.errors.length).to eq(1)
+      expect(layer.errors.first.code).to eq("E-001")
+    end
+
+    it "filters warnings" do
+      expect(layer.warnings.length).to eq(1)
+      expect(layer.warnings.first.code).to eq("W-001")
+    end
+
+    it "returns empty for infos" do
+      expect(layer.infos).to be_empty
+    end
+
+    it "returns empty for notices" do
+      expect(layer.notices).to be_empty
+    end
+  end
+end

data/spec/lutaml/model/validation/profile_spec.rb

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require "lutaml/model/validation_framework"
+require "tmpdir"
+require "yaml"
+
+RSpec.describe Lutaml::Model::Validation::Profile do
+  let(:registry) { Lutaml::Model::Validation.new_registry }
+
+  let(:profile) do
+    described_class.new(
+      name: "basic",
+      description: "Basic checks",
+      rule_names: ["TestRule"],
+    )
+  end
+
+  it "stores profile attributes" do
+    expect(profile.name).to eq("basic")
+    expect(profile.description).to eq("Basic checks")
+    expect(profile.rule_names).to eq(["TestRule"])
+    expect(profile.imports).to eq([])
+  end
+
+  describe ".load" do
+    it "loads profile from YAML file" do
+      Dir.mktmpdir do |dir|
+        yaml_path = File.join(dir, "basic.yml")
+        File.write(yaml_path, YAML.dump({
+                                          "name" => "loaded",
+                                          "description" => "Loaded profile",
+                                          "rules" => ["RuleA", "RuleB"],
+                                          "import" => ["base"],
+                                        }))
+        loaded = described_class.load(yaml_path)
+        expect(loaded.name).to eq("loaded")
+        expect(loaded.rule_names).to eq(["RuleA", "RuleB"])
+        expect(loaded.imports).to eq(["base"])
+      end
+    end
+
+    it "rejects YAML without a name key" do
+      Dir.mktmpdir do |dir|
+        yaml_path = File.join(dir, "bad.yml")
+        File.write(yaml_path, YAML.dump({ "description" => "no name" }))
+        expect { described_class.load(yaml_path) }
+          .to raise_error(ArgumentError, /must contain a 'name' string key/)
+      end
+    end
+
+    it "rejects non-hash YAML content" do
+      Dir.mktmpdir do |dir|
+        yaml_path = File.join(dir, "array.yml")
+        File.write(yaml_path, YAML.dump(["just", "an", "array"]))
+        expect { described_class.load(yaml_path) }
+          .to raise_error(ArgumentError, /must contain a 'name' string key/)
+      end
+    end
+  end
+
+  describe "#resolve" do
+    context "with imports" do
+      let(:base_rule_class) do
+        Class.new(Lutaml::Model::Validation::Rule) do
+          def self.name = "BaseRule"
+          def code = "BASE-001"
+        end
+      end
+
+      let(:extra_rule_class) do
+        Class.new(Lutaml::Model::Validation::Rule) do
+          def self.name = "ExtraRule"
+          def code = "EXTRA-001"
+        end
+      end
+
+      let(:base_profile) do
+        described_class.new(name: "base", rule_names: ["BaseRule"])
+      end
+
+      let(:extended_profile) do
+        described_class.new(
+          name: "extended",
+          rule_names: ["ExtraRule"],
+          imports: ["base"],
+        )
+      end
+
+      it "resolves imports" do
+        registry.register(base_rule_class)
+        registry.register(extra_rule_class)
+        profiles = { "base" => base_profile, "extended" => extended_profile }
+
+        rules = extended_profile.resolve(registry, profiles)
+        codes = rules.map(&:code)
+        expect(codes).to include("BASE-001", "EXTRA-001")
+      end
+
+      it "ignores missing imports" do
+        registry.register(extra_rule_class)
+        orphan = described_class.new(
+          name: "orphan",
+          rule_names: ["ExtraRule"],
+          imports: ["nonexistent"],
+        )
+        rules = orphan.resolve(registry, {})
+        expect(rules.map(&:code)).to eq(["EXTRA-001"])
+      end
+
+      it "detects circular imports" do
+        a = described_class.new(name: "a", imports: ["b"])
+        b = described_class.new(name: "b", imports: ["a"])
+        profiles = { "a" => a, "b" => b }
+        expect { a.resolve(registry, profiles) }
+          .to raise_error(ArgumentError, /Circular profile import detected: a/)
+      end
+
+      it "detects deep circular imports" do
+        a = described_class.new(name: "a", imports: ["b"])
+        b = described_class.new(name: "b", imports: ["c"])
+        c = described_class.new(name: "c", imports: ["a"])
+        profiles = { "a" => a, "b" => b, "c" => c }
+        expect { a.resolve(registry, profiles) }
+          .to raise_error(ArgumentError, /Circular profile import detected/)
+      end
+    end
+
+    it "skips rules with unknown class names" do
+      result = profile.resolve(registry)
+      expect(result).to be_empty
+    end
+  end
+end

data/spec/lutaml/model/validation/registry_spec.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require "lutaml/model/validation_framework"
+
+RSpec.describe Lutaml::Model::Validation::Registry do
+  subject(:registry) { described_class.new }
+
+  let(:rule_class) do
+    Class.new(Lutaml::Model::Validation::Rule) do
+      def code = "REG-001"
+      def category = :test
+    end
+  end
+
+  before { registry.register(rule_class) }
+
+  it "registers and returns rule instances" do
+    rules = registry.all
+    expect(rules.length).to eq(1)
+    expect(rules.first).to be_a(rule_class)
+    expect(rules.first.code).to eq("REG-001")
+  end
+
+  it "caches rule instances" do
+    first_call = registry.all
+    second_call = registry.all
+    expect(first_call).to equal(second_call)
+  end
+
+  it "invalidates cache on new registration" do
+    first = registry.all
+    new_rule = Class.new(Lutaml::Model::Validation::Rule) do
+      def code = "REG-002"
+    end
+    registry.register(new_rule)
+    expect(registry.all).not_to equal(first)
+    expect(registry.all.length).to eq(2)
+  end
+
+  it "prevents duplicate registration" do
+    registry.register(rule_class)
+    expect(registry.size).to eq(1)
+  end
+
+  it "filters by category" do
+    rules = registry.for_category(:test)
+    expect(rules.length).to eq(1)
+    expect(registry.for_category(:other)).to be_empty
+  end
+
+  it "finds by code" do
+    rule = registry.find("REG-001")
+    expect(rule).not_to be_nil
+    expect(rule.code).to eq("REG-001")
+  end
+
+  it "returns nil for unknown code" do
+    expect(registry.find("UNKNOWN")).to be_nil
+  end
+
+  it "resets" do
+    registry.reset!
+    expect(registry.size).to eq(0)
+    expect(registry.all).to be_empty
+  end
+
+  it "returns rule classes" do
+    expect(registry.rule_classes).to eq([rule_class])
+  end
+
+  it "returns a defensive copy of rule_classes" do
+    classes = registry.rule_classes
+    classes << String
+    expect(registry.rule_classes.length).to eq(1)
+  end
+
+  describe "#auto_discover" do
+    it "requires rule files from a directory" do
+      Dir.mktmpdir do |dir|
+        rule_file = File.join(dir, "discovered_rule.rb")
+        File.write(rule_file, <<~RUBY)
+          class DiscoveredTestRule < Lutaml::Model::Validation::Rule
+            def code = "DISC-001"
+          end
+        RUBY
+
+        registry.auto_discover(dir, pattern: "*_rule.rb")
+        registry.register(DiscoveredTestRule)
+        expect(registry.find("DISC-001")).not_to be_nil
+      end
+    end
+  end
+end