lutaml-model 0.8.16 → 0.8.17

data/lib/lutaml/xml/adapter_element.rb

@@ -129,7 +129,7 @@ module Lutaml
           next if attr_is_namespace?(attr)
 
           ns_prefix = attr.namespace&.prefix
-          ns_prefix = nil if ns_prefix&.empty?
+          ns_prefix = nil if ns_prefix && ns_prefix.empty?
 
           attr_name = ns_prefix ? "#{ns_prefix}:#{attr.name}" : attr.name
 
@@ -150,7 +150,7 @@ module Lutaml
           next if attr_is_namespace?(attr)
 
           ns_prefix = attr.namespace&.prefix
-          ns_prefix = nil if ns_prefix&.empty?
+          ns_prefix = nil if ns_prefix && ns_prefix.empty?
 
           attr_name = ns_prefix ? "#{ns_prefix}:#{attr.name}" : attr.name
           order << attr_name

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

@@ -251,18 +251,6 @@ child_transformation)
             value.xml_namespace_prefix = ns_prefix
           end
 
-          # Also set @__xml_namespace_prefix on the XmlElement for doubly-defined case.
-          # This is read by NamespaceCollector to set NamespaceUsage.used_prefix.
-          # For doubly-defined: parent has no ns, child's ns_prefix is from @__xml_ns_prefixes
-          # (not from parent's @__xml_namespace_prefix).
-          # For mixed content: parent's XmlElement already has @__xml_namespace_prefix set.
-          if parent_ns_class.nil? && ns_prefix && !ns_prefix.empty? && !child_ns_class
-            # Doubly-defined case: parent has no ns, child has ns class.
-            # Set on XmlElement so NamespaceCollector reads it.
-            # The value will be set on the model instance above (via @__xml_namespace_prefix)
-            # and we'll set it on XmlElement too so collection phase picks it up.
-          end
-
           child_element = child_transformation.transform(value, child_options)
 
           # Dual-namespace support: when the child model was deserialized from an element
@@ -304,15 +292,10 @@ child_transformation)
             child_element.name = rule.serialized_name
           end
 
-          # W3C elementFormDefault: unqualified override
-          # When parent's namespace has element_form_default :unqualified and the child's
-          # namespace is the same as the parent's, override to blank namespace.
-          # This ensures local elements are not namespace-qualified per W3C spec.
-          if parent_element_form_default == :unqualified &&
-              parent_ns_class &&
-              child_element.namespace_class == parent_ns_class
-            child_element.namespace_class = nil
-          end
+          propagate_form(child_element, rule)
+          apply_unqualified_form_default(
+            child_element, rule, parent_ns_class, parent_element_form_default
+          )
 
           child_element
         end
@@ -356,7 +339,7 @@ child_transformation)
             element.xml_namespace_prefix = model_ns_prefix
           end
 
-          element.form = rule.form if rule.form
+          propagate_form(element, rule)
           text = serialize_value(value, rule, rule.attribute_type, nil)
           element.text_content = text if text
           element
@@ -490,7 +473,7 @@ register_id)
             element.xml_namespace_prefix = ns_prefix
           end
 
-          element.form = rule.form if rule.form
+          propagate_form(element, rule)
 
           # Handle Hash type - expand hash into child elements
           if value.is_a?(::Hash) && rule.attribute_type == Lutaml::Model::Type::Hash
@@ -523,6 +506,38 @@ register_id)
           end
         end
 
+        # Copy the rule's form option onto the produced element so downstream
+        # rules (ElementFormOptionRule) can read it. Without this propagation
+        # the form option would be lost on transformed/fallback/simple paths.
+        #
+        # @param element [::Lutaml::Xml::DataModel::XmlElement] The element to update
+        # @param rule [CompiledRule] The rule carrying the form option
+        def propagate_form(element, rule)
+          element.form = rule.form if rule.form_set?
+        end
+
+        # W3C elementFormDefault: unqualified override.
+        #
+        # When the parent schema declares elementFormDefault="unqualified" and
+        # a locally-declared child lives in the same namespace as the parent,
+        # the child MUST NOT be namespace-qualified (XSD spec). An explicit
+        # form: :qualified on the rule is the user's per-element opt-out and
+        # takes precedence over the schema default.
+        #
+        # @param element [::Lutaml::Xml::DataModel::XmlElement] The element to update
+        # @param rule [CompiledRule] The rule (checked for explicit form override)
+        # @param parent_ns_class [Class, nil] Parent's namespace class
+        # @param parent_form_default [Symbol, nil] Parent's element_form_default
+        def apply_unqualified_form_default(element, rule, parent_ns_class,
+                                           parent_form_default)
+          return if rule.form == :qualified
+          return if parent_form_default != :unqualified
+          return unless parent_ns_class
+          return unless element.namespace_class == parent_ns_class
+
+          element.namespace_class = nil
+        end
+
         # Apply nil marker to element if needed
         #
         # @param element [XmlElement] The element

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
 

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
 

data/spec/lutaml/model/uninitialized_class_spec.rb

@@ -23,7 +23,7 @@ RSpec.describe Lutaml::Model::UninitializedClass do
 
   describe "#match?" do
     it "returns false for any argument" do
-      expect(uninitialized).not_to match /pattern/
+      expect(uninitialized).not_to include("pattern")
       expect(uninitialized).not_to match "string"
       expect(uninitialized).not_to match nil
     end

data/spec/lutaml/model/xsd_form_default_patterns_spec.rb

@@ -85,7 +85,7 @@ RSpec.describe "XSD Form Default Patterns" do
         xml = instance.to_xml
 
         # The element should be unqualified (no prefix) in instance
-        expect(xml).to match(%r{<premium})
+        expect(xml).to include("<premium")
         expect(xml).to include("<elementFormUnqualified")
       end
     end
@@ -281,7 +281,7 @@ RSpec.describe "XSD Form Default Patterns" do
         # and the namespace is already declared on an ancestor
         # The child element should be in the blank namespace without xmlns="" declaration
         # because the parent uses prefix format (xmlns:ex) or the namespace is already declared.
-        expect(result).not_to match(%r{xmlns=""})
+        expect(result).not_to include('xmlns=""')
       end
 
       it "serializes root element with namespace declaration" do

data/spec/lutaml/model/xsd_patterns_spec.rb

@@ -43,7 +43,7 @@ RSpec.describe "XSD Three Pattern Architecture" do
 
       expect(xsd).to include('<element name="item">')
       expect(xsd).to include("<complexType>")
-      expect(xsd).not_to match(/<complexType name=/)
+      expect(xsd).not_to include("<complexType name=")
       expect(xsd).to include('<attribute name="id" type="xs:string"/>')
     end
   end
@@ -68,7 +68,7 @@ RSpec.describe "XSD Three Pattern Architecture" do
       expect(xsd).to include('<element name="name" type="xs:string"/>')
       expect(xsd).to include('<element name="value" type="xs:integer"/>')
       # Should NOT generate standalone element declaration
-      expect(xsd).not_to match(/<element name="product"/)
+      expect(xsd).not_to include('<element name="product"')
     end
 
     it "type-only model can be referenced by other elements" do
@@ -233,7 +233,7 @@ RSpec.describe "XSD Three Pattern Architecture" do
 
       xsd = Lutaml::Model::Schema.to_xsd(klass)
       expect(xsd).to include('<element name="simple">')
-      expect(xsd).not_to match(/<element name="simple" type=/)
+      expect(xsd).not_to include('<element name="simple" type=')
     end
 
     it "Pattern 2: type_name only -> named reusable" do
@@ -252,7 +252,7 @@ RSpec.describe "XSD Three Pattern Architecture" do
       xsd = Lutaml::Model::Schema.to_xsd(klass)
       expect(xsd).to include('<complexType name="SimpleType">')
       # Should not have standalone element declaration (only child elements in sequence are OK)
-      expect(xsd).not_to match(/<element name="SimpleType"/)
+      expect(xsd).not_to include('<element name="SimpleType"')
     end
 
     it "Pattern 3: both -> element with named type" do

data/spec/lutaml/{jsonld → rdf}/context_spec.rb

@@ -1,9 +1,9 @@
 # frozen_string_literal: true
 
 require "spec_helper"
-require "lutaml/jsonld"
+require "lutaml/rdf"
 
-RSpec.describe Lutaml::JsonLd::Context do
+RSpec.describe Lutaml::Rdf::Context do
   subject(:ctx) { described_class.new }
 
   describe "empty context" do

data/spec/lutaml/{jsonld/transform_spec.rb → rdf/linked_data_transform_spec.rb}

@@ -2,8 +2,9 @@
 
 require "spec_helper"
 require "lutaml/jsonld"
+require "lutaml/yamlld"
 
-RSpec.describe Lutaml::JsonLd::Transform do
+RSpec.describe Lutaml::Rdf::LinkedDataTransform do
   before do
     stub_const("TestSkosNs", Class.new(Lutaml::Rdf::Namespace) do
       uri "http://www.w3.org/2004/02/skos/core#"
@@ -138,6 +139,19 @@ RSpec.describe Lutaml::JsonLd::Transform do
       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 "preserves data through model → YAML-LD → model" do
+      yaml = instance.to_yamlld
+      restored = JsonLdTestModel.from_yamlld(yaml)
+      expect(restored.name).to eq("test")
+      expect(restored.description).to eq("A test concept")
+    end
+
+    it "produces the same data model from YAML-LD 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
 
   describe "nil attribute values" do

data/spec/lutaml/{jsonld → rdf}/term_definition_spec.rb

@@ -1,9 +1,9 @@
 # frozen_string_literal: true
 
 require "spec_helper"
-require "lutaml/jsonld"
+require "lutaml/rdf"
 
-RSpec.describe Lutaml::JsonLd::TermDefinition do
+RSpec.describe Lutaml::Rdf::TermDefinition do
   it "simple term maps to name => id" do
     td = described_class.new(name: "name", id: "http://example.org/name")
     expect(td.to_context_hash).to eq("name" => "http://example.org/name")

data/spec/lutaml/turtle/transform_spec.rb

@@ -119,13 +119,13 @@ RSpec.describe Lutaml::Turtle::Transform do
     it "serializes integers as native Turtle literals" do
       instance = TypedModel.new(label: "test", count: 42, active: true)
       result = instance.to_turtle
-      expect(result).to match(/skos:notation 42/)
+      expect(result).to include("skos:notation 42")
     end
 
     it "serializes booleans as native Turtle literals" do
       instance = TypedModel.new(label: "test", count: 1, active: true)
       result = instance.to_turtle
-      expect(result).to match(/skos:note true/)
+      expect(result).to include("skos:note true")
     end
   end