lutaml-model 0.8.14 → 0.8.16

data/spec/lutaml/jsonld/transform_spec.rb

@@ -447,4 +447,153 @@ RSpec.describe Lutaml::JsonLd::Transform do
       expect(parsed).not_to have_key("@type")
     end
   end
+
+  describe "dynamic link predicates (String)" do
+    before do
+      stub_const("JsonLdDynChild", Class.new(Lutaml::Model::Serializable) do
+        attribute :cid, :string
+        attribute :label, :string
+
+        rdf do
+          namespace TestSkosNs, TestExNs
+
+          subject { |m| "http://example.org/item/#{m.cid}" } # rubocop:disable RSpec/NamedSubject, RSpec/MultipleSubjects
+
+          type "skos:Concept"
+
+          predicate :prefLabel, namespace: TestSkosNs, to: :label
+        end
+      end)
+
+      stub_const("JsonLdDynParent", Class.new(Lutaml::Model::Serializable) do
+        attribute :name, :string
+        attribute :children, JsonLdDynChild, collection: true
+
+        rdf do
+          namespace TestSkosNs, TestExNs
+
+          subject { |m| "http://example.org/group/#{m.name}" } # rubocop:disable RSpec/NamedSubject, RSpec/MultipleSubjects
+
+          type "skos:Collection"
+
+          predicate :prefLabel, namespace: TestSkosNs, to: :name
+
+          members :children, link: "skos:member"
+        end
+      end)
+    end
+
+    it "generates @id references for linked members" do
+      parent = JsonLdDynParent.new(
+        name: "grp1",
+        children: [
+          JsonLdDynChild.new(cid: "a", label: "Alpha"),
+          JsonLdDynChild.new(cid: "b", label: "Beta"),
+        ],
+      )
+      parsed = JSON.parse(parent.to_jsonld)
+      parent_resource = parsed["@graph"].find do |r|
+        r["@type"] == "skos:Collection"
+      end
+      expect(parent_resource["member"]).to eq([
+                                                { "@id" => "http://example.org/item/a" },
+                                                { "@id" => "http://example.org/item/b" },
+                                              ])
+    end
+
+    it "includes member resources in @graph" do
+      parent = JsonLdDynParent.new(
+        name: "grp1",
+        children: [JsonLdDynChild.new(cid: "a", label: "Alpha")],
+      )
+      parsed = JSON.parse(parent.to_jsonld)
+      member = parsed["@graph"].find { |r| r["prefLabel"] == "Alpha" }
+      expect(member).not_to be_nil
+    end
+  end
+
+  describe "recursive context and resource collection" do
+    before do
+      stub_const("JsonLdLeaf", Class.new(Lutaml::Model::Serializable) do
+        attribute :value, :string
+        attribute :lid, :string
+
+        rdf do
+          namespace TestExNs
+
+          subject { |m| "http://example.org/leaf/#{m.lid}" } # rubocop:disable RSpec/NamedSubject, RSpec/MultipleSubjects
+
+          type "ex:Leaf"
+
+          predicate :name, namespace: TestExNs, to: :value
+        end
+      end)
+
+      stub_const("JsonLdMid", Class.new(Lutaml::Model::Serializable) do
+        attribute :label, :string
+        attribute :mid, :string
+        attribute :leaves, JsonLdLeaf, collection: true
+
+        rdf do
+          namespace TestSkosNs, TestExNs
+
+          subject { |m| "http://example.org/mid/#{m.mid}" } # rubocop:disable RSpec/NamedSubject, RSpec/MultipleSubjects
+
+          type "skos:Concept"
+
+          predicate :prefLabel, namespace: TestSkosNs, to: :label
+
+          members :leaves, link: "skos:member"
+        end
+      end)
+
+      stub_const("JsonLdRoot", Class.new(Lutaml::Model::Serializable) do
+        attribute :title, :string
+        attribute :mids, JsonLdMid, collection: true
+
+        rdf do
+          namespace TestSkosNs
+
+          subject { |m| "http://example.org/root/#{m.title}" } # rubocop:disable RSpec/NamedSubject, RSpec/MultipleSubjects
+
+          type "skos:Collection"
+
+          predicate :prefLabel, namespace: TestSkosNs, to: :title
+
+          members :mids, link: "skos:member"
+        end
+      end)
+    end
+
+    it "collects @context from all nesting levels" do
+      root = JsonLdRoot.new(
+        title: "r1",
+        mids: [JsonLdMid.new(
+          label: "m1",
+          mid: "a",
+          leaves: [JsonLdLeaf.new(value: "l1", lid: "x")],
+        )],
+      )
+      parsed = JSON.parse(root.to_jsonld)
+      expect(parsed["@context"]["skos"]).to eq("http://www.w3.org/2004/02/skos/core#")
+      expect(parsed["@context"]["ex"]).to eq("http://example.org/")
+    end
+
+    it "includes resources from all nesting levels in @graph" do
+      root = JsonLdRoot.new(
+        title: "r1",
+        mids: [JsonLdMid.new(
+          label: "m1",
+          mid: "a",
+          leaves: [JsonLdLeaf.new(value: "l1", lid: "x")],
+        )],
+      )
+      parsed = JSON.parse(root.to_jsonld)
+      graph = parsed["@graph"]
+      types = graph.map { |r| r["@type"] }
+      expect(types).to include("skos:Collection")
+      expect(types).to include("skos:Concept")
+      expect(types).to include("ex:Leaf")
+    end
+  end
 end

data/spec/lutaml/model/liquid/indexed_access_spec.rb

@@ -0,0 +1,135 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require "liquid"
+
+RSpec.describe Lutaml::Model::Liquid::IndexedAccess do
+  describe "integration with auto-generated drops" do
+    before do
+      stub_const("IndexedSpec::Item", Class.new(Lutaml::Model::Serializable) do
+        attribute :name, :string
+        attribute :value, :string
+      end)
+
+      stub_const("IndexedSpec::ItemCollection", Class.new(Lutaml::Model::Serializable) do
+        include Lutaml::Model::Liquid::IndexedAccess
+
+        attribute :items, IndexedSpec::Item, collection: true
+
+        def [](key)
+          case key
+          when Integer then items[key]
+          when String then items.find { |i| i.name == key }
+          end
+        end
+      end)
+    end
+
+    let(:collection) do
+      IndexedSpec::ItemCollection.new(
+        items: [
+          IndexedSpec::Item.new(name: "alpha", value: "A"),
+          IndexedSpec::Item.new(name: "beta", value: "B"),
+          IndexedSpec::Item.new(name: "gamma", value: "C"),
+        ],
+      )
+    end
+
+    let(:drop) { collection.to_liquid }
+
+    describe "#liquid_method_missing" do
+      it "resolves string key via liquid_fetch" do
+        result = drop["alpha"]
+        expect(result).to be_a(Liquid::Drop)
+        expect(result.name).to eq("alpha")
+        expect(result.value).to eq("A")
+      end
+
+      it "resolves integer index via liquid_fetch" do
+        result = drop[0]
+        expect(result).to be_a(Liquid::Drop)
+        expect(result.name).to eq("alpha")
+      end
+
+      it "returns nil for unknown key" do
+        result = drop["nonexistent"]
+        expect(result).to be_nil
+      end
+
+      it "returns nil for out-of-bounds index" do
+        result = drop[99]
+        expect(result).to be_nil
+      end
+    end
+
+    describe "Liquid template rendering" do
+      it "resolves bracket access in templates" do
+        template = Liquid::Template.parse("{{ collection['beta'].value }}")
+        result = template.render("collection" => drop)
+        expect(result).to eq("B")
+      end
+
+      it "resolves integer bracket access in templates" do
+        template = Liquid::Template.parse("{{ collection[2].name }}")
+        result = template.render("collection" => drop)
+        expect(result).to eq("gamma")
+      end
+
+      it "renders empty string for unknown key" do
+        template = Liquid::Template.parse("{{ collection['missing'].name }}")
+        result = template.render("collection" => drop)
+        expect(result).to eq("")
+      end
+    end
+
+    describe "coexistence with declared attribute methods" do
+      it "still exposes declared attributes normally" do
+        expect(drop.items).to be_a(Array)
+        expect(drop.items.size).to eq(3)
+        expect(drop.items[0].name).to eq("alpha")
+      end
+
+      it "prefers declared methods over indexed access" do
+        # 'items' is a declared attribute, so invoke_drop('items') calls
+        # the generated method, not liquid_fetch
+        result = drop.items
+        expect(result).to be_a(Array)
+      end
+    end
+  end
+
+  describe "objects without IndexedAccess" do
+    before do
+      stub_const("PlainSpec::Model", Class.new(Lutaml::Model::Serializable) do
+        attribute :name, :string
+      end)
+    end
+
+    let(:instance) { PlainSpec::Model.new(name: "test") }
+    let(:drop) { instance.to_liquid }
+
+    it "does not attempt bracket access on non-indexed objects" do
+      result = drop["anything"]
+      expect(result).to be_nil
+    end
+
+    it "still exposes declared attributes" do
+      expect(drop.name).to eq("test")
+    end
+  end
+
+  describe "IndexedAccess module" do
+    it "provides liquid_fetch that delegates to []" do
+      klass = Class.new do
+        include Lutaml::Model::Liquid::IndexedAccess
+
+        def [](key)
+          "value_for_#{key}"
+        end
+      end
+
+      instance = klass.new
+      expect(instance.liquid_fetch("test")).to eq("value_for_test")
+    end
+  end
+end

data/spec/lutaml/model/mixed_content_spec.rb

@@ -1111,19 +1111,22 @@ RSpec.describe "MixedContent" do
         expect(enum).to be_a(Enumerator)
       end
 
-      it "skips whitespace-only text nodes" do
+      it "yields whitespace text nodes in mixed content" do
         parsed = MixedContentSpec::RootMixedContent.from_xml(xml)
 
         results = []
         parsed.each_mixed_content do |node|
-          results << node if node.is_a?(String) && node.strip.empty?
+          results << node if node.is_a?(String)
         end
 
-        expect(results).to eq([])
+        expect(results).not_to be_empty
+        text_joined = results.join
+        expect(text_joined).to include("Hello")
+        expect(text_joined).to include("and")
+        expect(text_joined).to include("!")
       end
 
       context "with ordered-only content (no mixed)" do
-        # Test that ordered content (elements only, no text) works
         let(:xml) do
           <<~XML
             <RootMixedContentNested id="outer">
@@ -1134,15 +1137,17 @@ RSpec.describe "MixedContent" do
           XML
         end
 
-        it "yields element objects in document order" do
+        it "yields element values in document order" do
           parsed = MixedContentSpec::RootMixedContentNested.from_xml(xml)
 
           results = []
           parsed.content.each_mixed_content { |node| results << node }
 
-          # Should yield element objects in order (bold, italic strings)
+          # RootMixedContent has mixed_content, so whitespace text nodes
+          # ARE yielded alongside element values
           string_results = results.grep(String)
-          expect(string_results.length).to eq(2)
+          expect(string_results).to include("first")
+          expect(string_results).to include("second")
         end
       end
 
@@ -1152,6 +1157,42 @@ RSpec.describe "MixedContent" do
           expect(parsed.each_mixed_content.to_a).to eq([])
         end
       end
+
+      context "with ordered-only model (no mixed_content)" do
+        before do
+          stub_const("OrderedOnlyContainer", Class.new(Lutaml::Model::Serializable) do
+            attribute :items, :string, collection: true
+
+            xml do
+              element "container"
+              ordered
+              map_element "item", to: :items
+            end
+          end)
+        end
+
+        it "skips whitespace-only text nodes between elements" do
+          xml = <<~XML
+            <container>
+              <item>first</item>
+              <item>second</item>
+            </container>
+          XML
+
+          parsed = OrderedOnlyContainer.from_xml(xml)
+          results = []
+          parsed.each_mixed_content { |node| results << node }
+
+          # Ordered-only: whitespace between elements is formatting noise, not content
+          whitespace_only = results.select do |n|
+            n.is_a?(String) && n.strip.empty?
+          end
+          expect(whitespace_only).to eq([])
+
+          string_results = results.grep(String)
+          expect(string_results).to eq(%w[first second])
+        end
+      end
     end
 
     # Issue #630: Mutation after deserialization should update serialization output