lutaml-model 0.8.15 → 0.8.17

data/lib/lutaml/xml/transformation/rule_compiler.rb

@@ -253,6 +253,15 @@ _register)
 
         private
 
+        # Resolve the unified raw mode from mapping rule and attribute
+        #
+        # @param mapping_rule [Xml::MappingRule] The mapping rule
+        # @param attr [Attribute, nil] The attribute (nil for custom methods)
+        # @return [Symbol, nil] :element, :content, or nil
+        def resolve_raw_mode(mapping_rule, attr)
+          mapping_rule.raw || (attr&.raw? ? :content : nil)
+        end
+
         # Infer attribute name from mapping rule or custom methods
         #
         # @param mapping_rule [Xml::MappingRule] The mapping rule
@@ -321,7 +330,7 @@ register_id, register, attr_name, custom_methods_value)
             mapping_type: :element,
             cdata: mapping_rule.cdata,
             mixed_content: mapping_rule.mixed_content?,
-            raw: attr.raw?,
+            raw: resolve_raw_mode(mapping_rule, attr),
             render_default: mapping_rule.render_default,
             value_map: value_map,
             custom_methods: custom_methods_value,
@@ -350,7 +359,7 @@ custom_methods_value)
             mapping_type: :element,
             cdata: mapping_rule.cdata,
             mixed_content: mapping_rule.mixed_content?,
-            raw: false,
+            raw: mapping_rule.raw,
             render_default: mapping_rule.render_default,
             value_map: value_map,
             custom_methods: custom_methods_value,
@@ -401,7 +410,7 @@ register_id, register, custom_methods_value)
             mapping_type: :element,
             cdata: mapping_rule.cdata,
             mixed_content: mapping_rule.mixed_content?,
-            raw: attr.raw?,
+            raw: resolve_raw_mode(mapping_rule, attr),
             render_default: mapping_rule.render_default,
             value_map: value_map,
             custom_methods: custom_methods_value,

data/lib/lutaml/yamlld/adapter.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require "yaml"
+
+module Lutaml
+  module YamlLd
+    class Adapter < Lutaml::KeyValue::Document
+      PERMITTED_CLASSES = Lutaml::Yaml::Adapter::StandardAdapter::PERMITTED_CLASSES
+
+      def self.parse(yaml_string, _options = {})
+        YAML.safe_load(yaml_string, permitted_classes: PERMITTED_CLASSES)
+      end
+
+      def to_yamlld(options = {})
+        attributes_to_serialize =
+          if @attributes.is_a?(Lutaml::KeyValue::DataModel::Element)
+            @attributes.to_hash["__root__"]
+          else
+            @attributes
+          end
+        YAML.dump(attributes_to_serialize, options)
+      end
+    end
+  end
+end

data/lib/lutaml/yamlld.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require_relative "model"
+require_relative "rdf"
+require_relative "yaml"
+
+module Lutaml
+  module YamlLd
+    autoload :Adapter, "#{__dir__}/yamlld/adapter"
+  end
+end
+
+# Known limitations (v1):
+# - Single YAML document only; multi-document streams not interpreted as @graph.
+# - YAML anchors/aliases not used to deduplicate @id references.
+# - External @context loading not performed (matches :jsonld behavior).
+Lutaml::Model::FormatRegistry.register(
+  :yamlld,
+  mapping_class: Lutaml::Rdf::Mapping,
+  adapter_class: Lutaml::YamlLd::Adapter,
+  transformer: Lutaml::Rdf::LinkedDataTransform,
+  key_value: false,
+  rdf: true,
+  error_types: ["Psych::SyntaxError"],
+)

data/spec/lutaml/integration/multi_format_spec.rb

@@ -3,6 +3,7 @@
 require "spec_helper"
 require "lutaml/turtle"
 require "lutaml/jsonld"
+require "lutaml/yamlld"
 
 RSpec.describe "Multi-format model" do
   before do
@@ -103,4 +104,26 @@ RSpec.describe "Multi-format model" do
       expect(turtle).to include("@prefix")
     end
   end
+
+  describe "YAML-LD format" do
+    it "serializes with @type and @id" do
+      yamlld = instance.to_yamlld
+      parsed = YAML.safe_load(yamlld)
+      expect(parsed["@type"]).to eq("skos:Concept")
+      expect(parsed["@id"]).to eq("http://example.org/concept/42")
+      expect(parsed["prefLabel"]).to eq("test")
+    end
+
+    it "round-trips" do
+      restored = MultiFormatModel.from_yamlld(instance.to_yamlld)
+      expect(restored.name).to eq("test")
+      expect(restored.code).to eq("42")
+    end
+
+    it "produces the same data model as JSON-LD" do
+      from_yamlld = YAML.safe_load(instance.to_yamlld)
+      from_jsonld = JSON.parse(instance.to_jsonld)
+      expect(from_yamlld).to eq(from_jsonld)
+    end
+  end
 end

data/spec/lutaml/model/attribute_spec.rb

@@ -191,7 +191,14 @@ RSpec.describe Lutaml::Model::Attribute do
 
     Lutaml::Model::Attribute::ALLOWED_OPTIONS.each do |option|
       it "return true if option is `#{option}`" do
-        expect(validate_options.call({ option => "value" })).to be(true)
+        if option == :xsd_type
+          expect do
+            result = validate_options.call({ option => "value" })
+            expect(result).to be(true)
+          end.to output.to_stderr
+        else
+          expect(validate_options.call({ option => "value" })).to be(true)
+        end
       end
     end
 

data/spec/lutaml/model/choice_restrict_spec.rb

@@ -0,0 +1,225 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe Lutaml::Model::Choice, "#restrict and #remove_attribute" do
+  before do
+    stub_const("ChoiceRestrictParent", Class.new(Lutaml::Model::Serializable) do
+      attribute :name, :string
+      attribute :age, :integer
+      attribute :email, :string
+    end)
+  end
+
+  describe "#restrict" do
+    it "restricts a predefined attribute inside a choice block" do
+      stub_const("ChoiceRestrictModel", Class.new(Lutaml::Model::Serializable) do
+        attribute :foo, :string, collection: 1..10
+
+        choice min: 1, max: 1 do
+          restrict :foo, collection: 2..5
+        end
+      end)
+
+      attr = ChoiceRestrictModel.attributes[:foo]
+      expect(attr.options[:collection]).to eq(2..5)
+      choice = ChoiceRestrictModel.choice_attributes.first
+      expect(choice.attributes).to include(attr)
+    end
+
+    it "raises UndefinedAttributeError for non-existent attribute" do
+      expect do
+        stub_const("ChoiceRestrictBadModel", Class.new(Lutaml::Model::Serializable) do
+          choice min: 1, max: 1 do
+            restrict :nonexistent, collection: 1..2
+          end
+        end)
+      end.to raise_error(Lutaml::Model::UndefinedAttributeError)
+    end
+
+    it "restricts an imported model attribute inside a choice block" do
+      stub_const("ChoiceImportModel", Class.new(Lutaml::Model::Serializable) do
+        attribute :name, :string
+        attribute :age, :integer
+
+        choice min: 1, max: 1 do
+          import_model_attributes ChoiceRestrictParent
+          restrict :age, values: [18, 21, 30]
+        end
+      end)
+
+      attr = ChoiceImportModel.attributes[:age]
+      expect(attr.options[:values]).to eq([18, 21, 30])
+    end
+
+    it "marks the attribute as belonging to the choice" do
+      stub_const("ChoiceRestrictOwnedModel", Class.new(Lutaml::Model::Serializable) do
+        attribute :tag, :string
+
+        choice min: 0, max: 1 do
+          restrict :tag, values: %w[a b c]
+        end
+      end)
+
+      attr = ChoiceRestrictOwnedModel.attributes[:tag]
+      expect(attr.options[:choice]).to be_a(described_class)
+    end
+
+    it "does not duplicate the attribute if restrict is called twice" do
+      stub_const("ChoiceRestrictDupModel", Class.new(Lutaml::Model::Serializable) do
+        attribute :val, :integer
+
+        choice min: 0, max: 1 do
+          restrict :val, values: [1, 2]
+          restrict :val, values: [1, 2, 3]
+        end
+      end)
+
+      choice = ChoiceRestrictDupModel.choice_attributes.first
+      count = choice.attributes.count do |a|
+        !a.is_a?(described_class) && a.name == :val
+      end
+      expect(count).to eq(1)
+      expect(ChoiceRestrictDupModel.attributes[:val].options[:values]).to eq([
+                                                                               1, 2, 3
+                                                                             ])
+    end
+
+    it "restricts an inherited attribute in a child class choice" do
+      stub_const("ChoiceRestrictParent", Class.new(Lutaml::Model::Serializable) do
+        attribute :tag, :string
+        attribute :label, :string
+      end)
+
+      child = Class.new(ChoiceRestrictParent) do
+        include Lutaml::Model::Serialize
+
+        choice min: 1, max: 1 do
+          restrict :tag, values: %w[a b c]
+        end
+      end
+
+      attr = child.attributes[:tag]
+      expect(attr.options[:values]).to eq(%w[a b c])
+      choice = child.choice_attributes.first
+      expect(choice.flat_attributes.any? { |a| a.name == :tag }).to be(true)
+    end
+  end
+
+  describe "#remove_attribute" do
+    it "removes an attribute from the choice block" do
+      stub_const("ChoiceRemoveModel", Class.new(Lutaml::Model::Serializable) do
+        attribute :keep, :string
+        attribute :drop, :string
+
+        choice min: 0, max: 1 do
+          attribute :keep, :string
+          attribute :drop, :string
+          remove_attribute :drop
+        end
+      end)
+
+      choice = ChoiceRemoveModel.choice_attributes.first
+      attr_names = choice.attributes.filter_map do |a|
+        a.is_a?(described_class) ? nil : a.name
+      end
+      expect(attr_names).to eq([:keep])
+    end
+
+    it "clears the choice option from the removed attribute" do
+      stub_const("ChoiceRemoveOptModel", Class.new(Lutaml::Model::Serializable) do
+        attribute :item, :string
+
+        choice min: 0, max: 1 do
+          attribute :item, :string
+          remove_attribute :item
+        end
+      end)
+
+      attr = ChoiceRemoveOptModel.attributes[:item]
+      # The top-level :item attribute should still exist without :choice
+      # since the one in the choice was a different instance
+      expect(attr.options[:choice]).to be_nil
+    end
+
+    it "returns nil if the attribute is not in the choice" do
+      result = nil
+      stub_const("ChoiceRemoveNotFoundModel", Class.new(Lutaml::Model::Serializable) do
+        attribute :x, :string
+
+        choice min: 0, max: 1 do
+          result = remove_attribute(:nonexistent)
+        end
+      end)
+
+      expect(result).to be_nil
+    end
+
+    it "invalidates the flat_attributes cache" do
+      stub_const("ChoiceRemoveCacheModel", Class.new(Lutaml::Model::Serializable) do
+        attribute :a, :string
+        attribute :b, :string
+
+        choice min: 0, max: 1 do
+          attribute :a, :string
+          attribute :b, :string
+        end
+      end)
+
+      choice = ChoiceRemoveCacheModel.choice_attributes.first
+      expect(choice.flat_attributes.map(&:name)).to contain_exactly(:a, :b)
+      choice.remove_attribute(:b)
+      expect(choice.flat_attributes.map(&:name)).to contain_exactly(:a)
+    end
+
+    it "removes an imported attribute from the choice block" do
+      source = Class.new(Lutaml::Model::Serializable) do
+        attribute :name, :string
+        attribute :email, :string
+        attribute :phone, :string
+      end
+      stub_const("ChoiceRemoveImportSource", source)
+
+      stub_const("ChoiceRemoveImportModel", Class.new(Lutaml::Model::Serializable) do
+        choice min: 1, max: 1 do
+          import_model_attributes ChoiceRemoveImportSource
+          remove_attribute :phone
+        end
+      end)
+
+      choice = ChoiceRemoveImportModel.choice_attributes.first
+      names = choice.flat_attributes.map(&:name)
+      expect(names).to contain_exactly(:name, :email)
+    end
+
+    it "removes a restrict-added attribute from the choice" do
+      stub_const("ChoiceRemoveRestrictModel", Class.new(Lutaml::Model::Serializable) do
+        attribute :tag, :string
+
+        choice min: 0, max: 1 do
+          restrict :tag, values: %w[a b c]
+          remove_attribute :tag
+        end
+      end)
+
+      choice = ChoiceRemoveRestrictModel.choice_attributes.first
+      expect(choice.flat_attributes).to be_empty
+      expect(ChoiceRemoveRestrictModel.attributes[:tag].options[:choice]).to be_nil
+    end
+
+    it "returns the removed attribute" do
+      stub_const("ChoiceRemoveReturnModel", Class.new(Lutaml::Model::Serializable) do
+        attribute :item, :string
+
+        choice min: 0, max: 1 do
+          attribute :item, :string
+        end
+      end)
+
+      choice = ChoiceRemoveReturnModel.choice_attributes.first
+      removed = choice.remove_attribute(:item)
+      expect(removed).to be_a(Lutaml::Model::Attribute)
+      expect(removed.name).to eq(:item)
+    end
+  end
+end

data/spec/lutaml/model/custom_model_spec.rb

@@ -153,16 +153,16 @@ module CustomModelSpecs
   end
 
   class MixedWithNestedContent < Lutaml::Model::Serializable
-    attribute :street, :string, raw: true
-    attribute :city, :string, raw: true
+    attribute :street, :string
+    attribute :city, :string
     attribute :bibdata, Bibdata
 
     xml do
       element "MixedWithNestedContent"
       mixed_content
 
-      map_element "street", to: :street
-      map_element "city", to: :city
+      map_element "street", to: :street, raw: :content
+      map_element "city", to: :city, raw: :content
       map_element "bibdata",
                   to: :bibdata,
                   with: { from: :bibdata_from_xml, to: :bibdata_to_xml }

data/spec/lutaml/model/mixed_content_spec.rb

@@ -107,12 +107,12 @@ module MixedContentSpec
   end
 
   class SpecialCharContentWithRawAndMixedOption < Lutaml::Model::Serializable
-    attribute :special, :string, raw: true
+    attribute :special, :string
 
     xml do
       element "SpecialCharContentWithRawOptionAndMixedOption"
       mixed_content
-      map_element :special, to: :special
+      map_element :special, to: :special, raw: :content
     end
   end
 
@@ -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

data/spec/lutaml/model/multiple_mapping_spec.rb

@@ -240,12 +240,12 @@ RSpec.describe MultipleMapping do
         expect(product1.name).to eq("Coffee Maker")
         expect(product1.description).to eq("Premium coffee maker")
         expect(product1.status).to eq("active")
-        expect(product1.content.to_s).to match(/Some content here/)
+        expect(product1.content.to_s).to include("Some content here")
 
         expect(product2.name).to eq("Coffee Maker")
         expect(product2.description).to eq("Premium coffee maker")
         expect(product2.status).to eq("in-stock")
-        expect(product2.content.to_s).to match(/Different content/)
+        expect(product2.content.to_s).to include("Different content")
 
         # Test round-trip: serialize and deserialize should preserve data
         # (Note: exact XML format differs between adapters due to mixed content whitespace handling)
@@ -253,13 +253,13 @@ RSpec.describe MultipleMapping do
         expect(round_trip1.name).to eq(product1.name)
         expect(round_trip1.description).to eq(product1.description)
         expect(round_trip1.status).to eq(product1.status)
-        expect(round_trip1.content.to_s).to match(/Some content here/)
+        expect(round_trip1.content.to_s).to include("Some content here")
 
         round_trip2 = MultipleMapping::Product.from_xml(product2.to_xml)
         expect(round_trip2.name).to eq(product2.name)
         expect(round_trip2.description).to eq(product2.description)
         expect(round_trip2.status).to eq(product2.status)
-        expect(round_trip2.content.to_s).to match(/Different content/)
+        expect(round_trip2.content.to_s).to include("Different content")
       end
     end
 

data/spec/lutaml/model/ordered_content_spec.rb

@@ -102,8 +102,8 @@ RSpec.describe "OrderedContent" do
         expect(obj.bold).to eq(["bell", "cool"])
         expect(obj.italic).to eq(["384,400 km"])
         expect(obj.underline).to eq("craters")
-        expect(obj.content.first.to_s).to match(/The Earth's Moon rings like a/)
-        expect(obj.content.join).to match(/Ain't that/)
+        expect(obj.content.first.to_s).to include("The Earth's Moon rings like a")
+        expect(obj.content.join).to include("Ain't that")
 
         # Verify round-trip preserves data
         # (Note: exact XML format differs between adapters in ordered mode)
@@ -112,7 +112,7 @@ RSpec.describe "OrderedContent" do
         expect(round_trip.bold).to eq(obj.bold)
         expect(round_trip.italic).to eq(obj.italic)
         expect(round_trip.underline).to eq(obj.underline)
-        expect(round_trip.content.first.to_s).to match(/The Earth's Moon rings like a/)
+        expect(round_trip.content.first.to_s).to include("The Earth's Moon rings like a")
       end
     end