lutaml-model 0.8.9 → 0.8.11

data/spec/lutaml/rdf/rdf_transform_spec.rb

@@ -4,79 +4,145 @@ require "spec_helper"
 require "lutaml/rdf"
 
 RSpec.describe Lutaml::Rdf::Transform do
-  let(:transform) { described_class.new(nil) }
-
   describe "#resolve_subject_uri" do
     it "returns nil when mapping has no subject" do
       mapping = Lutaml::Rdf::Mapping.new
-      expect(transform.send(:resolve_subject_uri, mapping, double)).to be_nil
+      transform = described_class.new(nil)
+      expect(transform.resolve_subject_uri(mapping, double)).to be_nil
     end
 
     it "calls subject proc with instance" do
       mapping = Lutaml::Rdf::Mapping.new
       mapping.subject { |i| "http://example.org/#{i}" }
 
-      result = transform.send(:resolve_subject_uri, mapping, "test")
+      transform = described_class.new(nil)
+      result = transform.resolve_subject_uri(mapping, "test")
       expect(result).to eq("http://example.org/test")
     end
   end
 
-  describe "#resolve_type_uri" do
-    it "returns nil when mapping has no type" do
-      mapping = Lutaml::Rdf::Mapping.new
-      expect(transform.send(:resolve_type_uri, mapping)).to be_nil
-    end
-
+  describe "#resolve_single_type_uri" do
     it "resolves compact IRI to full URI" do
-      mapping = Lutaml::Rdf::Mapping.new
       stub_const("TestNs", Class.new(Lutaml::Rdf::Namespace) do
         uri "http://example.org/"
         prefix "ex"
       end)
+      mapping = Lutaml::Rdf::Mapping.new
       mapping.namespace(TestNs)
       mapping.type "ex:Thing"
 
-      result = transform.send(:resolve_type_uri, mapping)
+      transform = described_class.new(nil)
+      result = transform.resolve_single_type_uri(mapping, "ex:Thing")
       expect(result).to eq("http://example.org/Thing")
     end
   end
 
-  describe "#resolve_type_compact" do
-    it "returns the compact form" do
+  describe "#resolve_type_uris" do
+    it "returns empty array when mapping has no types" do
+      mapping = Lutaml::Rdf::Mapping.new
+      transform = described_class.new(nil)
+      expect(transform.resolve_type_uris(mapping)).to eq([])
+    end
+
+    it "resolves all type compact IRIs to full URIs" do
+      stub_const("MultiNs", Class.new(Lutaml::Rdf::Namespace) do
+        uri "http://example.org/"
+        prefix "ex"
+      end)
       mapping = Lutaml::Rdf::Mapping.new
-      mapping.type "skos:Concept"
+      mapping.namespace(MultiNs)
+      mapping.type ["ex:Thing", "ex:Other"]
 
-      expect(transform.send(:resolve_type_compact,
-                            mapping)).to eq("skos:Concept")
+      transform = described_class.new(nil)
+      result = transform.resolve_type_uris(mapping)
+      expect(result).to eq(["http://example.org/Thing", "http://example.org/Other"])
     end
   end
 
   describe "#extract_language" do
     it "extracts language from LanguageTagged objects" do
       literal = Lutaml::Rdf::Literal.new("hello", language: "eng")
-      expect(transform.send(:extract_language, literal)).to eq("eng")
+      transform = described_class.new(nil)
+      expect(transform.extract_language(literal)).to eq("eng")
     end
 
     it "returns nil for plain strings" do
-      expect(transform.send(:extract_language, "hello")).to be_nil
+      transform = described_class.new(nil)
+      expect(transform.extract_language("hello")).to be_nil
     end
 
     it "returns nil for non-LanguageTagged objects" do
-      expect(transform.send(:extract_language, 42)).to be_nil
+      transform = described_class.new(nil)
+      expect(transform.extract_language(42)).to be_nil
     end
   end
 
-  describe "#build_instance" do
-    it "constructs a model instance with resolved register" do
-      stub_const("BuildTestModel", Class.new(Lutaml::Model::Serializable) do
-        attribute :name, :string
+  describe "#each_member" do
+    it "iterates over collection attribute values" do
+      stub_const("MemberItem", Class.new do
+        attr_reader :label
+
+        def initialize(label)
+          @label = label
+        end
+      end)
+      stub_const("MemberParent", Class.new(Lutaml::Model::Serializable) do
+        attribute :items, :string, collection: true
+      end)
+
+      instance = MemberParent.new(items: ["a", "b"])
+      member_rule = Lutaml::Rdf::MemberRule.new(:items)
+      transform = described_class.new(nil)
+
+      collected = []
+      transform.each_member(instance, member_rule) { |m| collected << m }
+      expect(collected).to eq(["a", "b"])
+    end
+
+    it "handles nil collection as empty" do
+      stub_const("NilParent", Class.new(Lutaml::Model::Serializable) do
+        attribute :items, :string, collection: true
+      end)
+
+      instance = NilParent.new
+      member_rule = Lutaml::Rdf::MemberRule.new(:items)
+      transform = described_class.new(nil)
+
+      collected = []
+      transform.each_member(instance, member_rule) { |m| collected << m }
+      expect(collected).to eq([])
+    end
+  end
+
+  describe "#member_mapping_for" do
+    it "returns the mapping for the given format" do
+      stub_const("MappedChild", Class.new(Lutaml::Model::Serializable) do
+        attribute :label, :string
+
+        turtle do
+          namespace Lutaml::Rdf::Namespaces::SkosNamespace
+          subject { |m| "http://example.org/#{m.label}" } # rubocop:disable RSpec/NamedSubject
+
+          predicate :prefLabel,
+                    namespace: Lutaml::Rdf::Namespaces::SkosNamespace,
+                    to: :label
+        end
+      end)
+
+      member = MappedChild.new(label: "test")
+      transform = described_class.new(nil)
+      mapping = transform.member_mapping_for(member, :turtle)
+      expect(mapping).to be_a(Lutaml::Rdf::Mapping)
+    end
+
+    it "returns nil when no mapping for format" do
+      stub_const("UnmappedChild", Class.new(Lutaml::Model::Serializable) do
+        attribute :label, :string
       end)
 
-      context = BuildTestModel
-      t = described_class.new(context)
-      instance = t.send(:build_instance, { name: "test" }, {})
-      expect(instance).to be_a(BuildTestModel)
-      expect(instance.name).to eq("test")
+      member = UnmappedChild.new(label: "test")
+      transform = described_class.new(nil)
+      expect(transform.member_mapping_for(member, :turtle)).to be_nil
     end
   end
 end

data/spec/lutaml/turtle/mapping_spec.rb

@@ -27,7 +27,7 @@ RSpec.describe Lutaml::Turtle::Mapping do
   describe "#type" do
     it "sets RDF type" do
       mapping.type("skos:Concept")
-      expect(mapping.rdf_type).to eq("skos:Concept")
+      expect(mapping.rdf_type).to eq(["skos:Concept"])
     end
   end
 
@@ -108,7 +108,7 @@ RSpec.describe Lutaml::Turtle::Mapping do
       duped = mapping.deep_dup
       expect(duped.namespace_set.size).to eq(2)
       expect(duped.rdf_subject).to be_a(Proc)
-      expect(duped.rdf_type).to eq("skos:Concept")
+      expect(duped.rdf_type).to eq(["skos:Concept"])
       expect(duped.rdf_predicates.length).to eq(1)
     end
 

data/spec/lutaml/turtle/transform_spec.rb

@@ -260,6 +260,13 @@ RSpec.describe Lutaml::Turtle::Transform do
       model = TurtleTestModel.from_turtle(turtle_input)
       expect(model.name).to eq("test concept")
     end
+
+    it "round-trips deserialized data back to Turtle" do
+      model = TurtleTestModel.from_turtle(turtle_input)
+      turtle_out = model.to_turtle
+      expect(turtle_out).to include("skos:Concept")
+      expect(turtle_out).to include("skos:notation \"2119\"")
+    end
   end
 
   describe "round-trip" do
@@ -270,4 +277,312 @@ RSpec.describe Lutaml::Turtle::Transform do
       expect(restored.description).to eq("A test description")
     end
   end
+
+  describe "multiple types" do
+    before do
+      stub_const("DualTypeModel", Class.new(Lutaml::Model::Serializable) do
+        attribute :name, :string
+
+        turtle do
+          namespace Lutaml::Rdf::Namespaces::SkosNamespace,
+                    Lutaml::Rdf::Namespaces::DctermsNamespace
+
+          subject { |m| "http://example.org/#{m.name}" }
+
+          type ["skos:Concept", "dcterms:Agent"]
+
+          predicate :prefLabel,
+                    namespace: Lutaml::Rdf::Namespaces::SkosNamespace,
+                    to: :name
+        end
+      end)
+    end
+
+    it "generates multiple rdf:type triples" do
+      instance = DualTypeModel.new(name: "test")
+      result = instance.to_turtle
+      expect(result).to include("a skos:Concept")
+      expect(result).to include("dcterms:Agent")
+    end
+
+    it "round-trips multiple types" do
+      instance = DualTypeModel.new(name: "test")
+      turtle = instance.to_turtle
+      restored = DualTypeModel.from_turtle(turtle)
+      expect(restored.name).to eq("test")
+    end
+  end
+
+  describe "empty type array" do
+    before do
+      stub_const("NoTypeModel", Class.new(Lutaml::Model::Serializable) do
+        attribute :name, :string
+
+        turtle do
+          namespace Lutaml::Rdf::Namespaces::SkosNamespace
+
+          subject { |m| "http://example.org/#{m.name}" }
+
+          predicate :prefLabel,
+                    namespace: Lutaml::Rdf::Namespaces::SkosNamespace,
+                    to: :name
+        end
+      end)
+    end
+
+    it "omits rdf:type when no types declared" do
+      instance = NoTypeModel.new(name: "test")
+      result = instance.to_turtle
+      expect(result).not_to include(" a ")
+      expect(result).to include("skos:prefLabel")
+    end
+  end
+
+  describe "URI reference predicates" do
+    before do
+      stub_const("UriRefModel", Class.new(Lutaml::Model::Serializable) do
+        attribute :name, :string
+        attribute :related, :string, collection: true
+
+        turtle do
+          namespace Lutaml::Rdf::Namespaces::SkosNamespace,
+                    Lutaml::Rdf::Namespaces::DctermsNamespace
+
+          subject { |m| "http://example.org/#{m.name}" }
+
+          type "skos:Concept"
+
+          predicate :prefLabel,
+                    namespace: Lutaml::Rdf::Namespaces::SkosNamespace,
+                    to: :name
+
+          predicate :related,
+                    namespace: Lutaml::Rdf::Namespaces::SkosNamespace,
+                    to: :related,
+                    uri_reference: true
+        end
+      end)
+    end
+
+    it "emits URI objects instead of literals" do
+      instance = UriRefModel.new(name: "test", related: ["skos:other"])
+      result = instance.to_turtle
+      expect(result).to include("skos:related skos:other")
+      expect(result).not_to include('"skos:other"')
+    end
+
+    it "round-trips URI references preserving compact form" do
+      instance = UriRefModel.new(name: "test", related: ["skos:other"])
+      turtle = instance.to_turtle
+      restored = UriRefModel.from_turtle(turtle)
+      expect(restored.related).to eq("skos:other")
+    end
+
+    it "handles full URI values without prefix" do
+      instance = UriRefModel.new(name: "test",
+                                 related: ["http://example.org/foo"])
+      result = instance.to_turtle
+      expect(result).to include("skos:related <http://example.org/foo>")
+    end
+
+    it "round-trips full URI values as-is" do
+      instance = UriRefModel.new(name: "test",
+                                 related: ["http://example.org/foo"])
+      turtle = instance.to_turtle
+      restored = UriRefModel.from_turtle(turtle)
+      expect(restored.related).to eq("http://example.org/foo")
+    end
+  end
+
+  describe "member linking predicates" do
+    before do
+      stub_const("ChildModel", Class.new(Lutaml::Model::Serializable) do
+        attribute :label, :string
+        attribute :cid, :string
+
+        turtle do
+          namespace Lutaml::Rdf::Namespaces::SkosNamespace
+
+          subject { |m| "http://example.org/child/#{m.cid}" } # rubocop:disable RSpec/NamedSubject, RSpec/MultipleSubjects
+
+          type "skos:Concept"
+
+          predicate :prefLabel,
+                    namespace: Lutaml::Rdf::Namespaces::SkosNamespace,
+                    to: :label
+        end
+      end)
+
+      stub_const("ParentModel", Class.new(Lutaml::Model::Serializable) do
+        attribute :name, :string
+        attribute :children, ChildModel, collection: true
+
+        turtle do
+          namespace Lutaml::Rdf::Namespaces::SkosNamespace
+
+          subject { |m| "http://example.org/parent/#{m.name}" }
+
+          type "skos:Collection"
+
+          predicate :prefLabel,
+                    namespace: Lutaml::Rdf::Namespaces::SkosNamespace,
+                    to: :name
+
+          members :children,
+                  predicate_name: :member,
+                  namespace: Lutaml::Rdf::Namespaces::SkosNamespace
+        end
+      end)
+    end
+
+    it "generates linking triples from parent to members" do
+      parent = ParentModel.new(
+        name: "parent1",
+        children: [
+          ChildModel.new(label: "child1", cid: "c1"),
+          ChildModel.new(label: "child2", cid: "c2"),
+        ],
+      )
+      result = parent.to_turtle
+      expect(result).to include("skos:member <http://example.org/child/c1>")
+      expect(result).to include("<http://example.org/child/c2>")
+    end
+
+    it "still generates member graph nodes" do
+      parent = ParentModel.new(
+        name: "parent1",
+        children: [
+          ChildModel.new(label: "child1", cid: "c1"),
+        ],
+      )
+      result = parent.to_turtle
+      expect(result).to include("skos:prefLabel \"child1\"")
+    end
+  end
+
+  describe "linked-only model (no type, no predicates)" do
+    before do
+      stub_const("LinkedOnlyChild", Class.new(Lutaml::Model::Serializable) do
+        attribute :cid, :string
+        attribute :label, :string
+
+        turtle do
+          namespace Lutaml::Rdf::Namespaces::SkosNamespace
+
+          subject { |m| "http://example.org/item/#{m.cid}" } # rubocop:disable RSpec/NamedSubject, RSpec/MultipleSubjects
+
+          type "skos:Concept"
+
+          predicate :prefLabel,
+                    namespace: Lutaml::Rdf::Namespaces::SkosNamespace,
+                    to: :label
+        end
+      end)
+
+      stub_const("LinkedOnlyParent", Class.new(Lutaml::Model::Serializable) do
+        attribute :pid, :string
+        attribute :items, LinkedOnlyChild, collection: true
+
+        turtle do
+          namespace Lutaml::Rdf::Namespaces::SkosNamespace
+
+          subject { |m| "http://example.org/group/#{m.pid}" } # rubocop:disable RSpec/NamedSubject, RSpec/MultipleSubjects
+
+          members :items,
+                  predicate_name: :member,
+                  namespace: Lutaml::Rdf::Namespaces::SkosNamespace
+        end
+      end)
+    end
+
+    it "generates linking triples even without type or predicates" do
+      parent = LinkedOnlyParent.new(
+        pid: "g1",
+        items: [
+          LinkedOnlyChild.new(cid: "a", label: "Alpha"),
+          LinkedOnlyChild.new(cid: "b", label: "Beta"),
+        ],
+      )
+      result = parent.to_turtle
+      expect(result).to include("skos:member")
+      expect(result).to include("<http://example.org/item/a>")
+      expect(result).to include("<http://example.org/item/b>")
+    end
+
+    it "includes member subgraph data" do
+      parent = LinkedOnlyParent.new(
+        pid: "g1",
+        items: [LinkedOnlyChild.new(cid: "a", label: "Alpha")],
+      )
+      result = parent.to_turtle
+      expect(result).to include("skos:prefLabel \"Alpha\"")
+    end
+
+    it "does not generate rdf:type for parent" do
+      parent = LinkedOnlyParent.new(
+        pid: "g1",
+        items: [LinkedOnlyChild.new(cid: "a", label: "Alpha")],
+      )
+      result = parent.to_turtle
+      parent_line = result.lines.find { |l| l.include?("<http://example.org/group/g1>") }
+      expect(parent_line).not_to include(" a ")
+    end
+  end
+
+  describe "heterogeneous member collection" do
+    before do
+      stub_const("HeteroChildA", Class.new(Lutaml::Model::Serializable) do
+        attribute :label, :string
+
+        turtle do
+          namespace Lutaml::Rdf::Namespaces::SkosNamespace
+
+          subject { |m| "http://example.org/a/#{m.label}" } # rubocop:disable RSpec/NamedSubject, RSpec/MultipleSubjects
+
+          type "skos:Concept"
+
+          predicate :prefLabel,
+                    namespace: Lutaml::Rdf::Namespaces::SkosNamespace,
+                    to: :label
+        end
+      end)
+
+      stub_const("HeteroChildB", Class.new(Lutaml::Model::Serializable) do
+        attribute :title, :string
+
+        turtle do
+          namespace Lutaml::Rdf::Namespaces::DctermsNamespace
+
+          subject { |m| "http://example.org/b/#{m.title}" } # rubocop:disable RSpec/NamedSubject, RSpec/MultipleSubjects
+
+          type "dcterms:Agent"
+
+          predicate :title,
+                    namespace: Lutaml::Rdf::Namespaces::DctermsNamespace,
+                    to: :title
+        end
+      end)
+
+      stub_const("HeteroParent", Class.new(Lutaml::Model::Serializable) do
+        attribute :name, :string
+        attribute :items, :string, collection: true
+
+        turtle do
+          namespace Lutaml::Rdf::Namespaces::SkosNamespace
+
+          subject { |m| "http://example.org/parent/#{m.name}" }
+
+          type "skos:Collection"
+
+          predicate :prefLabel,
+                    namespace: Lutaml::Rdf::Namespaces::SkosNamespace,
+                    to: :name
+        end
+      end)
+    end
+
+    it "includes prefixes from all member types" do
+      skip "Heterogeneous collection requires union-typed attribute (not yet supported)"
+    end
+  end
 end

data/spec/lutaml/xml/data_model_spec.rb

@@ -6,15 +6,10 @@ RSpec.describe Lutaml::Xml::DataModel do
   describe Lutaml::Xml::DataModel::XmlElement do
     let(:element_name) { "test-element" }
     let(:namespace_class) do
-      Class.new do
-        def self.prefix_default
-          "test"
-        end
-
-        def self.uri
-          "http://example.com/test"
-        end
-      end
+      ns = Class.new(Lutaml::Xml::Namespace)
+      ns.prefix_default "test"
+      ns.uri "http://example.com/test"
+      ns
     end
 
     describe "#initialize" do
@@ -146,11 +141,7 @@ RSpec.describe Lutaml::Xml::DataModel do
       end
 
       it "returns unprefixed when namespace has no prefix" do
-        ns_no_prefix = Class.new do
-          def self.prefix_default
-            nil
-          end
-        end
+        ns_no_prefix = Class.new(Lutaml::Xml::Namespace)
         element = described_class.new("element", ns_no_prefix)
 
         expect(element.qualified_name).to eq("element")
@@ -208,15 +199,10 @@ RSpec.describe Lutaml::Xml::DataModel do
     let(:attr_name) { "test-attr" }
     let(:attr_value) { "test-value" }
     let(:namespace_class) do
-      Class.new do
-        def self.prefix_default
-          "test"
-        end
-
-        def self.uri
-          "http://example.com/test"
-        end
-      end
+      ns = Class.new(Lutaml::Xml::Namespace)
+      ns.prefix_default "test"
+      ns.uri "http://example.com/test"
+      ns
     end
 
     describe "#initialize" do
@@ -257,11 +243,7 @@ RSpec.describe Lutaml::Xml::DataModel do
       end
 
       it "returns unprefixed when namespace has no prefix" do
-        ns_no_prefix = Class.new do
-          def self.prefix_default
-            nil
-          end
-        end
+        ns_no_prefix = Class.new(Lutaml::Xml::Namespace)
         attribute = described_class.new(attr_name, attr_value, ns_no_prefix)
 
         expect(attribute.qualified_name).to eq(attr_name)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lutaml-model
 version: !ruby/object:Gem::Version
-  version: 0.8.9
+  version: 0.8.11
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-05-14 00:00:00.000000000 Z
+date: 2026-05-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: base64
@@ -92,14 +92,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.1.16
+        version: 0.1.20
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.1.16
+        version: 0.1.20
 - !ruby/object:Gem::Dependency
   name: ostruct
   requirement: !ruby/object:Gem::Requirement
@@ -532,6 +532,7 @@ files:
 - lib/lutaml/model/serialize.rb
 - lib/lutaml/model/serialize/attribute_definition.rb
 - lib/lutaml/model/serialize/builder.rb
+- lib/lutaml/model/serialize/deserialization_context.rb
 - lib/lutaml/model/serialize/enum_handling.rb
 - lib/lutaml/model/serialize/format_conversion.rb
 - lib/lutaml/model/serialize/initialization.rb
@@ -1614,6 +1615,7 @@ files:
 - spec/lutaml/model/multiple_mapping_spec.rb
 - spec/lutaml/model/namespace_versioning_spec.rb
 - spec/lutaml/model/one_entry_cache_spec.rb
+- spec/lutaml/model/optimization_spec.rb
 - spec/lutaml/model/ordered_content_spec.rb
 - spec/lutaml/model/polymorphic_spec.rb
 - spec/lutaml/model/processing_instruction_spec.rb
@@ -1705,6 +1707,7 @@ files:
 - spec/lutaml/rdf/graph_serialization_spec.rb
 - spec/lutaml/rdf/iri_spec.rb
 - spec/lutaml/rdf/literal_spec.rb
+- spec/lutaml/rdf/mapping_rule_spec.rb
 - spec/lutaml/rdf/mapping_spec.rb
 - spec/lutaml/rdf/member_rule_spec.rb
 - spec/lutaml/rdf/namespace_set_spec.rb