moxml 0.1.13 → 0.1.15

data/lib/moxml/adapter/ox.rb

@@ -3,9 +3,7 @@
 require_relative "base"
 require "ox"
 require "stringio"
-require_relative "customized_ox/text"
-require_relative "customized_ox/attribute"
-require_relative "customized_ox/namespace"
+require_relative "customized_ox"
 
 # insert :parent methods to all Ox classes inherit the Node class
 Ox::Node.attr_accessor :parent
@@ -17,16 +15,19 @@ module Moxml
           replace_children(doc, [element])
         end
 
-        def parse(xml, _options = {}, _context = nil)
+        def parse(xml, options = {}, _context = nil)
           native_doc = begin
             result = ::Ox.parse(xml)
 
             # result can be either Document or Element
             if result.is_a?(::Ox::Document)
+              assign_parents(result)
+              validate_single_root(result) if options[:strict]
               result
             else
               doc = ::Ox::Document.new
               doc << result
+              assign_parents(doc)
               doc
             end
           rescue ::Ox::ParseError => e
@@ -37,7 +38,7 @@ module Moxml
           end
 
           ctx = _context || Context.new(:ox)
-          DocumentBuilder.new(ctx).build(native_doc)
+          Document.new(native_doc, ctx)
         end
 
         # SAX parsing implementation for Ox
@@ -50,7 +51,7 @@ module Moxml
           bridge = OxSAXBridge.new(handler)
 
           # Parse using Ox's SAX parser
-          xml_string = xml.respond_to?(:read) ? xml.read : xml.to_s
+          xml_string = xml.is_a?(IO) || xml.is_a?(StringIO) ? xml.read : xml.to_s
 
           begin
             ::Ox.sax_parse(bridge, StringIO.new(xml_string))
@@ -77,6 +78,14 @@ module Moxml
           content
         end
 
+        def create_native_entity_reference(name)
+          ::Moxml::Adapter::CustomizedOx::EntityReference.new(name)
+        end
+
+        def entity_reference_name(node)
+          node.name if node.is_a?(::Moxml::Adapter::CustomizedOx::EntityReference)
+        end
+
         def create_native_cdata(content, _owner_doc = nil)
           ::Ox::CData.new(content)
         end
@@ -121,11 +130,11 @@ module Moxml
         end
 
         def set_namespace(element, ns)
-          return unless element.respond_to?(:name)
+          return unless element.is_a?(::Ox::Element) || element.is_a?(::Ox::Node)
 
           prefix = ns.prefix
           # attributes don't have attributes but can have a namespace prefix
-          if element.respond_to?(:attributes)
+          if element.is_a?(::Ox::Element)
             set_attribute(element, ns.expanded_prefix,
                           ns.uri)
           end
@@ -136,8 +145,7 @@ module Moxml
 
         def namespace(element)
           prefix =
-            if element.respond_to?(:prefix)
-              # attribute
+            if element.is_a?(::Moxml::Adapter::CustomizedOx::Attribute)
               element.prefix
             elsif element.name.include?(":")
               element.name.split(":").first
@@ -145,7 +153,7 @@ module Moxml
           attr_name = ["xmlns", prefix].compact.join(":")
 
           ([element] + ancestors(element)).each do |node|
-            next unless node.respond_to?(:attributes) && node.attributes
+            next unless node.is_a?(::Ox::Element) && node.attributes
 
             if node[attr_name]
               return ::Moxml::Adapter::CustomizedOx::Namespace.new(
@@ -176,6 +184,7 @@ module Moxml
           when ::Ox::Instruct then :processing_instruction
           when ::Ox::Element then :element
           when ::Ox::DocType then :doctype
+          when ::Moxml::Adapter::CustomizedOx::EntityReference then :entity_reference
           when ::Moxml::Adapter::CustomizedOx::Namespace then :banespace
           when ::Moxml::Adapter::CustomizedOx::Attribute then :attribute
           else :unknown
@@ -194,10 +203,9 @@ module Moxml
         end
 
         def set_node_name(node, name)
-          if node.respond_to?(:name=)
-            node.name = name
-          elsif node.respond_to?(:value=)
-            node.value = name
+          case node
+          when ::Ox::Element then node.name = name
+          when ::Ox::Instruct then node.value = name
           end
         end
 
@@ -219,7 +227,7 @@ module Moxml
             else node
             end
 
-          new_node.parent = parent if new_node.respond_to?(:parent)
+          new_node.parent = parent if new_node.is_a?(::Ox::Node)
 
           new_node
         end
@@ -231,18 +239,25 @@ module Moxml
                                                                node.value]
           # when ::Moxml::Adapter::CustomizedOx::Attribute then { node.name => node.value }
           when ::Moxml::Adapter::CustomizedOx::Text then node.value
+          when ::Moxml::Adapter::CustomizedOx::EntityReference then node
           else node
           end
         end
 
         def children(node)
-          return [] unless node.respond_to?(:nodes)
+          return [] unless node.is_a?(::Ox::Element) || node.is_a?(::Ox::Document)
 
-          node.nodes || []
+          result = node.nodes || []
+          # Ox doesn't set parent references during parsing.
+          # Set them here so parent/sibling navigation works.
+          result.each do |child|
+            child.parent = node if child.respond_to?(:parent=)
+          end
+          result
         end
 
         def parent(node)
-          node.parent if node.respond_to?(:parent)
+          node.parent if node.is_a?(::Ox::Node)
         end
 
         def next_sibling(node)
@@ -272,9 +287,7 @@ module Moxml
         end
 
         def attributes(element)
-          unless element.respond_to?(:attributes) && element.attributes
-            return []
-          end
+          return [] unless element.is_a?(::Ox::Element) && element.attributes
 
           element.attributes.filter_map do |name, value|
             next if name.to_s.start_with?("xmlns")
@@ -324,7 +337,7 @@ module Moxml
         end
 
         def get_attribute(element, name)
-          return unless element.respond_to?(:attributes) && element.attributes
+          return unless element.is_a?(::Ox::HasAttrs) && element.attributes
           unless element.attributes.key?(name.to_s) || element.attributes.key?(name.to_s.to_sym)
             return
           end
@@ -342,7 +355,7 @@ module Moxml
         end
 
         def remove_attribute(element, name)
-          return unless element.respond_to?(:attributes) && element.attributes
+          return unless element.is_a?(::Ox::HasAttrs) && element.attributes
 
           element.attributes.delete(name.to_s)
           element.attributes.delete(name.to_s.to_sym)
@@ -367,15 +380,24 @@ module Moxml
             end
           end
 
-          child.parent = element if child.respond_to?(:parent)
+          child.parent = element if child.is_a?(::Ox::Node)
           element.nodes ||= []
           element.nodes << child
+
+          # Mark document if EntityReference is added (avoids tree scan in serialize)
+          if child.is_a?(::Moxml::Adapter::CustomizedOx::EntityReference)
+            root = element
+            while root.is_a?(::Ox::Node) && root.parent
+              root = root.parent
+            end
+            root&.instance_variable_set(:@moxml_entity_refs, true)
+          end
         end
 
         def add_previous_sibling(node, sibling)
           return unless (parent = parent(node))
 
-          if sibling.respond_to?(:parent)
+          if sibling.is_a?(::Ox::Node)
             sibling.parent&.nodes&.delete(sibling)
             sibling.parent = parent
           end
@@ -386,7 +408,7 @@ module Moxml
         def add_next_sibling(node, sibling)
           return unless (parent = parent(node))
 
-          if sibling.respond_to?(:parent)
+          if sibling.is_a?(::Ox::Node)
             sibling.parent&.nodes&.delete(sibling)
             sibling.parent = parent
           end
@@ -421,7 +443,7 @@ module Moxml
 
           return unless (parent = parent(node))
 
-          new_node.parent = parent if new_node.respond_to?(:parent)
+          new_node.parent = parent if new_node.is_a?(::Ox::Node)
           idx = parent.nodes.index(node)
           parent.nodes[idx] = new_node if idx
         end
@@ -429,20 +451,40 @@ module Moxml
         def replace_children(node, new_children)
           node.remove_children_by_path("*")
           new_children.each do |child|
-            child.parent = node if child.respond_to?(:parent)
+            child.parent = node if child.is_a?(::Ox::Node)
             node << child
           end
           node
         end
 
+        def assign_parents(node, parent = nil)
+          node.parent = parent if node.respond_to?(:parent=) && parent
+          return unless node.respond_to?(:nodes)
+
+          node.nodes&.each do |child|
+            assign_parents(child, node)
+          end
+        end
+
+        def validate_single_root(document)
+          elements = document.nodes&.grep(::Ox::Element) || []
+          return unless elements.size > 1
+
+          raise Moxml::ParseError.new(
+            "Multiple root elements found",
+            source: nil,
+          )
+        end
+
         def text_content(node)
           return "" if node.nil?
 
           case node
           when String then node.to_s
           when ::Moxml::Adapter::CustomizedOx::Text then node.value
+          when ::Moxml::Adapter::CustomizedOx::EntityReference then ""
           else
-            return "" unless node.respond_to?(:nodes)
+            return "" unless node.is_a?(::Ox::Element) || node.is_a?(::Ox::Document)
 
             node.nodes.map do |n|
               text_content(n)
@@ -451,7 +493,7 @@ module Moxml
         end
 
         def inner_text(node)
-          return "" unless node.respond_to?(:nodes)
+          return "" unless node.is_a?(::Ox::Element) || node.is_a?(::Ox::Document)
 
           node.nodes.grep(String).join
         end
@@ -499,7 +541,7 @@ module Moxml
 
         def namespace_definitions(node)
           ([node] + ancestors(node)).reverse.each_with_object({}) do |n, namespaces|
-            next unless n.respond_to?(:attributes) && n.attributes
+            next unless n.is_a?(::Ox::Element) && n.attributes
 
             n.attributes.each do |name, value|
               next unless name.to_s.start_with?("xmlns")
@@ -575,18 +617,30 @@ module Moxml
         end
 
         def serialize(node, options = {})
+          # Fast path: skip EntityReference scan for documents (most common case)
+          if node.is_a?(::Ox::Document) &&
+              !node.instance_variable_get(:@moxml_entity_refs)
+            return serialize_standard(node, options)
+          end
+
+          if tree_has_entity_references?(node)
+            serialize_custom(node, options)
+          else
+            serialize_standard(node, options)
+          end
+        end
+
+        private
+
+        def serialize_standard(node, options = {})
           output = ""
           if node.is_a?(::Ox::Document)
-            # 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]
@@ -598,8 +652,7 @@ module Moxml
           end
 
           ox_options = {
-            indent: -1, # options[:indent] || -1, # indent is a beast
-            # with_xml: true,
+            indent: -1,
             with_instructions: true,
             encoding: options[:encoding],
             no_empty: options[:expand_empty],
@@ -607,7 +660,102 @@ module Moxml
           output + ::Ox.dump(node, ox_options)
         end
 
-        private
+        def tree_has_entity_references?(node)
+          case node
+          when ::Moxml::Adapter::CustomizedOx::EntityReference
+            true
+          when ::Ox::Element
+            node.nodes&.any? do |child|
+              tree_has_entity_references?(child)
+            end || false
+          when ::Ox::Document
+            node.nodes&.any? do |child|
+              tree_has_entity_references?(child)
+            end || false
+          else
+            false
+          end
+        end
+
+        def serialize_custom(node, options = {})
+          output = +""
+          if node.is_a?(::Ox::Document)
+            should_include_decl = if options.key?(:no_declaration)
+                                    !options[:no_declaration]
+                                  else
+                                    node[:version] || node[:encoding] || node[:standalone]
+                                  end
+            if should_include_decl
+              version = node[:version] || "1.0"
+              encoding = options[:encoding] || node[:encoding]
+              standalone = node[:standalone]
+              output << "<?xml version=\"#{version}\""
+              output << " encoding=\"#{encoding}\"" if encoding
+              output << " standalone=\"#{standalone}\"" if standalone
+              output << "?>"
+            end
+            (node.nodes || []).each do |child|
+              output << serialize_node_custom(child)
+            end
+          else
+            output << serialize_node_custom(node)
+          end
+          output
+        end
+
+        def serialize_node_custom(node)
+          case node
+          when ::Ox::Element then serialize_element_custom(node)
+          when String then escape_xml_text(node)
+          when ::Moxml::Adapter::CustomizedOx::Text then escape_xml_text(node.value)
+          when ::Moxml::Adapter::CustomizedOx::EntityReference then "&#{node.name};"
+          when ::Ox::CData then "<![CDATA[#{node.value}]]>"
+          when ::Ox::Comment then "<!--#{node.value}-->"
+          when ::Ox::Instruct then "<?#{node.target} #{node.value || ''}?>"
+          when ::Ox::DocType then "<!DOCTYPE #{node.value}>"
+          else ""
+          end
+        end
+
+        def serialize_element_custom(elem)
+          output = "<#{elem.name}"
+          elem.attributes.each do |name, value|
+            output << " #{name}=\"#{escape_xml_attribute(value.to_s)}\""
+          end
+
+          if elem.nodes.nil? || elem.nodes.empty?
+            output << "/>"
+            return output
+          end
+
+          output << ">"
+          elem.nodes.each do |child|
+            output << serialize_node_custom(child)
+          end
+          output << "</#{elem.name}>"
+          output
+        end
+
+        def escape_xml_text(text)
+          text.to_s.gsub(/[<>&]/) do |match|
+            case match
+            when "<" then "&lt;"
+            when ">" then "&gt;"
+            when "&" then "&amp;"
+            end
+          end
+        end
+
+        def escape_xml_attribute(value)
+          value.to_s.gsub(/[<>&"]/) do |match|
+            case match
+            when "<" then "&lt;"
+            when ">" then "&gt;"
+            when "&" then "&amp;"
+            when '"' then "&quot;"
+            end
+          end
+        end
 
         # Translate a subset of XPath to Ox locate() syntax
         # Supports: //element, /path/to/element, .//element, element[@attr]
@@ -659,7 +807,7 @@ module Moxml
 
           result = nil
           traverse(root) do |node|
-            next unless node.respond_to?(:nodes)
+            next unless node.is_a?(::Ox::Element) || node.is_a?(::Ox::Document)
 
             node.nodes&.each do |child|
               if child.equal?(target_node)
@@ -676,7 +824,7 @@ module Moxml
           return unless node
 
           yield node
-          return unless node.respond_to?(:nodes)
+          return unless node.is_a?(::Ox::Element) || node.is_a?(::Ox::Document)
 
           node.nodes&.each { |child| traverse(child, &block) }
         end

data/lib/moxml/adapter/rexml.rb

@@ -4,7 +4,7 @@ require_relative "base"
 require "rexml/document"
 require "rexml/xpath"
 require "set"
-require_relative "customized_rexml/formatter"
+require_relative "customized_rexml"
 
 module Moxml
   module Adapter
@@ -54,7 +54,7 @@ module Moxml
 
           bridge = REXMLSAX2Bridge.new(handler)
 
-          xml_string = xml.respond_to?(:read) ? xml.read : xml.to_s
+          xml_string = xml.is_a?(IO) || xml.is_a?(StringIO) ? xml.read : xml.to_s
           source = ::REXML::IOSource.new(StringIO.new(xml_string))
 
           parser = ::REXML::Parsers::SAX2Parser.new(source)
@@ -77,6 +77,14 @@ module Moxml
           ::REXML::Text.new(content.to_s, true, nil)
         end
 
+        def create_native_entity_reference(name)
+          ::Moxml::Adapter::CustomizedRexml::EntityReference.new(name)
+        end
+
+        def entity_reference_name(node)
+          node.name if node.is_a?(::Moxml::Adapter::CustomizedRexml::EntityReference)
+        end
+
         def create_native_cdata(content, _owner_doc = nil)
           ::REXML::CData.new(content.to_s)
         end
@@ -124,6 +132,7 @@ module Moxml
           when ::REXML::Instruction then :processing_instruction
           when ::REXML::DocType then :doctype
           when ::REXML::XMLDecl then :declaration
+          when ::Moxml::Adapter::CustomizedRexml::EntityReference then :entity_reference
           else :unknown
           end
         end
@@ -149,13 +158,15 @@ module Moxml
         end
 
         def duplicate_node(node)
-          # Make a complete duplicate of the node
-          # https://stackoverflow.com/questions/23878384/why-the-original-element-got-changed-when-i-modify-the-copy-created-by-dup-meth
-          Marshal.load(Marshal.dump(node))
+          if node.respond_to?(:deep_clone)
+            node.deep_clone
+          else
+            Marshal.load(Marshal.dump(node))
+          end
         end
 
         def children(node)
-          return [] unless node.respond_to?(:children)
+          return [] unless node.is_a?(::REXML::Parent)
 
           # Get all children and filter out empty text nodes between elements
           result = node.children.reject do |child|
@@ -229,7 +240,7 @@ module Moxml
         end
 
         def attributes(element)
-          return [] unless element.respond_to?(:attributes)
+          return [] unless element.is_a?(::REXML::Element)
 
           # Only return non-namespace attributes
           element.attributes.values
@@ -280,6 +291,12 @@ module Moxml
           case child
           when String
             element.add_text(child)
+          when ::Moxml::Adapter::CustomizedRexml::EntityReference
+            # REXML doesn't support custom node types in its tree.
+            # Store alongside native children via instance variable.
+            refs = element.instance_variable_get(:@moxml_entity_refs) || []
+            refs << child
+            element.instance_variable_set(:@moxml_entity_refs, refs)
           else
             element.add(child)
           end
@@ -373,6 +390,8 @@ module Moxml
           case node
           when ::REXML::Text, ::REXML::CData
             node.value.to_s
+          when ::Moxml::Adapter::CustomizedRexml::EntityReference
+            ""
           when ::REXML::Element
             # Extract text recursively from all children to match other adapters
             extract_text_recursively(node)
@@ -428,7 +447,7 @@ module Moxml
         # add a namespace prefix to the element name AND a namespace definition
         def set_namespace(element, ns)
           prefix = ns.name.to_s.empty? ? "xmlns" : ns.name.to_s
-          if element.respond_to?(:add_namespace)
+          if element.is_a?(::REXML::Element)
             element.add_namespace(prefix,
                                   ns.value)
           end

data/lib/moxml/attribute.rb

@@ -45,6 +45,9 @@ module Moxml
 
     def remove
       adapter.remove_attribute(element, name)
+      if @parent_node.is_a?(Moxml::Element)
+        @parent_node.instance_variable_set(:@attributes_cache, nil)
+      end
       self
     end
 

data/lib/moxml/builder.rb

@@ -3,6 +3,7 @@
 module Moxml
   class Builder
     attr_reader :document
+    alias_method :doc, :document
 
     def initialize(context)
       @context = context

data/lib/moxml/config.rb

@@ -24,7 +24,7 @@ module Moxml
       end
     end
 
-    NAMESPACE_URI_MODES = %i[strict lenient].freeze
+    NAMESPACE_VALIDATION_MODES = %i[strict lenient].freeze
 
     attr_reader :adapter_name
     attr_accessor :strict_parsing,
@@ -35,7 +35,7 @@ module Moxml
                   :preload_entity_sets,
                   :entity_load_mode,
                   :entity_provider,
-                  :namespace_uri_mode
+                  :namespace_validation_mode
 
     def initialize(adapter_name = nil, strict_parsing = nil,
                    default_encoding = nil)
@@ -49,7 +49,7 @@ module Moxml
       @preload_entity_sets = []
       @entity_load_mode = :required
       @entity_provider = nil
-      @namespace_uri_mode = :strict
+      @namespace_validation_mode = :strict
     end
 
     def adapter=(name)
@@ -86,14 +86,14 @@ module Moxml
       @entity_load_mode = mode
     end
 
-    def namespace_uri_mode=(mode)
+    def namespace_validation_mode=(mode)
       mode = mode.to_sym
-      unless NAMESPACE_URI_MODES.include?(mode)
+      unless NAMESPACE_VALIDATION_MODES.include?(mode)
         raise ArgumentError,
-              "Invalid namespace_uri_mode: #{mode}. Must be one of: #{NAMESPACE_URI_MODES.join(', ')}"
+              "Invalid namespace_validation_mode: #{mode}. Must be one of: #{NAMESPACE_VALIDATION_MODES.join(', ')}"
       end
 
-      @namespace_uri_mode = mode
+      @namespace_validation_mode = mode
     end
 
     # Backward compatibility: convert old boolean to new symbol

data/lib/moxml/document.rb

@@ -26,11 +26,13 @@ module Moxml
 
     def root=(element)
       adapter.set_root(@native, element.native)
+      element.instance_variable_set(:@parent_node, self)
+      invalidate_children_cache!
     end
 
     def root
       root_element = adapter.root(@native)
-      root_element ? Element.wrap(root_element, context) : nil
+      root_element ? Element.new(root_element, context) : nil
     end
 
     def create_element(name)
@@ -91,6 +93,8 @@ module Moxml
       else
         adapter.add_child(@native, node.native)
       end
+      node.instance_variable_set(:@parent_node, self)
+      invalidate_children_cache!
       self
     end