moxml 0.1.8 → 0.1.9

data/lib/moxml/adapter/rexml.rb

@@ -23,6 +23,7 @@ module Moxml
             end
             create_document
           end
+
           DocumentBuilder.new(Context.new(:rexml)).build(native_doc)
         end
 
@@ -255,6 +256,12 @@ module Moxml
         end
 
         def add_child(element, child)
+          # Special handling for declarations on REXML documents
+          if element.is_a?(::REXML::Document) && child.is_a?(::REXML::XMLDecl)
+            # Set document's xml_decl directly
+            element.instance_variable_set(:@xml_declaration, child)
+          end
+
           case child
           when String
             element.add_text(child)
@@ -279,6 +286,12 @@ module Moxml
         end
 
         def remove(node)
+          # Special handling for declarations on REXML documents
+          if node.is_a?(::REXML::XMLDecl) && node.parent.is_a?(::REXML::Document)
+            # Clear document's xml_declaration when removing declaration
+            node.parent.instance_variable_set(:@xml_declaration, nil)
+          end
+
           node.remove
         end
 
@@ -453,16 +466,25 @@ module Moxml
           output = +""
 
           if node.is_a?(::REXML::Document)
-            # Always include XML declaration
-            decl = node.xml_decl || ::REXML::XMLDecl.new("1.0",
-                                                         options[:encoding] || "UTF-8")
-            decl.encoding = options[:encoding] if options[:encoding]
-            output << "<?xml"
-            output << %( version="#{decl.version}") if decl.version
-            output << %( encoding="#{decl.encoding}") if decl.encoding
-            output << %( standalone="#{decl.standalone}") if decl.standalone
-            output << "?>"
-            # output << "\n"
+            # Check if we should include declaration
+            # Priority: explicit option > check if document has xml_decl
+            should_include_decl = if options.key?(:no_declaration)
+                                    !options[:no_declaration]
+                                  else
+                                    # Include declaration only if document has xml_decl
+                                    !node.xml_decl.nil?
+                                  end
+
+            # Include XML declaration only if should_include_decl and xml_decl exists
+            if should_include_decl && node.xml_decl
+              decl = node.xml_decl
+              decl.encoding = options[:encoding] if options[:encoding]
+              output << "<?xml"
+              output << %( version="#{decl.version}") if decl.version
+              output << %( encoding="#{decl.encoding}") if decl.encoding
+              output << %( standalone="#{decl.standalone}") if decl.standalone
+              output << "?>"
+            end
 
             # output << "\n"
             node.doctype&.write(output)

data/lib/moxml/context.rb

@@ -13,7 +13,24 @@ module Moxml
     end
 
     def parse(xml, options = {})
-      config.adapter.parse(xml, default_options.merge(options))
+      # Detect if input has XML declaration
+      xml_string = if xml.respond_to?(:read)
+                     xml.read.tap do
+                       xml.rewind if xml.respond_to?(:rewind)
+                     end
+                   else
+                     xml.to_s
+                   end
+      has_declaration = xml_string.strip.start_with?("<?xml")
+
+      # Parse with adapter (without declaration info - adapters don't need it)
+      parsed_options = default_options.merge(options)
+      doc = config.adapter.parse(xml_string, parsed_options)
+
+      # Set declaration flag on Document wrapper (proper OOP)
+      doc.has_xml_declaration = has_declaration if doc.is_a?(Document)
+
+      doc
     end
 
     # Parse XML using SAX (event-driven) parsing

data/lib/moxml/declaration.rb

@@ -33,6 +33,15 @@ module Moxml
       adapter.set_declaration_attribute(@native, "standalone", new_standalone)
     end
 
+    def remove
+      # Mark document as having no declaration when declaration is removed
+      # Store on native document so all wrappers see it
+      native_doc = adapter.document(@native)
+      native_doc&.instance_variable_set(:@moxml_has_declaration, false)
+
+      super
+    end
+
     def declaration?
       true
     end

data/lib/moxml/document.rb

@@ -12,6 +12,17 @@ require_relative "doctype"
 
 module Moxml
   class Document < Node
+    attr_accessor :has_xml_declaration
+
+    def initialize(native, context)
+      super
+      @has_xml_declaration = false
+    end
+
+    def document
+      self
+    end
+
     def root=(element)
       adapter.set_root(@native, element.native)
     end
@@ -61,6 +72,9 @@ module Moxml
       node = prepare_node(node)
 
       if node.is_a?(Declaration)
+        # Mark that document now has a declaration
+        @has_xml_declaration = true
+
         if children.empty?
           adapter.add_child(@native, node.native)
         else

data/lib/moxml/document_builder.rb

@@ -12,6 +12,13 @@ module Moxml
     def build(native_doc)
       @current_doc = context.create_document(native_doc)
 
+      # Transfer has_declaration flag if present
+      if native_doc.respond_to?(:instance_variable_get) &&
+          native_doc.instance_variable_defined?(:@moxml_has_declaration)
+        has_declaration = native_doc.instance_variable_get(:@moxml_has_declaration)
+        @current_doc.has_xml_declaration = has_declaration
+      end
+
       # Transfer DOCTYPE from parsed document if it exists
       if native_doc.respond_to?(:instance_variable_get) &&
           native_doc.instance_variable_defined?(:@moxml_doctype)

data/lib/moxml/node.rb

@@ -73,7 +73,13 @@ module Moxml
     end
 
     def to_xml(options = {})
-      adapter.serialize(@native, default_options.merge(options))
+      # Determine if we should include XML declaration
+      # For Document nodes: check native then wrapper, unless explicitly overridden
+      # For other nodes: default to no declaration unless explicitly set
+      serialize_options = default_options.merge(options)
+      serialize_options[:no_declaration] = !should_include_declaration?(options)
+
+      adapter.serialize(@native, serialize_options)
     end
 
     def xpath(expression, namespaces = {})
@@ -235,5 +241,59 @@ module Moxml
         expand_empty: true,
       }
     end
+
+    def should_include_declaration?(options)
+      return options[:declaration] if options.key?(:declaration)
+      return options.fetch(:declaration, false) unless is_a?(Document)
+
+      # For Document nodes, check both wrapper flag and native state
+      # Wrapper flag is set by Context.parse for parsed documents
+      # Native state reflects programmatic changes (e.g., add/remove)
+
+      adapter_name = adapter.to_s.split("::").last
+
+      case adapter_name
+      when "Nokogiri"
+        # Nokogiri: if @xml_decl is explicitly set, use that state
+        # Otherwise, trust wrapper flag (for parsed documents)
+        if native.respond_to?(:instance_variable_defined?) &&
+            native.instance_variable_defined?(:@xml_decl)
+          # Explicitly set (programmatically added) - check if nil
+          !native.instance_variable_get(:@xml_decl).nil?
+        else
+          # Not set (parsed document) - trust wrapper flag
+          has_xml_declaration
+        end
+      when "Rexml"
+        # REXML: check @xml_declaration instance variable
+        # If not defined (parsed doc), trust wrapper flag
+        if native.respond_to?(:instance_variable_defined?) &&
+            native.instance_variable_defined?(:@xml_declaration)
+          # Explicitly set - check if nil
+          !native.instance_variable_get(:@xml_declaration).nil?
+        else
+          # Not set (parsed document) - trust wrapper flag
+          has_xml_declaration
+        end
+      when "Oga"
+        native.respond_to?(:xml_declaration) && !native.xml_declaration.nil?
+      when "Ox", "HeadedOx"
+        # Ox stores declaration in document attributes
+        native[:version] || native[:encoding] || native[:standalone]
+      when "Libxml"
+        # LibXML stores declaration wrapper as instance variable
+        if native.respond_to?(:instance_variable_defined?) &&
+            native.instance_variable_defined?(:@moxml_declaration)
+          # Explicitly set - check if nil
+          !native.instance_variable_get(:@moxml_declaration).nil?
+        else
+          # Not set - trust wrapper flag
+          has_xml_declaration
+        end
+      else
+        # Fallback - trust wrapper flag
+        has_xml_declaration
+      end
+    end
   end
 end

data/lib/moxml/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Moxml
-  VERSION = "0.1.8"
+  VERSION = "0.1.9"
 end

data/lib/moxml/xpath/compiler.rb

@@ -976,8 +976,10 @@ module Moxml
           conversions << conversion.to_string(arg_var)
         end
 
+        # rubocop:disable Style/RedundantSum, Performance/Sum
         concatted = assigns.inject(:followed_by)
           .followed_by(conversions.inject(:+))
+        # rubocop:enable Style/RedundantSum, Performance/Sum
 
         block_given? ? concatted.empty?.if_false { yield concatted } : concatted
       end

data/spec/integration/shared_examples/node_wrappers/declaration_behavior.rb

@@ -98,9 +98,6 @@ RSpec.shared_examples "Moxml::Declaration" do
     end
 
     it "removes from document" do
-      if Moxml.new.config.adapter.name.match?(/Nokogiri|Rexml|Ox/)
-        pending("The document contains a default declaration")
-      end
       doc.add_child(declaration)
       declaration.remove
       expect(doc.to_xml).not_to include("<?xml")

data/spec/moxml/declaration_preservation_spec.rb

@@ -0,0 +1,217 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe "XML Declaration Preservation" do
+  # Test with all available adapters
+  ADAPTERS = %i[nokogiri oga rexml ox libxml headed_ox].freeze
+
+  ADAPTERS.each do |adapter_name|
+    context "with #{adapter_name} adapter" do
+      let(:context) { Moxml.new(adapter_name) }
+
+      describe "automatic preservation" do
+        context "when input has no XML declaration" do
+          let(:xml_without_decl) { '<svg xmlns="http://www.w3.org/2000/svg"><rect/></svg>' }
+
+          it "does not add XML declaration to output" do
+            doc = context.parse(xml_without_decl)
+            output = doc.to_xml
+
+            expect(output).not_to include("<?xml")
+            expect(output).to include("<svg")
+          end
+
+          it "sets has_xml_declaration to false" do
+            doc = context.parse(xml_without_decl)
+            expect(doc.has_xml_declaration).to be false
+          end
+        end
+
+        context "when input has XML declaration" do
+          let(:xml_with_decl) do
+            '<?xml version="1.0" encoding="UTF-8"?><root><child/></root>'
+          end
+
+          it "preserves XML declaration in output" do
+            doc = context.parse(xml_with_decl)
+            output = doc.to_xml
+
+            expect(output).to include("<?xml")
+            expect(output).to include('version="1.0"')
+          end
+
+          it "sets has_xml_declaration to true" do
+            doc = context.parse(xml_with_decl)
+            expect(doc.has_xml_declaration).to be true
+          end
+        end
+
+        context "when input has declaration with standalone attribute" do
+          let(:xml_with_standalone) do
+            '<?xml version="1.0" encoding="UTF-8" standalone="yes"?><root/>'
+          end
+
+          it "preserves the declaration" do
+            doc = context.parse(xml_with_standalone)
+            output = doc.to_xml
+
+            expect(output).to include("<?xml")
+          end
+        end
+      end
+
+      describe "explicit override" do
+        let(:xml_without_decl) { "<root><child/></root>" }
+        let(:xml_with_decl) { '<?xml version="1.0"?><root><child/></root>' }
+
+        context "when forcing declaration on document without one" do
+          it "adds declaration when declaration: true" do
+            doc = context.parse(xml_without_decl)
+            output = doc.to_xml(declaration: true)
+
+            expect(output).to include("<?xml")
+          end
+        end
+
+        context "when removing declaration from document with one" do
+          it "removes declaration when declaration: false" do
+            doc = context.parse(xml_with_decl)
+            output = doc.to_xml(declaration: false)
+
+            expect(output).not_to include("<?xml")
+            expect(output).to include("<root")
+          end
+        end
+
+        context "when explicitly preserving declaration" do
+          it "keeps declaration when declaration: true" do
+            doc = context.parse(xml_with_decl)
+            output = doc.to_xml(declaration: true)
+
+            expect(output).to include("<?xml")
+          end
+        end
+      end
+
+      describe "round-trip fidelity" do
+        context "for document without declaration" do
+          let(:original) { "<root><item id=\"1\"/></root>" }
+
+          it "maintains absence of declaration through parse and serialize" do
+            doc = context.parse(original)
+            output = doc.to_xml
+
+            expect(output).not_to include("<?xml")
+
+            # Parse again and verify
+            doc2 = context.parse(output)
+            expect(doc2.has_xml_declaration).to be false
+          end
+        end
+
+        context "for document with declaration" do
+          let(:original) do
+            '<?xml version="1.0" encoding="UTF-8"?><root><item id="1"/></root>'
+          end
+
+          it "maintains presence of declaration through parse and serialize" do
+            doc = context.parse(original)
+            output = doc.to_xml
+
+            expect(output).to include("<?xml")
+
+            # Parse again and verify
+            doc2 = context.parse(output)
+            expect(doc2.has_xml_declaration).to be true
+          end
+        end
+      end
+
+      describe "edge cases" do
+        context "with empty document" do
+          it "does not add declaration to empty document" do
+            doc = context.create_document
+
+            # Empty documents should not have declaration by default
+            expect(doc.has_xml_declaration).to be false
+          end
+        end
+
+        context "with built document" do
+          it "does not add declaration to programmatically built document" do
+            doc = context.create_document
+            root = doc.create_element("root")
+            doc.root = root
+
+            output = doc.to_xml
+
+            expect(output).not_to include("<?xml")
+            expect(doc.has_xml_declaration).to be false
+          end
+
+          it "can explicitly add declaration to built document" do
+            doc = context.create_document
+            root = doc.create_element("root")
+            doc.root = root
+
+            output = doc.to_xml(declaration: true)
+
+            expect(output).to include("<?xml")
+          end
+        end
+      end
+
+      describe "non-document nodes" do
+        let(:xml) { '<?xml version="1.0"?><root><child>text</child></root>' }
+
+        it "does not add declaration when serializing element nodes" do
+          doc = context.parse(xml)
+          root = doc.root
+          output = root.to_xml
+
+          expect(output).not_to include("<?xml")
+          expect(output).to include("<root>")
+        end
+      end
+    end
+  end
+
+  describe "integration with svg_conform use case" do
+    let(:context) { Moxml.new }
+
+    context "remediating SVG without declaration" do
+      let(:svg_input) { '<svg xmlns="http://www.w3.org/2000/svg" width="100" height="100"><rect x="10" y="10" width="80" height="80"/></svg>' }
+
+      it "does not add declaration to remediated output" do
+        doc = context.parse(svg_input)
+
+        # Simulate remediation: add viewport
+        root = doc.root
+        root["viewBox"] = "0 0 100 100"
+
+        output = doc.to_xml
+
+        expect(output).not_to include("<?xml")
+        expect(output).to include('viewBox="0 0 100 100"')
+      end
+    end
+
+    context "remediating SVG with declaration" do
+      let(:svg_input) { '<?xml version="1.0" encoding="UTF-8"?><svg xmlns="http://www.w3.org/2000/svg"><rect/></svg>' }
+
+      it "preserves declaration in remediated output" do
+        doc = context.parse(svg_input)
+
+        # Simulate remediation
+        root = doc.root
+        root["viewBox"] = "0 0 100 100"
+
+        output = doc.to_xml
+
+        expect(output).to include("<?xml")
+        expect(output).to include('viewBox="0 0 100 100"')
+      end
+    end
+  end
+end

data/spec/performance/memory_usage_spec.rb

@@ -51,9 +51,10 @@ RSpec.shared_examples "Memory Usage Examples" do
     end
 
     it "handles streaming processing" do
-      if %i[ox headed_ox].include?(context.config.adapter_name)
-        pending "Ox/HeadedOx have load_file method but not stream parsing"
+      if context.config.adapter_name == :headed_ox
+        pending "HeadedOx double-wrapping issue with file-based parsing"
       end
+
       # Process file
       doc = nil
       File.open("spec/fixtures/small.xml") do |f|

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: moxml
 version: !ruby/object:Gem::Version
-  version: 0.1.8
+  version: 0.1.9
 platform: ruby
 authors:
 - Ribose Inc.
@@ -47,6 +47,7 @@ files:
 - docs/_guides/parsing-xml.adoc
 - docs/_guides/sax-parsing.adoc
 - docs/_guides/working-with-documents.adoc
+- docs/_guides/xml-declaration.adoc
 - docs/_pages/adapter-compatibility.adoc
 - docs/_pages/adapters/headed-ox.adoc
 - docs/_pages/adapters/index.adoc
@@ -203,6 +204,7 @@ files:
 - spec/moxml/comment_spec.rb
 - spec/moxml/config_spec.rb
 - spec/moxml/context_spec.rb
+- spec/moxml/declaration_preservation_spec.rb
 - spec/moxml/declaration_spec.rb
 - spec/moxml/doctype_spec.rb
 - spec/moxml/document_builder_spec.rb