lutaml-model 0.8.3 → 0.8.5

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

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require "lutaml/model/validation_framework"
+
+RSpec.describe Lutaml::Model::Validation::Rule do
+  subject(:rule) { described_class.new }
+
+  describe "defaults" do
+    it "returns nil code" do
+      expect(rule.code).to be_nil
+    end
+
+    it "returns :general category" do
+      expect(rule.category).to eq(:general)
+    end
+
+    it "returns error severity" do
+      expect(rule.severity).to eq("error")
+    end
+
+    it "is always applicable" do
+      expect(rule.applicable?(nil)).to be true
+      expect(rule.applicable?({})).to be true
+    end
+
+    it "returns empty issues from check" do
+      expect(rule.check(nil)).to eq([])
+    end
+
+    it "is not deferred" do
+      expect(rule.needs_deferred?).to be false
+    end
+
+    it "returns nil from collect" do
+      expect(rule.collect(:element, nil)).to be_nil
+    end
+
+    it "returns empty array from complete" do
+      expect(rule.complete(nil)).to eq([])
+    end
+  end
+
+  describe "custom subclass" do
+    let(:custom_rule_class) do
+      Class.new(described_class) do
+        def code = "CUSTOM-001"
+        def category = :custom
+        def severity = "warning"
+
+        def applicable?(context)
+          context&.dig(:enabled) != false
+        end
+
+        def check(_context)
+          [issue("Found a problem")]
+        end
+      end
+    end
+
+    it "overrides defaults" do
+      rule = custom_rule_class.new
+      expect(rule.code).to eq("CUSTOM-001")
+      expect(rule.category).to eq(:custom)
+      expect(rule.severity).to eq("warning")
+    end
+
+    it "produces issues via helper" do
+      rule = custom_rule_class.new
+      issues = rule.check(nil)
+      expect(issues.length).to eq(1)
+      expect(issues.first.code).to eq("CUSTOM-001")
+      expect(issues.first.severity).to eq("warning")
+      expect(issues.first.message).to eq("Found a problem")
+    end
+
+    it "respects applicable?" do
+      rule = custom_rule_class.new
+      expect(rule.applicable?({ enabled: true })).to be true
+      expect(rule.applicable?({ enabled: false })).to be false
+    end
+
+    it "allows issue helper to override severity and code" do
+      klass = Class.new(described_class) do
+        def code = "OVERRIDE"
+        def severity = "error"
+
+        def check(_context)
+          [issue("msg", severity: "info", code: "OTHER")]
+        end
+      end
+      issues = klass.new.check(nil)
+      expect(issues.first.severity).to eq("info")
+      expect(issues.first.code).to eq("OTHER")
+    end
+  end
+
+  describe "streaming subclass" do
+    let(:streaming_rule_class) do
+      Class.new(described_class) do
+        def code = "STREAM-001"
+        def needs_deferred? = true
+
+        def collect(element, context)
+          state = context.rule_state(code)
+          state[:items] ||= []
+          state[:items] << element
+        end
+
+        def complete(context)
+          state = context.rule_state(code)
+          return [] unless state[:items]&.any?
+
+          [issue("Collected #{state[:items].length} items")]
+        end
+      end
+    end
+
+    it "signals deferred collection" do
+      rule = streaming_rule_class.new
+      expect(rule.needs_deferred?).to be true
+    end
+
+    it "collects elements and reports in complete" do
+      ctx = Lutaml::Model::Validation::Context.new
+      rule = streaming_rule_class.new
+      rule.collect("item_a", ctx)
+      rule.collect("item_b", ctx)
+      issues = rule.complete(ctx)
+      expect(issues.length).to eq(1)
+      expect(issues.first.message).to eq("Collected 2 items")
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe "Lutaml::Model::Validation with UninitializedClass" do
+  before do
+    stub_const("ValidateWithUninitializedModel", Class.new(Lutaml::Model::Serializable) do
+      attribute :name, :string
+      attribute :role, :string, values: %w[admin guest], default: -> { "guest" }
+    end)
+  end
+
+  it "does not crash when validating with uninitialized attributes" do
+    model = ValidateWithUninitializedModel.new
+    # name is uninitialized, but validate should not crash
+    expect { model.validate }.not_to raise_error
+  end
+
+  it "still catches value constraint violations" do
+    model = ValidateWithUninitializedModel.new(role: "hacker")
+    errors = model.validate
+    expect(errors).not_to be_empty
+  end
+
+  it "returns empty errors for valid instance" do
+    model = ValidateWithUninitializedModel.new(name: "ok", role: "admin")
+    expect(model.validate).to be_empty
+  end
+end

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

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require "lutaml/model/validation_framework"
+
+RSpec.describe Lutaml::Model::Validation::ValidationError do
+  it "is a StandardError" do
+    expect(described_class).to be < StandardError
+  end
+
+  it "stores message" do
+    error = described_class.new("Something broke")
+    expect(error.message).to eq("Something broke")
+  end
+
+  it "stores issues" do
+    issue = Lutaml::Model::Validation::Issue.new(
+      severity: "error", code: "E-001", message: "bad",
+    )
+    error = described_class.new("Failed", issues: [issue])
+    expect(error.issues.length).to eq(1)
+    expect(error.issues.first.code).to eq("E-001")
+  end
+
+  it "defaults issues to empty array" do
+    error = described_class.new("Failed")
+    expect(error.issues).to eq([])
+  end
+end

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

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require "lutaml/model/validation_framework"
+
+RSpec.describe Lutaml::Model::Validation, ".validate / .validate!" do
+  let(:registry) { described_class.new_registry }
+
+  let(:rule_a_class) do
+    Class.new(Lutaml::Model::Validation::Rule) do
+      def code = "E2E-001"
+      def severity = "error"
+
+      def check(context)
+        context[:items].empty? ? [issue("No items found")] : []
+      end
+    end
+  end
+
+  let(:rule_b_class) do
+    Class.new(Lutaml::Model::Validation::Rule) do
+      def code = "E2E-002"
+      def severity = "warning"
+
+      def check(context)
+        context[:items].length > 100 ? [issue("Too many items")] : []
+      end
+    end
+  end
+
+  before do
+    registry.register(rule_a_class)
+    registry.register(rule_b_class)
+  end
+
+  describe ".validate" do
+    it "finds no issues with valid data" do
+      issues = described_class.validate({ items: (1..50).to_a }, registry)
+      expect(issues).to be_empty
+    end
+
+    it "finds errors for empty items" do
+      issues = described_class.validate({ items: [] }, registry)
+      expect(issues.length).to eq(1)
+      expect(issues.first.code).to eq("E2E-001")
+      expect(issues.first).to be_error
+    end
+
+    it "finds warnings for too many items" do
+      issues = described_class.validate({ items: (1..101).to_a }, registry)
+      expect(issues.length).to eq(1)
+      expect(issues.first.code).to eq("E2E-002")
+      expect(issues.first).to be_warning
+    end
+
+    it "skips inapplicable rules" do
+      skip_rule = Class.new(Lutaml::Model::Validation::Rule) do
+        def code = "SKIP"
+        def applicable?(_ctx) = false
+        def check(_ctx) = [issue("should not appear")]
+      end
+      registry.register(skip_rule)
+      issues = described_class.validate({ items: [1] }, registry)
+      expect(issues).to be_empty
+    end
+
+    it "does not crash with contexts that support add_error" do
+      Lutaml::Model::Validation::Context.new
+      # Use plain hash for data — rules expect [:items]
+      issues = described_class.validate({ items: [] }, registry)
+      expect(issues.length).to eq(1)
+      # Plain hash doesn't accumulate, but validate still works
+    end
+  end
+
+  describe ".validate!" do
+    it "raises on errors" do
+      expect do
+        described_class.validate!({ items: [] }, registry)
+      end.to raise_error(Lutaml::Model::Validation::ValidationError, /E2E-001/)
+    end
+
+    it "exposes issues on ValidationError" do
+      described_class.validate!({ items: [] }, registry)
+    rescue Lutaml::Model::Validation::ValidationError => e
+      expect(e.issues.length).to eq(1)
+      expect(e.issues.first.code).to eq("E2E-001")
+    end
+
+    it "does not raise when only warnings" do
+      expect do
+        described_class.validate!({ items: (1..101).to_a }, registry)
+      end.not_to raise_error
+    end
+
+    it "does not raise when no issues" do
+      expect do
+        described_class.validate!({ items: (1..50).to_a }, registry)
+      end.not_to raise_error
+    end
+  end
+
+  describe ".new_registry" do
+    it "returns a fresh Registry instance" do
+      reg = described_class.new_registry
+      expect(reg).to be_a(Lutaml::Model::Validation::Registry)
+      expect(reg.size).to eq(0)
+    end
+  end
+end

data/spec/lutaml/rdf/graph_serialization_spec.rb

@@ -0,0 +1,137 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require "lutaml/turtle"
+require "lutaml/jsonld"
+
+RSpec.describe "RDF graph-aware serialization" do
+  before do
+    stub_const("GraphTestNs", Class.new(Lutaml::Rdf::Namespace) do
+      uri "http://example.org/"
+      prefix "ex"
+    end)
+
+    stub_const("GraphMemberModel", Class.new(Lutaml::Model::Serializable) do
+      attribute :code, :string
+      attribute :name, :string
+
+      rdf do
+        namespace GraphTestNs
+
+        type "ex:Item"
+        predicate :notation, namespace: GraphTestNs, to: :code
+        predicate :prefLabel, namespace: GraphTestNs, to: :name
+      end
+    end)
+
+    stub_const("GraphContainerModel", Class.new(Lutaml::Model::Serializable) do
+      attribute :id, :string
+      attribute :items, GraphMemberModel, collection: true
+
+      rdf do
+        namespace GraphTestNs
+        subject { |m| "http://example.org/container/#{m.id}" } # rubocop:disable RSpec/NamedSubject
+
+        type "ex:Container"
+        predicate :prefLabel, namespace: GraphTestNs, to: :id
+        members :items
+      end
+    end)
+  end
+
+  let(:first_item) { GraphMemberModel.new(code: "1", name: "First") }
+  let(:second_item) { GraphMemberModel.new(code: "2", name: "Second") }
+  let(:container) do
+    GraphContainerModel.new(id: "test", items: [first_item, second_item])
+  end
+
+  describe "Turtle serialization with members" do
+    subject(:turtle) { container.to_turtle }
+
+    it "includes container triples" do
+      expect(turtle).to include("a ex:Container")
+      expect(turtle).to include("ex:container")
+    end
+
+    it "includes container predicates" do
+      expect(turtle).to include('ex:prefLabel "test"')
+    end
+
+    it "includes all member blank nodes" do
+      expect(turtle.scan("a ex:Item").length).to be >= 2
+    end
+
+    it "includes member types" do
+      expect(turtle.scan("a ex:Item").length).to eq(2)
+    end
+
+    it "includes member predicates" do
+      expect(turtle).to include('ex:notation "1"')
+      expect(turtle).to include('ex:notation "2"')
+      expect(turtle).to include('ex:prefLabel "First"')
+      expect(turtle).to include('ex:prefLabel "Second"')
+    end
+
+    it "shares prefix declarations" do
+      prefix_count = turtle.scan(/@prefix ex:/).length
+      expect(prefix_count).to eq(1)
+    end
+  end
+
+  describe "JSON-LD serialization with members" do
+    subject(:jsonld) { JSON.parse(container.to_jsonld) }
+
+    it "includes @context" do
+      expect(jsonld["@context"]).to include("ex")
+    end
+
+    it "includes @graph array" do
+      expect(jsonld["@graph"]).to be_an(Array)
+      expect(jsonld["@graph"].length).to eq(3) # container + 2 items
+    end
+
+    it "includes container in @graph" do
+      container_data = jsonld["@graph"].find do |r|
+        r["@type"] == "ex:Container"
+      end
+      expect(container_data).not_to be_nil
+      expect(container_data["@id"]).to eq("http://example.org/container/test")
+      expect(container_data["prefLabel"]).to eq("test")
+    end
+
+    it "includes all members in @graph" do
+      items = jsonld["@graph"].select { |r| r["@type"] == "ex:Item" }
+      expect(items.length).to eq(2)
+      codes = items.map { |i| i["notation"] }
+      expect(codes).to contain_exactly("1", "2")
+    end
+  end
+
+  describe "container without subject (member-only)" do
+    before do
+      stub_const("MemberOnlyModel", Class.new(Lutaml::Model::Serializable) do
+        attribute :items, GraphMemberModel, collection: true
+
+        rdf do
+          namespace GraphTestNs
+          members :items
+        end
+      end)
+    end
+
+    let(:model) { MemberOnlyModel.new(items: [first_item, second_item]) }
+
+    it "serializes only member triples to turtle" do
+      turtle = model.to_turtle
+      expect(turtle).to include("a ex:Item")
+      expect(turtle).not_to include("ex:Container")
+    end
+
+    it "serializes only members to jsonld @graph" do
+      jsonld = JSON.parse(model.to_jsonld)
+      expect(jsonld["@graph"].length).to eq(2)
+      items = jsonld["@graph"].select { |r| r["@type"] == "ex:Item" }
+      expect(items.length).to eq(2)
+    end
+  end
+end

data/spec/lutaml/rdf/iri_spec.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require "lutaml/rdf"
+
+RSpec.describe Lutaml::Rdf::Iri do
+  subject(:iri) { described_class.new("http://example.org/ns/Concept") }
+
+  it "stores frozen value" do
+    expect(iri.value).to eq("http://example.org/ns/Concept")
+    expect(iri.value).to be_frozen
+  end
+
+  it "coerces to string" do
+    expect(iri.to_s).to eq("http://example.org/ns/Concept")
+  end
+
+  describe "equality" do
+    it "equals Iri with same value" do
+      other = described_class.new("http://example.org/ns/Concept")
+      expect(iri).to eq(other)
+    end
+
+    it "does not equal Iri with different value" do
+      other = described_class.new("http://other.org/Thing")
+      expect(iri).not_to eq(other)
+    end
+
+    it "has consistent hash" do
+      other = described_class.new("http://example.org/ns/Concept")
+      expect(iri.hash).to eq(other.hash)
+    end
+  end
+
+  describe "comparable" do
+    it "compares by value" do
+      a = described_class.new("http://a.org/")
+      b = described_class.new("http://b.org/")
+      expect(a < b).to be true
+    end
+  end
+
+  describe "#expand" do
+    let(:ns_set) do
+      Lutaml::Rdf::NamespaceSet.new(
+        Lutaml::Rdf::Namespaces::SkosNamespace,
+      )
+    end
+
+    it "expands compact IRI via namespace set" do
+      iri = described_class.new("skos:Concept")
+      expect(iri.expand(ns_set)).to eq("http://www.w3.org/2004/02/skos/core#Concept")
+    end
+  end
+
+  describe "#compact" do
+    let(:ns_set) do
+      Lutaml::Rdf::NamespaceSet.new(
+        Lutaml::Rdf::Namespaces::SkosNamespace,
+      )
+    end
+
+    it "compacts full URI to prefixed form" do
+      iri = described_class.new("http://www.w3.org/2004/02/skos/core#Concept")
+      expect(iri.compact(ns_set)).to eq("skos:Concept")
+    end
+
+    it "returns nil for unknown URI" do
+      iri = described_class.new("http://unknown.org/Thing")
+      expect(iri.compact(ns_set)).to be_nil
+    end
+  end
+end

data/spec/lutaml/rdf/literal_spec.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require "lutaml/rdf"
+
+RSpec.describe Lutaml::Rdf::Literal do
+  describe "plain literal" do
+    subject(:lit) { described_class.new("hello") }
+
+    it "stores value" do
+      expect(lit.value).to eq("hello")
+    end
+
+    it "has no datatype" do
+      expect(lit.datatype).to be_nil
+    end
+
+    it "has no language" do
+      expect(lit.language).to be_nil
+    end
+
+    it "serializes to Turtle" do
+      expect(lit.to_turtle).to eq('"hello"')
+    end
+
+    it "serializes to JSON-LD as plain value" do
+      expect(lit.to_jsonld_term).to eq("hello")
+    end
+  end
+
+  describe "language-tagged literal" do
+    subject(:lit) { described_class.new("hello", language: "en") }
+
+    it "serializes to Turtle with language tag" do
+      expect(lit.to_turtle).to eq('"hello"@en')
+    end
+
+    it "serializes to JSON-LD with @language" do
+      expect(lit.to_jsonld_term).to eq({ "@value" => "hello",
+                                         "@language" => "en" })
+    end
+  end
+
+  describe "typed literal" do
+    subject(:lit) { described_class.new("2024-01-01", datatype: "http://www.w3.org/2001/XMLSchema#date") }
+
+    it "serializes to Turtle with datatype" do
+      expect(lit.to_turtle).to eq('"2024-01-01"^^<http://www.w3.org/2001/XMLSchema#date>')
+    end
+
+    it "serializes to JSON-LD with @type" do
+      expect(lit.to_jsonld_term).to eq({ "@value" => "2024-01-01",
+                                         "@type" => "http://www.w3.org/2001/XMLSchema#date" })
+    end
+  end
+
+  describe "special character escaping" do
+    it "escapes quotes" do
+      lit = described_class.new('has "quotes"')
+      expect(lit.to_turtle).to eq('"has \\"quotes\\""')
+    end
+
+    it "escapes newlines" do
+      lit = described_class.new("line1\nline2")
+      expect(lit.to_turtle).to eq('"line1\\nline2"')
+    end
+
+    it "escapes backslashes" do
+      lit = described_class.new("back\\slash")
+      expect(lit.to_turtle).to eq('"back\\\\slash"')
+    end
+
+    it "escapes tabs" do
+      lit = described_class.new("tab\there")
+      expect(lit.to_turtle).to eq('"tab\\there"')
+    end
+  end
+
+  describe "equality" do
+    it "equals literal with same value, datatype, and language" do
+      a = described_class.new("hello", language: "en")
+      b = described_class.new("hello", language: "en")
+      expect(a).to eq(b)
+    end
+
+    it "does not equal with different language" do
+      a = described_class.new("hello", language: "en")
+      b = described_class.new("hello", language: "fr")
+      expect(a).not_to eq(b)
+    end
+
+    it "does not equal with different datatype" do
+      a = described_class.new("1", datatype: "xsd:integer")
+      b = described_class.new("1", datatype: "xsd:string")
+      expect(a).not_to eq(b)
+    end
+  end
+end