moxml 0.1.8 → 0.1.10

data/lib/moxml/adapter/ox.rb

@@ -348,6 +348,24 @@ module Moxml
         end
 
         def add_child(element, child)
+          # Special handling for declarations on Ox documents
+          if element.is_a?(::Ox::Document) && child.is_a?(::Ox::Instruct) && child.target == "xml"
+            # Transfer declaration attributes to document
+            element.attributes ||= {}
+            if child.attributes["version"]
+              element.attributes[:version] =
+                child.attributes["version"]
+            end
+            if child.attributes["encoding"]
+              element.attributes[:encoding] =
+                child.attributes["encoding"]
+            end
+            if child.attributes["standalone"]
+              element.attributes[:standalone] =
+                child.attributes["standalone"]
+            end
+          end
+
           child.parent = element if child.respond_to?(:parent)
           element.nodes ||= []
           element.nodes << child
@@ -380,6 +398,15 @@ module Moxml
 
           return unless parent(node)
 
+          # Special handling for declarations on Ox documents
+          if parent(node).is_a?(::Ox::Document) && node.is_a?(::Ox::Instruct) && node.target == "xml"
+            # Clear declaration attributes from document
+            doc = parent(node)
+            doc.attributes&.delete(:version)
+            doc.attributes&.delete(:encoding)
+            doc.attributes&.delete(:standalone)
+          end
+
           parent(node).nodes.delete(unpatch_node(node))
         end
 
@@ -483,6 +510,31 @@ module Moxml
           end.values
         end
 
+        # Doctype accessor methods
+        # Ox stores DOCTYPE as a string, so we parse it
+        def doctype_name(native)
+          # Parse: "name PUBLIC \"external_id\" \"system_id\"" or "name SYSTEM \"system_id\""
+          value = native.value.to_s.strip
+          # Extract the first word (the name)
+          value.split(/\s+/).first
+        end
+
+        def doctype_external_id(native)
+          value = native.value.to_s
+          # Match PUBLIC "external_id"
+          match = value.match(/PUBLIC\s+"([^"]*)"/)
+          match ? match[1] : nil
+        end
+
+        def doctype_system_id(native)
+          value = native.value.to_s
+          # Match the last quoted string (system_id)
+          # For PUBLIC: "name PUBLIC \"external_id\" \"system_id\""
+          # For SYSTEM: "name SYSTEM \"system_id\""
+          matches = value.scan(/"([^"]*)"/)
+          matches.last&.first
+        end
+
         def xpath(node, expression, namespaces = {})
           # Translate common XPath patterns to Ox locate() syntax
           locate_expr = translate_xpath_to_locate(expression, namespaces)
@@ -524,13 +576,24 @@ module Moxml
         def serialize(node, options = {})
           output = ""
           if node.is_a?(::Ox::Document)
-            # add declaration
-            version = node[:version] || "1.0"
-            encoding = options[:encoding] || node[:encoding]
-            standalone = node[:standalone]
-
-            decl = create_native_declaration(version, encoding, standalone)
-            output = ::Ox.dump(::Ox::Document.new << decl).strip
+            # Check if we should include declaration
+            # Priority: explicit option > document attributes
+            should_include_decl = if options.key?(:no_declaration)
+                                    !options[:no_declaration]
+                                  else
+                                    # Check if document has declaration attributes
+                                    node[:version] || node[:encoding] || node[:standalone]
+                                  end
+
+            # Only add declaration if should_include_decl is true
+            if should_include_decl
+              version = node[:version] || "1.0"
+              encoding = options[:encoding] || node[:encoding]
+              standalone = node[:standalone]
+
+              decl = create_native_declaration(version, encoding, standalone)
+              output = ::Ox.dump(::Ox::Document.new << decl).strip
+            end
           end
 
           ox_options = {

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
 
@@ -413,6 +426,19 @@ module Moxml
           end
         end
 
+        # Doctype accessor methods
+        def doctype_name(native)
+          native.name
+        end
+
+        def doctype_external_id(native)
+          native.public
+        end
+
+        def doctype_system_id(native)
+          native.system
+        end
+
         # not used at the moment
         # but may be useful when the xpath is upgraded to work with namespaces
         def prepare_xpath_namespaces(node)
@@ -453,16 +479,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/attribute.rb

@@ -10,6 +10,12 @@ module Moxml
       adapter.set_attribute_name(@native, new_name)
     end
 
+    # Returns the primary identifier for this attribute (its name)
+    # @return [String] the attribute name
+    def identifier
+      name
+    end
+
     def value
       @native.value
     end

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/doctype.rb

@@ -1,17 +1,50 @@
 # frozen_string_literal: true
 
 module Moxml
+  # Represents an XML DOCTYPE declaration
+  #
+  # @note Doctype accessor methods are not fully implemented across all adapters.
+  #   The availability of #name, #external_id, and #system_id depends on whether
+  #   the specific adapter implements the corresponding adapter methods:
+  #   - adapter.doctype_name(native)
+  #   - adapter.doctype_external_id(native)
+  #   - adapter.doctype_system_id(native)
+  #
+  #   Most adapters do not currently implement these methods. If you need DOCTYPE
+  #   information, consider using adapter-specific methods or parsing the serialized
+  #   XML manually.
   class Doctype < Node
+    # Returns the DOCTYPE name (root element name)
+    #
+    # @return [String, nil] the DOCTYPE name
+    # @raise [NotImplementedError] if the adapter doesn't implement doctype_name
     def name
       adapter.doctype_name(@native)
     end
 
+    # Returns the DOCTYPE external ID
+    #
+    # @return [String, nil] the external ID
+    # @raise [NotImplementedError] if the adapter doesn't implement doctype_external_id
     def external_id
       adapter.doctype_external_id(@native)
     end
 
+    # Returns the DOCTYPE system ID
+    #
+    # @return [String, nil] the system ID
+    # @raise [NotImplementedError] if the adapter doesn't implement doctype_system_id
     def system_id
       adapter.doctype_system_id(@native)
     end
+
+    # Returns the primary identifier for this doctype
+    # Since DOCTYPE information is not reliably available across adapters,
+    # this returns nil.
+    #
+    # @return [nil]
+    def identifier
+      name
+    end
   end
 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/element.rb

@@ -13,6 +13,12 @@ module Moxml
       adapter.set_node_name(@native, value)
     end
 
+    # Returns the primary identifier for this element (its tag name)
+    # @return [String] the element name
+    def identifier
+      name
+    end
+
     # Returns the expanded name including namespace prefix
     def expanded_name
       if namespace_prefix && !namespace_prefix.empty?

data/lib/moxml/error.rb

@@ -40,7 +40,7 @@ module Moxml
       msg = super
       msg += "\n  Expression: #{@expression}" if @expression
       msg += "\n  Adapter: #{@adapter}" if @adapter
-      msg += "\n  Node: <#{@node.name}>" if @node.respond_to?(:name)
+      msg += "\n  Node: <#{@node.name}>" if @node.is_a?(Element) || @node.is_a?(Attribute)
       msg += "\n  Hint: Verify XPath syntax and ensure the adapter supports the expression"
       msg
     end
@@ -60,9 +60,9 @@ module Moxml
     def to_s
       msg = super
       # Only add extra details if any were provided
-      has_details = @node.respond_to?(:name) || @constraint || @value
+      has_details = (@node.is_a?(Element) || @node.is_a?(Attribute)) || @constraint || @value
       if has_details
-        msg += "\n  Node: <#{@node.name}>" if @node.respond_to?(:name)
+        msg += "\n  Node: <#{@node.name}>" if @node.is_a?(Element) || @node.is_a?(Attribute)
         msg += "\n  Constraint: #{@constraint}" if @constraint
         msg += "\n  Value: #{@value.inspect}" if @value
         msg += "\n  Hint: Ensure the value meets XML specification requirements"
@@ -119,7 +119,7 @@ module Moxml
 
     def to_s
       msg = super
-      msg += "\n  Node: <#{@node.name}>" if @node.respond_to?(:name)
+      msg += "\n  Node: <#{@node.name}>" if @node.is_a?(Element) || @node.is_a?(Attribute)
       msg += "\n  Adapter: #{@adapter}" if @adapter
       msg += "\n  Format: #{@format}" if @format
       msg += "\n  Hint: Check that the node structure is valid for serialization"
@@ -160,7 +160,7 @@ module Moxml
     def to_s
       msg = super
       msg += "\n  Attribute: #{@attribute_name}" if @attribute_name
-      msg += "\n  Element: <#{@element.name}>" if @element.respond_to?(:name)
+      msg += "\n  Element: <#{@element.name}>" if @element.is_a?(Element)
       msg += "\n  Value: #{@value.inspect}" if @value
       msg += "\n  Hint: Verify attribute name follows XML naming rules"
       msg

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 = {})
@@ -180,6 +186,18 @@ module Moxml
       end
     end
 
+    # Returns the primary identifier for this node type
+    # For Element: the tag name
+    # For Attribute: the attribute name
+    # For ProcessingInstruction: the target
+    # For content nodes (Text, Comment, Cdata, Declaration): nil (no identifier)
+    # For Doctype: nil (not fully implemented across adapters)
+    #
+    # @return [String, nil] the node's primary identifier or nil
+    def identifier
+      nil
+    end
+
     def self.wrap(node, context)
       return nil if node.nil?
 
@@ -235,5 +253,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/processing_instruction.rb

@@ -10,6 +10,12 @@ module Moxml
       adapter.set_node_name(@native, new_target.to_s)
     end
 
+    # Returns the primary identifier for this processing instruction (its target)
+    # @return [String] the PI target
+    def identifier
+      target
+    end
+
     def content
       adapter.processing_instruction_content(@native)
     end

data/lib/moxml/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Moxml
-  VERSION = "0.1.8"
+  VERSION = "0.1.10"
 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/lib/moxml/xpath/errors.rb

@@ -36,7 +36,7 @@ module Moxml
 
       def to_s
         msg = super
-        msg += "\n  Context node: <#{@context_node.name}>" if @context_node.respond_to?(:name)
+        msg += "\n  Context node: <#{@context_node.name}>" if @context_node.is_a?(Moxml::Element) || @context_node.is_a?(Moxml::Attribute)
         msg += "\n  Step: #{@step}" if @step
         msg
       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")