lutaml-model 0.8.4 → 0.8.6

data/lib/lutaml/xml/serialization/instance_methods.rb

@@ -19,15 +19,24 @@ module Lutaml
         attr_accessor :element_order, :attribute_order, :schema_location,
                       :encoding, :doctype
 
-        # Store pre-collected namespace data for lazy plan building.
-        # This is a plain Hash (no adapter objects) collected during from_xml.
-        attr_accessor :pending_namespace_data
-
         # Store root element reference for truly lazy plan building.
         # Set in :lazy mode during deserialization; consumed on first to_xml.
         # Released after plan is built to allow GC of the DOM tree.
         attr_accessor :pending_plan_root_element
 
+        # Clear all internal XML parse state on this instance.
+        #
+        # Call before re-serializing a previously-parsed instance when the
+        # serialization context has changed (e.g. different namespace config,
+        # different XML document structure).
+        #
+        # @return [self]
+        def clear_xml_parse_state!
+          @import_declaration_plan = nil
+          @pending_plan_root_element = nil
+          self
+        end
+
         # XML namespace metadata for doubly-defined and alias support.
         # These carry information from deserialization to serialization.
         # Accessor methods use the @__ prefixed ivars for backward compatibility.
@@ -74,8 +83,8 @@ module Lutaml
         # Build or return the cached declaration plan.
         #
         # When import_declaration_plan: :lazy (default), builds the plan from
-        # pre-collected namespace data on first call. No-op when no pending
-        # data exists (:eager already set, :skip, or programmatic creation).
+        # the stored element reference on first call. No-op when no pending
+        # element exists (:eager already set, :skip, or programmatic creation).
         #
         # @return [DeclarationPlan, nil] The plan or nil
         def import_declaration_plan
@@ -178,8 +187,7 @@ module Lutaml
 
         # Extend INTERNAL_ATTRIBUTES with XML-specific ones
         def pretty_print_instance_variables
-          xml_internals = %i[@import_declaration_plan @xml_input_namespaces
-                             @pending_namespace_data @pending_plan_root_element
+          xml_internals = %i[@import_declaration_plan @pending_plan_root_element
                              @__xml_namespace_prefix
                              @__xml_ns_prefixes @__xml_original_namespace_uri
                              @xml_declaration @raw_schema_location]
@@ -232,11 +240,6 @@ module Lutaml
             options[:xml_declaration] = @xml_declaration
           end
 
-          # Pass input namespaces for Namespace Preservation
-          if instance_variable_defined?(:@xml_input_namespaces) && @xml_input_namespaces&.any?
-            options[:input_namespaces] = @xml_input_namespaces
-          end
-
           # Pass stored DeclarationPlan for format preservation.
           if import_declaration_plan
             options[:stored_xml_declaration_plan] = import_declaration_plan
@@ -253,39 +256,27 @@ module Lutaml
 
         private
 
-        # Build declaration plan from pre-collected namespace data or stored
-        # element reference (lazy mode). Called by xml_declaration_plan getter
-        # on first access.
+        # Build declaration plan from stored element reference (lazy mode).
+        # Called by import_declaration_plan getter on first access.
         # @return [DeclarationPlan, nil]
         def build_pending_declaration_plan
-          # Truly lazy: build namespace data from stored element reference
-          if @pending_plan_root_element
-            element = @pending_plan_root_element
-            @pending_plan_root_element = nil # Release reference (allows GC of DOM)
-            ns_data = Lutaml::Xml::ModelTransform.collect_element_namespaces(element)
-            if ns_data && !ns_data.empty?
-              xml_mapping = self.class.mappings_for(:xml)
-              return Lutaml::Xml::DeclarationPlan.from_input_with_locations(ns_data,
-                                                                            xml_mapping)
-            end
-            return nil
-          end
+          return nil unless @pending_plan_root_element
 
-          # Fallback: use pre-collected namespace data (eager-lazy hybrid)
-          ns = @pending_namespace_data
-          return nil unless ns
+          element = @pending_plan_root_element
+          @pending_plan_root_element = nil
+          ns_data = Lutaml::Xml::ModelTransform.collect_element_namespaces(element)
+          return nil unless ns_data && !ns_data.empty?
 
-          @pending_namespace_data = nil
           xml_mapping = self.class.mappings_for(:xml)
-          Lutaml::Xml::DeclarationPlan.from_input_with_locations(ns,
+          Lutaml::Xml::DeclarationPlan.from_input_with_locations(ns_data,
                                                                  xml_mapping)
         end
 
         def set_ordering(attrs)
-          return unless attrs.respond_to?(:item_order)
+          return unless attrs.is_a?(Lutaml::Xml::XmlElement)
 
           @element_order = attrs.item_order
-          @attribute_order = attrs.attribute_order if attrs.respond_to?(:attribute_order)
+          @attribute_order = attrs.attribute_order
         end
 
         def set_schema_location(attrs)

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

@@ -13,14 +13,10 @@ module Lutaml
     # is called with a block, the new element becomes the context for the duration
     # of the block, allowing nested element creation.
     class CustomMethodWrapper
-      # Initialize the wrapper
-      #
       # @param parent [XmlDataModel::XmlElement] Parent element to add children to
-      # @param rule [CompiledRule] The transformation rule
-      def initialize(parent, rule)
+      def initialize(parent)
         @parent = parent
-        @rule = rule
-        @context_stack = [parent] # Stack of context elements for nested creation
+        @context_stack = [parent]
       end
 
       # Get the current context element (top of stack)
@@ -70,9 +66,12 @@ module Lutaml
 
         if element_or_string.is_a?(String)
           add_xml_fragment_or_raw_content(parent, element_or_string)
-        else
-          # Add as child element
+        elsif element_or_string.is_a?(::Lutaml::Xml::DataModel::XmlElement)
           parent.add_child(element_or_string)
+        else
+          raise TypeError,
+                "add_element expects a String or XmlElement, got " \
+                "#{element_or_string.class}. Call .to_xml on the element first."
         end
         element_or_string
       end
@@ -81,7 +80,7 @@ module Lutaml
         require "moxml" unless defined?(Moxml)
         fragment_doc = Moxml.new.parse(fragment_string, fragment: true)
         add_fragment_children_to_parent(fragment_doc, parent)
-      rescue LoadError, StandardError
+      rescue LoadError
         append_raw_content(parent, fragment_string)
       end
 
@@ -135,12 +134,12 @@ module Lutaml
 
       # Add text to element (mimics old adapter API)
       #
-      # @param element [XmlDataModel::XmlElement, CustomMethodWrapper, nil] Element to add text to
+      # @param element [XmlDataModel::XmlElement, CustomMethodWrapper, nil]
+      #   Element to add text to. When the wrapper itself or nil is passed,
+      #   text is added to the current context element.
       # @param text [String] Text content
       def add_text(element, text)
-        # Handle case where element is the wrapper itself (for content mapping)
-        # or when element is nil (add to current context)
-        target = if element.is_a?(CustomMethodWrapper) || element.nil?
+        target = if element == self || element.nil?
                    current_context
                  else
                    element
@@ -169,32 +168,14 @@ module Lutaml
       # @yield [ElementWrapper] The created element for customization
       # @return [XmlElement] The created element
       def create_and_add_element(name, attributes: {})
-        # Create XmlDataModel element
-        element = Lutaml::Xml::DataModel::XmlElement.new(name)
-
-        # Add attributes if provided
-        attributes&.each do |attr_name, attr_value|
-          attr = Lutaml::Xml::DataModel::XmlAttribute.new(
-            attr_name.to_s, attr_value.to_s
-          )
-          element.add_attribute(attr)
-        end
-
-        # Add to current context
+        element = self.class.build_element(name, attributes)
         current_context.add_child(element)
 
         if block_given?
-          # Push this element as the new context for nested operations
           push_context(element)
-
           begin
-            # Create wrapper for the element
-            wrapped_element = ElementWrapper.new(element, self)
-
-            # Yield for customization (e.g., adding text, more nested elements)
-            yield wrapped_element
+            yield ElementWrapper.new(element, self)
           ensure
-            # Restore previous context
             pop_context
           end
         end
@@ -216,13 +197,7 @@ module Lutaml
         # @param text [String] Text content
         # @param cdata [Boolean, Hash] Whether to use CDATA (true or {cdata: true})
         def add_text(_self, text, cdata: false)
-          # Handle both cdata: true and cdata: {cdata: true} formats
-          use_cdata = if cdata.is_a?(Hash)
-                        cdata[:cdata] || false
-                      else
-                        cdata
-                      end
-
+          use_cdata = cdata.is_a?(Hash) ? cdata[:cdata] || false : cdata
           @element.text_content = text
           @element.cdata = use_cdata
         end
@@ -234,29 +209,33 @@ module Lutaml
         # @yield [ElementWrapper] The created element for customization
         # @return [XmlElement] The created element
         def create_and_add_element(name, attributes: {})
-          # Create XmlDataModel element
-          child = Lutaml::Xml::DataModel::XmlElement.new(name)
-
-          # Add attributes if provided
-          attributes&.each do |attr_name, attr_value|
-            attr = Lutaml::Xml::DataModel::XmlAttribute.new(
-              attr_name.to_s, attr_value.to_s
-            )
-            child.add_attribute(attr)
-          end
-
-          # Add to this element
+          child = CustomMethodWrapper.build_element(name, attributes)
           @element.add_child(child)
 
           if block_given?
-            # Wrap the child and yield
-            wrapped_child = ElementWrapper.new(child, @parent_wrapper)
-            yield wrapped_child
+            yield ElementWrapper.new(child, @parent_wrapper)
           end
 
           child
         end
       end
+
+      # Shared factory: create an XmlElement with optional attributes.
+      # Public so ElementWrapper can call it without an instance.
+      #
+      # @param name [String] Element name
+      # @param attributes [Hash] Optional attributes
+      # @return [DataModel::XmlElement]
+      def self.build_element(name, attributes)
+        element = Lutaml::Xml::DataModel::XmlElement.new(name)
+        attributes&.each do |attr_name, attr_value|
+          attr = Lutaml::Xml::DataModel::XmlAttribute.new(
+            attr_name.to_s, attr_value.to_s
+          )
+          element.add_attribute(attr)
+        end
+        element
+      end
     end
   end
 end

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

@@ -239,7 +239,7 @@ register_id)
         # @param model_class [Class] The model class
         # @param model_instance [Object] The model instance
         def apply_custom_method(parent, rule, model_class, model_instance)
-          wrapper = ::Lutaml::Xml::CustomMethodWrapper.new(parent, rule)
+          wrapper = ::Lutaml::Xml::CustomMethodWrapper.new(parent)
           mapper_instance = model_class.new
           mapper_instance.send(rule.custom_methods[:to], model_instance,
                                parent, wrapper)

data/lib/lutaml/xml/xml_element.rb

@@ -257,33 +257,26 @@ module Lutaml
         return @order_cache if @order_cache
 
         @order_cache = children.filter_map do |child|
-          if child.text?
+          if child.cdata?
+            Lutaml::Xml::Element.new("Text", "#cdata-section",
+                                     text_content: child.text,
+                                     node_type: :cdata)
+          elsif child.text?
             next if child.text.nil?
 
-            # For text nodes:
-            # - name is "text" for backward compatibility with tests
-            # - text_content contains the actual text for round-trip serialization
-            # - node_type explicitly marks this as a text node
             Lutaml::Xml::Element.new("Text", "text",
                                      text_content: child.text,
                                      node_type: :text)
-          elsif child.cdata?
-            # For CDATA sections:
-            # - name is "#cdata-section" for backward compatibility
-            # - text_content contains the actual CDATA content
-            # - node_type explicitly marks this as CDATA
-            Lutaml::Xml::Element.new("Text", "#cdata-section",
-                                     text_content: child.text,
-                                     node_type: :cdata)
           elsif child.comment?
             Lutaml::Xml::Element.new("Comment", "comment",
                                      text_content: child.text,
                                      node_type: :comment)
+          elsif child.processing_instruction?
+            Lutaml::Xml::Element.new("ProcessingInstruction",
+                                     child.unprefixed_name,
+                                     text_content: child.text,
+                                     node_type: :processing_instruction)
           else
-            # For regular elements:
-            # - name is the actual element name
-            # - node_type explicitly marks this as an element
-            # - namespace_uri and namespace_prefix preserve namespace info for rule matching
             Lutaml::Xml::Element.new("Element", child.unprefixed_name,
                                      node_type: :element,
                                      namespace_uri: child.namespace_uri,
@@ -303,14 +296,14 @@ module Lutaml
 
       def text
         return @text if children.empty?
-        return text_children.map(&:text) if children.count > 1
+        return text_children.map(&:text) if content_bearing_children_count > 1
 
         text_children.map(&:text).join
       end
 
       def cdata
         return @text if children.empty?
-        return cdata_children.map(&:text) if children.count > 1
+        return cdata_children.map(&:text) if content_bearing_children_count > 1
 
         cdata_children.map(&:text).join
       end
@@ -330,7 +323,8 @@ module Lutaml
 
         @element_children = children.reject do |child|
           child.is_a?(String) || child.is_a?(Symbol) ||
-            (child.is_a?(XmlElement) && child.text?)
+            (child.is_a?(XmlElement) &&
+              (child.text? || child.processing_instruction?))
         end
       end
 
@@ -389,6 +383,8 @@ module Lutaml
 
         @children_index = {}
         @children.each do |child|
+          next if child.is_a?(XmlElement) && child.processing_instruction?
+
           key = child.namespaced_name
           @children_index[key] ||= []
           @children_index[key] << child
@@ -432,6 +428,14 @@ module Lutaml
 
       private
 
+      # Count children that bear content (excludes processing instructions).
+      # Used to determine if content is mixed (multiple content nodes).
+      def content_bearing_children_count
+        children.count do |child|
+          !child.is_a?(XmlElement) || !child.processing_instruction?
+        end
+      end
+
       # Backward compatibility: infer node_type from name
       # This allows old code that doesn't pass node_type to still work
       def infer_node_type_from_name(name)

data/spec/lutaml/integration/edge_cases_spec.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require "lutaml/rdf"
+
+RSpec.describe "RDF Namespace edge cases" do
+  describe "Namespace immutability" do
+    it "prevents URI change after initial set" do
+      ns_class = Class.new(Lutaml::Rdf::Namespace)
+      ns_class.uri "http://example.org/"
+      expect { ns_class.uri "http://other.org/" }.to raise_error(FrozenError)
+    end
+
+    it "prevents prefix change after initial set" do
+      ns_class = Class.new(Lutaml::Rdf::Namespace)
+      ns_class.prefix "ex"
+      expect { ns_class.prefix "other" }.to raise_error(FrozenError)
+    end
+  end
+
+  describe "NamespaceSet collision detection" do
+    it "raises when adding two different classes with same prefix" do
+      ns1 = Class.new(Lutaml::Rdf::Namespace)
+      ns1.uri "http://one.org/"
+      ns1.prefix "ex"
+
+      ns2 = Class.new(Lutaml::Rdf::Namespace)
+      ns2.uri "http://two.org/"
+      ns2.prefix "ex"
+
+      set = Lutaml::Rdf::NamespaceSet.new(ns1)
+      expect { set.add(ns2) }.to raise_error(ArgumentError, /conflicts/)
+    end
+
+    it "allows adding the same class twice" do
+      ns = Class.new(Lutaml::Rdf::Namespace)
+      ns.uri "http://example.org/"
+      ns.prefix "ex"
+
+      set = Lutaml::Rdf::NamespaceSet.new(ns)
+      expect { set.add(ns) }.not_to raise_error
+      expect(set.size).to eq(1)
+    end
+  end
+
+  describe "NamespaceSet edge cases" do
+    it "returns nil for unknown prefix lookup" do
+      set = Lutaml::Rdf::NamespaceSet.new
+      expect(set["unknown"]).to be_nil
+    end
+
+    it "returns nil for unknown URI compaction" do
+      set = Lutaml::Rdf::NamespaceSet.new
+      expect(set.compact("http://unknown.org/thing")).to be_nil
+    end
+
+    it "handles empty namespace set" do
+      set = Lutaml::Rdf::NamespaceSet.new
+      expect(set.size).to eq(0)
+      expect(set.empty?).to be(true)
+      expect(set.to_a).to eq([])
+      expect(set.to_hash).to eq({})
+    end
+
+    it "returns value as-is when no colon in compact IRI" do
+      set = Lutaml::Rdf::NamespaceSet.new
+      expect(set.resolve_compact_iri("plain_name")).to eq("plain_name")
+    end
+  end
+
+  describe "Iri value object edge cases" do
+    it "stores frozen string value" do
+      iri = Lutaml::Rdf::Iri.new("http://example.org/")
+      expect(iri.value).to be_frozen
+    end
+
+    it "compares with Comparable" do
+      a = Lutaml::Rdf::Iri.new("http://a.org/")
+      b = Lutaml::Rdf::Iri.new("http://b.org/")
+      expect(a < b).to be(true)
+      expect(b < a).to be(false)
+    end
+
+    it "returns nil compact when no namespace matches" do
+      iri = Lutaml::Rdf::Iri.new("http://unknown.org/thing")
+      set = Lutaml::Rdf::NamespaceSet.new
+      expect(iri.compact(set)).to be_nil
+    end
+  end
+
+  describe "Literal value object edge cases" do
+    it "plain literal has no datatype or language" do
+      lit = Lutaml::Rdf::Literal.new("hello")
+      expect(lit.datatype).to be_nil
+      expect(lit.language).to be_nil
+    end
+
+    it "handles empty string value" do
+      lit = Lutaml::Rdf::Literal.new("")
+      expect(lit.to_turtle).to eq('""')
+      expect(lit.to_jsonld_term).to eq("")
+    end
+
+    it "escapes tabs in Turtle output" do
+      lit = Lutaml::Rdf::Literal.new("tab\there")
+      expect(lit.to_turtle).to include("\\t")
+    end
+  end
+end

data/spec/lutaml/integration/multi_format_spec.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require "lutaml/turtle"
+require "lutaml/jsonld"
+
+RSpec.describe "Multi-format model" do
+  before do
+    stub_const("TestSkosNs", Class.new(Lutaml::Rdf::Namespace) do
+      uri "http://www.w3.org/2004/02/skos/core#"
+      prefix "skos"
+    end)
+
+    stub_const("MultiFormatModel", Class.new(Lutaml::Model::Serializable) do
+      attribute :name, :string
+      attribute :description, :string
+      attribute :code, :string
+
+      json do
+        map "name", to: :name
+        map "description", to: :description
+        map "code", to: :code
+      end
+
+      rdf do
+        namespace TestSkosNs
+
+        subject { |m| "http://example.org/concept/#{m.code}" } # rubocop:disable RSpec/NamedSubject
+
+        type "skos:Concept"
+
+        predicate :prefLabel, namespace: TestSkosNs, to: :name
+        predicate :definition, namespace: TestSkosNs, to: :description
+        predicate :notation, namespace: TestSkosNs, to: :code
+      end
+    end)
+  end
+
+  let(:instance) do
+    MultiFormatModel.new(name: "test", description: "desc", code: "42")
+  end
+
+  describe "JSON format" do
+    it "serializes without @context" do
+      json = instance.to_json
+      parsed = JSON.parse(json)
+      expect(parsed).not_to have_key("@context")
+      expect(parsed["name"]).to eq("test")
+      expect(parsed["code"]).to eq("42")
+    end
+
+    it "round-trips" do
+      restored = MultiFormatModel.from_json(instance.to_json)
+      expect(restored.name).to eq("test")
+      expect(restored.code).to eq("42")
+    end
+  end
+
+  describe "JSON-LD format" do
+    it "serializes with @type and @id" do
+      jsonld = instance.to_jsonld
+      parsed = JSON.parse(jsonld)
+      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_jsonld(instance.to_jsonld)
+      expect(restored.name).to eq("test")
+      expect(restored.code).to eq("42")
+    end
+  end
+
+  describe "Turtle format" do
+    it "serializes with prefixes and type" do
+      turtle = instance.to_turtle
+      expect(turtle).to include("@prefix skos:")
+      expect(turtle).to include("a skos:Concept")
+      expect(turtle).to include("<http://example.org/concept/42>")
+      expect(turtle).to include("skos:prefLabel \"test\"")
+    end
+
+    it "round-trips" do
+      restored = MultiFormatModel.from_turtle(instance.to_turtle)
+      expect(restored.name).to eq("test")
+      expect(restored.code).to eq("42")
+    end
+  end
+
+  describe "cross-format independence" do
+    it "JSON serialization does not affect JSON-LD" do
+      json_parsed = JSON.parse(instance.to_json)
+      jsonld_parsed = JSON.parse(instance.to_jsonld)
+      expect(json_parsed).not_to have_key("@type")
+      expect(jsonld_parsed).to have_key("@type")
+    end
+
+    it "JSON-LD serialization does not affect Turtle" do
+      instance.to_jsonld
+      turtle = instance.to_turtle
+      expect(turtle).not_to include("@context")
+      expect(turtle).to include("@prefix")
+    end
+  end
+end