moxml 0.1.16 → 0.1.18

data/lib/moxml/adapter/oga.rb

@@ -8,9 +8,6 @@ module Moxml
   module Adapter
     class Oga < Base
       class << self
-        # Standard XML entities handled natively by parsers
-        STANDARD_XML_ENTITIES = %w[amp lt gt quot apos].freeze
-
         def attachments
           @attachments ||= Moxml::NativeAttachment.new
         end
@@ -24,9 +21,7 @@ module Moxml
         end
 
         def parse(xml, options = {}, _context = nil)
-          # Pre-process XML to convert named entities to marker form (\x01name;).
-          # Oga drops named entity references like &nbsp; during parsing.
-          processed_xml = preprocess_named_entities(xml)
+          processed_xml = preprocess_entities(xml)
 
           native_doc = begin
             ::Oga.parse_xml(processed_xml, strict: options[:strict])
@@ -72,12 +67,12 @@ module Moxml
         end
 
         def create_native_text(content, _owner_doc = nil)
-          ::Oga::XML::Text.new(text: encode_entity_markers(content))
+          ::Oga::XML::Text.new(text: preprocess_entities(content))
         end
 
         def create_native_entity_reference(name)
           text = ::Oga::XML::Text.new
-          text.text = "#{ENTITY_MARKER}#{name};"
+          text.text = "#{self::ENTITY_MARKER}#{name};"
           attachments.set(text, :entity_name, name)
           text
         end
@@ -198,11 +193,27 @@ module Moxml
 
           return all_children unless node.is_a?(::Oga::XML::Node) || node.is_a?(::Oga::XML::Document)
 
-          all_children + node.children.reject do |child|
-            child.is_a?(::Oga::XML::Text) &&
-              child.text.strip.empty? &&
-              !(child.previous.nil? && child.next.nil?)
+          child_nodes = node.children.to_a
+          # Filter out whitespace-only text nodes at document level only.
+          # Document-level whitespace (between <?xml?> and <root>) is
+          # formatting, not content, and differs across adapters.
+          # Whitespace inside elements (e.g. "FigureA.1" spacing) is
+          # meaningful and must be preserved.
+          if node.is_a?(::Oga::XML::Document)
+            child_nodes = child_nodes.reject do |child|
+              child.is_a?(::Oga::XML::Text) && child.text.strip.empty?
+            end
           end
+          all_children + child_nodes
+        end
+
+        def adjacent_to_entity_reference?(node)
+          entity_ref?(node.previous) || entity_ref?(node.next)
+        end
+
+        def entity_ref?(node)
+          node.is_a?(::Oga::XML::Text) &&
+            attachments.get(node, :entity_name)
         end
 
         def parent(node)
@@ -251,7 +262,7 @@ module Moxml
           attr = ::Oga::XML::Attribute.new(
             name: name.to_s,
             namespace_name: namespace_name,
-            value: encode_entity_markers(value.to_s),
+            value: preprocess_entities(value.to_s),
           )
           element.add_attribute(attr)
         end
@@ -261,7 +272,7 @@ module Moxml
         end
 
         def get_attribute_value(element, name)
-          restore_entity_markers(element[name.to_s])
+          element[name.to_s]
         end
 
         def remove_attribute(element, name)
@@ -330,24 +341,23 @@ module Moxml
         end
 
         def text_content(node)
-          restore_entity_markers(node.text)
+          node.text
         end
 
         def inner_text(node)
-          text = if node.is_a?(::Oga::XML::Element)
-                   node.inner_text
-                 else
-                   node.text
-                 end
-          restore_entity_markers(text)
+          if node.is_a?(::Oga::XML::Element)
+            node.inner_text
+          else
+            node.text
+          end
         end
 
         def set_text_content(node, content)
-          encoded = encode_entity_markers(content)
+          processed = preprocess_entities(content)
           if node.is_a?(::Oga::XML::Element)
-            node.inner_text = encoded
+            node.inner_text = processed
           else
-            node.text = encoded
+            node.text = processed
           end
         end
 
@@ -439,24 +449,9 @@ module Moxml
         end
 
         def serialize(node, options = {})
-          output = serialize_without_entity_processing(node, options)
-          # Post-process: convert entity markers back to entity references
-          output.gsub(ENTITY_MARKER_REGEX, '&\1;')
+          serialize_without_entity_processing(node, options)
         end
 
-        # Shared entity name pattern (W3C: 2-31 chars, starts with alpha)
-        ENTITY_PATTERN = "([a-zA-Z][a-zA-Z0-9]{1,30})"
-
-        # Marker character for entity preservation through Oga's parser.
-        # U+0001 is preserved literally by Oga through parse/serialize cycle.
-        ENTITY_MARKER = "\x01"
-
-        # Regular expression for entity marker post-processing
-        ENTITY_MARKER_REGEX = /#{ENTITY_MARKER}#{ENTITY_PATTERN};/
-
-        # Simple entity-only regex with no nested quantifiers
-        ENTITY_REF_REGEX = /&#{ENTITY_PATTERN};/
-
         def has_declaration?(native_doc, _wrapper)
           decl = attachments.get(native_doc, :xml_declaration)
           if decl.nil? && !attachments.key?(native_doc, :xml_declaration)
@@ -469,32 +464,6 @@ module Moxml
 
         private
 
-        # Convert &entity; back to \x01entity; for Oga text storage.
-        # Used when setting text content programmatically (not from parsing).
-        def encode_entity_markers(text)
-          return text unless text&.include?("&")
-
-          text.gsub(ENTITY_REF_REGEX) do
-            name = ::Regexp.last_match(1)
-
-            next ::Regexp.last_match(0) if STANDARD_XML_ENTITIES.include?(name)
-
-            codepoint = Moxml::EntityRegistry.default.codepoint_for_name(name)
-            if codepoint
-              "#{ENTITY_MARKER}#{name};"
-            else
-              ::Regexp.last_match(0)
-            end
-          end
-        end
-
-        # Convert \x01entity; back to &entity; for text accessors.
-        def restore_entity_markers(text)
-          return text unless text
-
-          text.gsub(ENTITY_MARKER_REGEX, '&\1;')
-        end
-
         def serialize_without_entity_processing(node, options = {})
           # Oga's XmlGenerator doesn't support options directly
           # We need to handle declaration options ourselves for Document nodes
@@ -572,30 +541,6 @@ module Moxml
             ::Moxml::Adapter::CustomizedOga::XmlGenerator.new(node).to_xml
           end
         end
-
-        # Pre-process XML to convert named entities to marker format.
-        # Oga drops named entity references like &nbsp; but preserves control chars.
-        # By converting known named entities to marker form (\x01name;), we can
-        # reconstruct them during serialization.
-        #
-        # @param xml [String, #to_s] The XML string to process
-        # @return [String] The XML with known named entities converted to marker form
-        def preprocess_named_entities(xml)
-          return xml unless xml.is_a?(String)
-
-          xml.gsub(ENTITY_REF_REGEX) do
-            name = Regexp.last_match(1)
-
-            next Regexp.last_match(0) if STANDARD_XML_ENTITIES.include?(name)
-
-            codepoint = Moxml::EntityRegistry.default.codepoint_for_name(name)
-            if codepoint
-              "#{ENTITY_MARKER}#{name};"
-            else
-              Regexp.last_match(0)
-            end
-          end
-        end
       end
     end
 

data/lib/moxml/adapter/ox.rb

@@ -20,8 +20,9 @@ module Moxml
         end
 
         def parse(xml, options = {}, _context = nil)
+          processed_xml = preprocess_entities(xml)
           native_doc = begin
-            result = ::Ox.parse(xml)
+            result = ::Ox.parse(processed_xml)
 
             # result can be either Document or Element
             if result.is_a?(::Ox::Document)
@@ -543,17 +544,18 @@ module Moxml
         end
 
         def namespace_definitions(node)
-          ([node] + ancestors(node)).reverse.each_with_object({}) do |n, namespaces|
-            next unless n.is_a?(::Ox::Element) && n.attributes
+          return [] unless node.is_a?(::Ox::Element) && node.attributes
 
-            n.attributes.each do |name, value|
-              next unless name.to_s.start_with?("xmlns")
+          namespaces = {}
+          node.attributes.each do |name, value|
+            name_s = name.to_s
+            next unless name_s == "xmlns" || name_s.start_with?("xmlns:")
 
-              namespaces[name] = ::Moxml::Adapter::CustomizedOx::Namespace.new(
-                name, value, n
-              )
-            end
-          end.values
+            namespaces[name] = ::Moxml::Adapter::CustomizedOx::Namespace.new(
+              name, value, node
+            )
+          end
+          namespaces.values
         end
 
         # Doctype accessor methods
@@ -620,17 +622,44 @@ module Moxml
         end
 
         def serialize(node, options = {})
-          # Fast path: skip EntityReference scan for documents (most common case)
-          if node.is_a?(::Ox::Document) &&
-              !attachments.get(node, :has_entity_refs)
+          needs_custom = needs_custom_serialize?(node)
+
+          unless needs_custom
             return serialize_standard(node, options)
           end
 
-          if tree_has_entity_references?(node)
-            serialize_custom(node, options)
-          else
-            serialize_standard(node, options)
+          serialize_custom(node, options)
+        end
+
+        def needs_custom_serialize?(node)
+          # Fast path: single CData with ]]>
+          return true if node.is_a?(::Ox::CData) && node.value&.include?("]]>")
+
+          # Only documents/elements can contain entity refs or CDATA issues
+          return false unless node.is_a?(::Ox::Document) || node.is_a?(::Ox::Element)
+
+          # Check cached flags on documents (most common case)
+          if node.is_a?(::Ox::Document)
+            return true if attachments.get(node, :has_entity_refs)
+            return true if attachments.get(node, :has_cdata_end_markers)
+            return false if attachments.key?(node, :has_entity_refs) &&
+                            attachments.key?(node, :has_cdata_end_markers)
           end
+
+          # Only scan tree on first call — short-circuit on first hit
+          has_er = tree_has_entity_references?(node)
+          if has_er
+            attachments.set(node, :has_entity_refs, true) if node.is_a?(::Ox::Document)
+            return true
+          end
+
+          has_cdata = tree_has_cdata_end_markers?(node)
+          if node.is_a?(::Ox::Document)
+            attachments.set(node, :has_entity_refs, false)
+            attachments.set(node, :has_cdata_end_markers, has_cdata)
+          end
+
+          has_cdata
         end
 
         def has_declaration?(native_doc, _wrapper)
@@ -665,7 +694,9 @@ module Moxml
             encoding: options[:encoding],
             no_empty: options[:expand_empty],
           }
-          output + ::Ox.dump(node, ox_options)
+          result = output + ::Ox.dump(node, ox_options)
+          # Fix CDATA ]]> end markers that Ox doesn't escape
+          result
         end
 
         def tree_has_entity_references?(node)
@@ -685,6 +716,19 @@ module Moxml
           end
         end
 
+        def tree_has_cdata_end_markers?(node)
+          case node
+          when ::Ox::CData
+            node.value&.include?("]]>") || false
+          when ::Ox::Element
+            node.nodes&.any? { |child| tree_has_cdata_end_markers?(child) } || false
+          when ::Ox::Document
+            node.nodes&.any? { |child| tree_has_cdata_end_markers?(child) } || false
+          else
+            false
+          end
+        end
+
         def serialize_custom(node, options = {})
           output = +""
           if node.is_a?(::Ox::Document)
@@ -717,7 +761,7 @@ module Moxml
           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::CData then serialize_cdata(node.value)
           when ::Ox::Comment then "<!--#{node.value}-->"
           when ::Ox::Instruct then "<?#{node.target} #{node.value || ''}?>"
           when ::Ox::DocType then "<!DOCTYPE #{node.value}>"
@@ -744,6 +788,11 @@ module Moxml
           output
         end
 
+        def serialize_cdata(content)
+          escaped = content.gsub("]]>", "]]]]><![CDATA[>")
+          "<![CDATA[#{escaped}]]>"
+        end
+
         def escape_xml_text(text)
           text.to_s.gsub(/[<>&]/) do |match|
             case match
@@ -765,6 +814,7 @@ module Moxml
           end
         end
 
+
         # Translate a subset of XPath to Ox locate() syntax
         # Supports: //element, /path/to/element, .//element, element[@attr]
         # Note: Ox locate() doesn't support namespace prefixes in the path

data/lib/moxml/adapter/rexml.rb

@@ -15,6 +15,8 @@ module Moxml
         end
 
         def parse(xml, options = {}, _context = nil)
+          xml = "" if xml.nil?
+
           # Handle frozen strings by creating a mutable copy
           processed_xml = if xml.frozen?
                             xml.dup.force_encoding("UTF-8").encode("UTF-8")
@@ -22,6 +24,9 @@ module Moxml
                             xml.force_encoding("UTF-8").encode("UTF-8")
                           end
 
+          # Preprocess entities to avoid double-escaping on output
+          processed_xml = preprocess_entities(processed_xml)
+
           native_doc = begin
             ::REXML::Document.new(processed_xml)
           rescue ::REXML::ParseException => e
@@ -172,12 +177,8 @@ module Moxml
         def children(node)
           return [] unless node.is_a?(::REXML::Parent)
 
-          # Get all children and filter out empty text nodes between elements
-          result = node.children.reject do |child|
-            child.is_a?(::REXML::Text) &&
-              child.to_s.strip.empty? &&
-              !(child.next_sibling.nil? && child.previous_sibling.nil?)
-          end
+          # Return all children preserving whitespace text nodes
+          result = node.children.dup
 
           # Include any EntityReference wrappers stored alongside native children
           entity_refs = attachments.get(node, :entity_refs)
@@ -412,7 +413,7 @@ module Moxml
           when ::REXML::Element
             # Extract text recursively from all children to match other adapters
             extract_text_recursively(node)
-          end
+          end.to_s
         end
 
         def extract_text_recursively(element)
@@ -491,9 +492,25 @@ module Moxml
         end
 
         def namespace_definitions(node)
-          node.namespaces.map do |prefix, uri|
-            ::REXML::Attribute.new(prefix.to_s, uri, node)
+          return [] unless node.is_a?(::REXML::Element)
+
+          result = []
+          node.attributes.each_attribute do |attr|
+            next unless attr.prefix == "xmlns" || (attr.name == "xmlns" && attr.prefix.to_s.empty?)
+
+            result << attr
+          end
+          result
+        end
+
+        def in_scope_namespaces(element)
+          namespaces = {}
+          element.namespaces.each do |prefix, uri|
+            key = prefix.to_s.empty? ? "xmlns" : prefix.to_s
+            ns = ::REXML::Attribute.new(key, uri, element)
+            namespaces[prefix] = ns
           end
+          namespaces.values
         end
 
         # Doctype accessor methods

data/lib/moxml/attribute.rb

@@ -17,6 +17,12 @@ module Moxml
     end
 
     def value
+      val = @native.value.to_s
+      adapter.restore_entities(val)
+    end
+
+    # Returns raw native value without entity marker restoration.
+    def raw_value
       @native.value
     end
 

data/lib/moxml/config.rb

@@ -3,7 +3,8 @@
 module Moxml
   class Config
     VALID_ADAPTERS = %i[nokogiri oga rexml ox headed_ox libxml].freeze
-    DEFAULT_ADAPTER = VALID_ADAPTERS.first
+    DEFAULT_ADAPTER = :nokogiri
+    OPAL_DEFAULT_ADAPTER = :oga
 
     # Entity loading modes:
     # - :required - Must load entities, raise error if unavailable (default)
@@ -20,7 +21,21 @@ module Moxml
       end
 
       def default_adapter
-        @default_adapter ||= DEFAULT_ADAPTER
+        @default_adapter ||= runtime_default_adapter
+      end
+
+      def runtime_default_adapter
+        return OPAL_DEFAULT_ADAPTER if RUBY_ENGINE == "opal"
+
+        detect_loaded_adapter || DEFAULT_ADAPTER
+      end
+
+      def detect_loaded_adapter
+        return :nokogiri if Object.const_defined?(:Nokogiri)
+        return :ox if Object.const_defined?(:Ox)
+        return :oga if Object.const_defined?(:Oga)
+
+        nil
       end
     end
 

data/lib/moxml/element.rb

@@ -46,7 +46,8 @@ module Moxml
     end
 
     def [](name)
-      adapter.get_attribute_value(@native, name)
+      val = adapter.get_attribute_value(@native, name)
+      val ? adapter.restore_entities(val) : val
     end
 
     def attribute(name)
@@ -54,12 +55,7 @@ module Moxml
       native_attr && Attribute.new(native_attr, context)
     end
 
-    # Alias for attribute access
-    def get(attr_name)
-      attribute(attr_name)
-    end
-
-    # Alias for getting attribute value (used by XPath engine)
+    # Returns attribute value by name (used by XPath engine)
     def get(attr_name)
       self[attr_name]
     end
@@ -137,7 +133,8 @@ module Moxml
     end
 
     def text
-      adapter.text_content(@native)
+      val = adapter.text_content(@native)
+      adapter.restore_entities(val)
     end
 
     def text=(content)
@@ -146,6 +143,13 @@ module Moxml
     end
 
     def inner_text
+      text = raw_inner_text
+      adapter.restore_entities(text)
+    end
+
+    # Returns inner text without entity marker restoration.
+    # Used internally when raw content with markers is needed (e.g., for DOM construction).
+    def raw_inner_text
       adapter.inner_text(@native)
     end
 

data/lib/moxml/node.rb

@@ -97,7 +97,10 @@ module Moxml
       serialize_options = default_options.merge(options)
       serialize_options[:no_declaration] = !should_include_declaration?(options)
 
-      adapter.serialize(@native, serialize_options)
+      result = adapter.serialize(@native, serialize_options)
+
+      # Restore entity markers to named entity references
+      adapter.restore_entities(result)
     end
 
     def xpath(expression, namespaces = {})

data/lib/moxml/text.rb

@@ -3,6 +3,12 @@
 module Moxml
   class Text < Node
     def content
+      text = raw_content
+      adapter.restore_entities(text)
+    end
+
+    # Returns raw content without entity marker restoration.
+    def raw_content
       adapter.text_content(@native)
     end
 

data/lib/moxml/version.rb

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

data/lib/moxml/xpath/compiler.rb

@@ -388,30 +388,38 @@ module Moxml
         document_or_node(input).if_true do
           # Create a proper if-else structure that prevents double traversal
           input.is_a?(doc_class).if_true do
-            # DOCUMENT PATH: test root, then traverse from root
-            root = unique_literal(:root)
-            root.assign(input.root).followed_by do
-              root.if_true do
-                # Test root first
-                condition = process(ast, root)
-                (if block_given?
-                   condition.if_true { yield root }
-                 else
-                   condition.if_true { root }
-                 end)
-                  .followed_by do
-                    # Traverse descendants FROM root only (not document.each_node)
-                    root.each_node.add_block(node) do
-                      desc_condition = process(ast, node)
-                      if block_given?
-                        desc_condition.if_true { yield node }
-                      else
-                        desc_condition.if_true { node }
+            # DOCUMENT PATH: test document (self), then root, then traverse
+            doc_condition = process(ast, input)
+            (if block_given?
+               doc_condition.if_true { yield input }
+             else
+               doc_condition.if_true { input }
+             end)
+              .followed_by do
+                root = unique_literal(:root)
+                root.assign(input.root).followed_by do
+                  root.if_true do
+                    # Test root
+                    condition = process(ast, root)
+                    (if block_given?
+                       condition.if_true { yield root }
+                     else
+                       condition.if_true { root }
+                     end)
+                      .followed_by do
+                        # Traverse descendants FROM root only (not document.each_node)
+                        root.each_node.add_block(node) do
+                          desc_condition = process(ast, node)
+                          if block_given?
+                            desc_condition.if_true { yield node }
+                          else
+                            desc_condition.if_true { node }
+                          end
+                        end
                       end
-                    end
                   end
+                end
               end
-            end
           end.else do
             # NON-DOCUMENT PATH: test self, then traverse from self
             condition = process(ast, input)
@@ -497,6 +505,17 @@ module Moxml
         element_or_attribute(input)
       end
 
+      # Handle node type test (node(), text(), comment(), etc.)
+      # node() matches any node — always returns truthy
+      def on_node_type(ast, input)
+        case ast.value
+        when "node"
+          # node() matches everything — use a truthy literal
+          Ruby::Node.new(:lit, ["true"])
+        else element_or_attribute(input)
+        end
+      end
+
       # Match element/attribute names and namespaces
       def match_name_and_namespace(ast, input)
         ns = ast.value[:namespace]

data/lib/moxml/xpath/parser.rb

@@ -311,10 +311,10 @@ module Moxml
           return AST::Node.absolute_path(*steps.children)
         elsif match?(:dslash)
           advance
-          # Descendant-or-self: //
+          # Descendant-or-self: // (expands to /descendant-or-self::node()/)
           steps = parse_relative_path
           return AST::Node.absolute_path(
-            AST::Node.axis("descendant-or-self", AST::Node.wildcard),
+            AST::Node.axis("descendant-or-self", AST::Node.node_type("node")),
             *steps.children,
           )
         end
@@ -330,9 +330,9 @@ module Moxml
         while match?(:slash) && !at_end?
           advance
           if match?(:slash)
-            # Double slash within path
+            # Double slash within path: expands to descendant-or-self::node()
             advance
-            steps << AST::Node.axis("descendant-or-self", AST::Node.wildcard)
+            steps << AST::Node.axis("descendant-or-self", AST::Node.node_type("node"))
           end
           steps << parse_step unless at_end? || match?(:pipe, :rbracket,
                                                        :rparen, :comma)
@@ -352,9 +352,14 @@ module Moxml
           return AST::Node.parent
         elsif match?(:at)
           advance
-          # Attribute: @name
-          name = consume(:name, "Expected attribute name after @")
-          node_test = AST::Node.test(nil, name[1])
+          # Attribute: @name or @*
+          if match?(:star)
+            advance
+            node_test = AST::Node.wildcard
+          else
+            name = consume(:name, "Expected attribute name after @")
+            node_test = AST::Node.test(nil, name[1])
+          end
           step = AST::Node.axis("attribute", node_test)
           return parse_predicates(step)
         end