moxml 0.1.26 → 0.2.0

data/lib/moxml/adapter/customized_leptris/text_segment.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Moxml
+  module Adapter
+    module CustomizedLeptris
+      # A text run split out of a native text node that carried entity
+      # markers. Value object: the moxml contract exposes text nodes as
+      # separate children around entity references, while libleptris
+      # stores them as one marker-bearing text node.
+      class TextSegment
+        attr_accessor :parent
+
+        attr_reader :content
+
+        def initialize(content, parent = nil)
+          @content = content
+          @parent = parent
+        end
+
+        def ==(other)
+          other.is_a?(self.class) && content == other.content
+        end
+      end
+    end
+  end
+end

data/lib/moxml/adapter/customized_leptris.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Moxml
+  module Adapter
+    # Pure-Ruby node kinds that libleptris has no native representation
+    # for: XML declarations, programmatic DOCTYPEs, and entity references.
+    # The adapter stores them via NativeAttachment and serializes them
+    # from #to_xml.
+    module CustomizedLeptris
+      autoload :Declaration, "moxml/adapter/customized_leptris/declaration"
+      autoload :Doctype, "moxml/adapter/customized_leptris/doctype"
+      autoload :EntityReference, "moxml/adapter/customized_leptris/entity_reference"
+      autoload :TextSegment, "moxml/adapter/customized_leptris/text_segment"
+    end
+  end
+end

data/lib/moxml/adapter/customized_libxml/cdata.rb

@@ -5,19 +5,10 @@ module Moxml
     module CustomizedLibxml
       # Wrapper for LibXML CDATA section nodes
       class Cdata < Node
-        # Serialize as XML CDATA section
-        # LibXML auto-escapes content, we need to un-escape it
+        # libxml stores CDATA payload verbatim. Only the `]]>` end-marker
+        # needs splitting before re-wrapping.
         def to_xml
-          content = @native.content
-            .gsub("&quot;", '"')
-            .gsub("&apos;", "'")
-            .gsub("&lt;", "<")
-            .gsub("&gt;", ">")
-            .gsub("&amp;", "&")
-
-          # Handle CDATA end marker escaping (]]> becomes ]]]]><![CDATA[>)
-          # Replace all ]]> markers in the content before wrapping
-          escaped_content = content.gsub("]]>", "]]]]><![CDATA[>")
+          escaped_content = @native.content.gsub("]]>", "]]]]><![CDATA[>")
           "<![CDATA[#{escaped_content}]]>"
         end
       end

data/lib/moxml/adapter/customized_libxml/comment.rb

@@ -5,16 +5,9 @@ module Moxml
     module CustomizedLibxml
       # Wrapper for LibXML comment nodes
       class Comment < Node
-        # Serialize as XML comment
-        # LibXML auto-escapes content, we need to un-escape it
+        # libxml stores comment payload verbatim.
         def to_xml
-          content = @native.content
-            .gsub("&quot;", '"')
-            .gsub("&apos;", "'")
-            .gsub("&lt;", "<")
-            .gsub("&gt;", ">")
-            .gsub("&amp;", "&")
-          "<!--#{content}-->"
+          "<!--#{@native.content}-->"
         end
       end
     end

data/lib/moxml/adapter/customized_libxml/declaration.rb

@@ -47,16 +47,7 @@ module Moxml
 
         # Generate XML declaration string
         def to_xml
-          output = "<?xml version=\"#{@version}\""
-          if @encoding && !@encoding.empty?
-            output << " encoding=\"#{@encoding}\""
-          end
-          # Include standalone attribute if explicitly set (true or false)
-          unless @standalone_value.nil?
-            output << " standalone=\"#{standalone}\""
-          end
-          output << "?>"
-          output
+          XmlEmitter.declaration_xml(@version, @encoding, standalone)
         end
 
         private

data/lib/moxml/adapter/customized_libxml/node.rb

@@ -18,6 +18,14 @@ module Moxml
           @native = native_node
         end
 
+        # Swap the wrapped native node. Used by the Libxml adapter when
+        # libxml-ruby's content= setter would silently re-escape stored
+        # text; replacing the node with a fresh raw-storage instance is
+        # the only way to preserve verbatim content.
+        def replace_native!(fresh)
+          @native = fresh
+        end
+
         # Compare wrappers based on their native nodes
         def ==(other)
           return false unless other

data/lib/moxml/adapter/customized_libxml/processing_instruction.rb

@@ -5,20 +5,12 @@ module Moxml
     module CustomizedLibxml
       # Wrapper for LibXML processing instruction nodes
       class ProcessingInstruction < Node
-        # Serialize as XML processing instruction
-        # LibXML auto-escapes content, we need to un-escape it
+        # XML 1.0 §2.6: PI content is verbatim — no entity resolution, no escaping.
         def to_xml
           target = @native.name
           content = @native.content
-
-          # Un-escape LibXML's automatic escaping
           if content && !content.empty?
-            unescaped = content.gsub("&quot;", '"')
-              .gsub("&apos;", "'")
-              .gsub("&lt;", "<")
-              .gsub("&gt;", ">")
-              .gsub("&amp;", "&")
-            "<?#{target} #{unescaped}?>"
+            "<?#{target} #{content}?>"
           else
             "<?#{target}?>"
           end

data/lib/moxml/adapter/customized_libxml/text.rb

@@ -13,16 +13,9 @@ module Moxml
           @native.content
         end
 
-        # Serialize as XML with proper escaping
-        # LibXML's .content already contains escaped text, but it over-escapes
-        # quotes which don't need escaping in text nodes (only in attributes)
+        # @native.to_s escapes & < > but leaves quotes alone, which text nodes need.
         def to_xml
-          content = @native.content
-          # Skip the gsub allocation entirely when there's nothing to undo —
-          # the common case for parsed text without literal quotes.
-          return content unless content.include?("&quot;")
-
-          content.gsub("&quot;", '"')
+          @native.to_s
         end
       end
     end

data/lib/moxml/adapter/customized_oga/entity_decoder.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require "oga"
+
+module Moxml
+  module Adapter
+    module CustomizedOga
+      # Override Oga::EntityDecoder.decode for XML inputs.
+      #
+      # Oga 3.4's stock Oga::XML::Entities.decode runs multiple passes,
+      # turning the well-formed "&" into "&" rather than the
+      # spec-correct "&". XML 1.0 §4.6 forbids recursive resolution
+      # of parsed entities — exactly one decode pass is correct.
+      #
+      # Moxml::Adapter::Base.decode_entities does the single pass. HTML
+      # inputs fall through to Oga's stock HTML::Entities.decode, which
+      # has HTML-specific legacy rules that differ from XML's.
+      #
+      # Prepending on the singleton class means every Oga reader
+      # (Text#text, Attribute#value, etc.) automatically picks up the
+      # fixed decoder, so the adapter no longer needs to walk the parsed
+      # tree rewriting @text/@value ivars behind Oga's back.
+      module EntityDecoderOverride
+        # rubocop:disable-next Style/OptionalBooleanParameter -- must match Oga's signature
+        def decode(input, html = false)
+          return super if html
+
+          ::Moxml::Adapter::Base.decode_entities(input)
+        end
+      end
+    end
+  end
+end
+
+Oga::EntityDecoder.singleton_class.prepend(
+  Moxml::Adapter::CustomizedOga::EntityDecoderOverride,
+)

data/lib/moxml/adapter/customized_oga/raw_value_override.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require "oga"
+
+module Moxml
+  module Adapter
+    module CustomizedOga
+      # Bypass Oga's lazy decoder for user-authored values.
+      #
+      # Oga::XML::Attribute#value and Oga::XML::Text#text decode `@value` /
+      # `@text` on first read via Oga::EntityDecoder. EntityDecoderOverride
+      # makes that decode single-pass for parsed input. But user-authored
+      # values are already data — running them through the decoder again
+      # would re-interpret any literal `&` / `&#NN;` substrings as entity
+      # references. So we route the read through the NativeAttachment
+      # sidecar first; if the adapter stored the verbatim value there, we
+      # return it as-is, otherwise we fall through to Oga's normal read.
+      module RawValueOverride
+        def value
+          cached = ::Moxml::Adapter::Oga.attachments.get(self, :raw_value)
+          return cached unless cached.nil?
+
+          super
+        end
+
+        def value=(new_value)
+          ::Moxml::Adapter::Oga.attachments.set(self, :raw_value, new_value)
+          super
+        end
+
+        def text
+          cached = ::Moxml::Adapter::Oga.attachments.get(self, :raw_text)
+          return cached unless cached.nil?
+
+          super
+        end
+
+        def text=(new_value)
+          ::Moxml::Adapter::Oga.attachments.set(self, :raw_text, new_value)
+          super
+        end
+      end
+    end
+  end
+end
+
+Oga::XML::Attribute.prepend(
+  Moxml::Adapter::CustomizedOga::RawValueOverride,
+)
+Oga::XML::Text.prepend(
+  Moxml::Adapter::CustomizedOga::RawValueOverride,
+)

data/lib/moxml/adapter/customized_oga/xml_generator.rb

@@ -45,36 +45,10 @@ module Moxml
         end
 
         def on_cdata(node, output)
-          # Escape the end sequence
+          # Split any embedded end sequence into adjacent sections
           return super unless node.text.include?("]]>")
 
-          chunks = node.text.split(/(\]\]>)/)
-          chunks = ["]]", ">"] if chunks.size == 1
-
-          while (index = chunks.index("]]>"))
-            # the end tag cannot be the first and the last at the same time
-
-            if index.zero?
-              # it's the first text chunk
-              chunks[index] = "]]"
-              chunks[index + 1] = ">#{chunks[index + 1]}"
-            elsif index - 1 == chunks.size
-              # it's the last text chunk
-              chunks[index - 1] += "]]"
-              chunks[index] = ">"
-            else
-              # it's a chunk in the middle
-              chunks[index - 1] += "]]"
-              chunks[index + 1] = ">#{chunks[index + 1]}"
-              chunks.delete_at(index)
-            end
-          end
-
-          chunks.each do |chunk|
-            output << "<![CDATA[#{chunk}]]>"
-          end
-
-          output
+          output << ::Moxml::XmlEmitter.cdata(node.text)
         end
 
         def on_processing_instruction(node, output)
@@ -91,12 +65,8 @@ module Moxml
         protected
 
         def encode(input)
-          # similar to ::Oga::XML::Entities.encode_attribute
-          input&.gsub(
-            ::Oga::XML::Entities::ENCODE_ATTRIBUTE_REGEXP,
-            # Keep apostrophes in attributes
-            ::Oga::XML::Entities::ENCODE_ATTRIBUTE_MAPPING.merge("'" => "'"),
-          )
+          # moxml-canonical attribute form: apostrophes stay literal
+          ::Moxml::XmlEmitter.escape_attribute(input.to_s)
         end
       end
     end

data/lib/moxml/adapter/customized_oga.rb

@@ -3,6 +3,8 @@
 module Moxml
   module Adapter
     module CustomizedOga
+      autoload :EntityDecoderOverride, "moxml/adapter/customized_oga/entity_decoder"
+      autoload :RawValueOverride, "moxml/adapter/customized_oga/raw_value_override"
       autoload :XmlDeclaration, "moxml/adapter/customized_oga/xml_declaration"
       autoload :XmlGenerator, "moxml/adapter/customized_oga/xml_generator"
     end

data/lib/moxml/adapter/customized_ox/entity_reference.rb

@@ -3,23 +3,7 @@
 module Moxml
   module Adapter
     module CustomizedOx
-      class EntityReference
-        attr_reader :name
-        attr_accessor :parent
-
-        def initialize(name)
-          @name = name
-          @parent = nil
-        end
-
-        def to_xml
-          "&#{@name};"
-        end
-
-        def ==(other)
-          other.is_a?(self.class) && @name == other.name
-        end
-      end
+      EntityReference = ::Moxml::Entity::Reference
     end
   end
 end

data/lib/moxml/adapter/customized_rexml/entity_reference.rb

@@ -3,17 +3,7 @@
 module Moxml
   module Adapter
     module CustomizedRexml
-      class EntityReference
-        attr_reader :name
-
-        def initialize(name)
-          @name = name
-        end
-
-        def ==(other)
-          other.is_a?(self.class) && @name == other.name
-        end
-      end
+      EntityReference = ::Moxml::Entity::Reference
     end
   end
 end

data/lib/moxml/adapter/headed_ox.rb

@@ -6,15 +6,13 @@ require "moxml/adapter/ox"
 
 module Moxml
   module Adapter
-    # HeadedOx adapter - combines Ox's fast parsing with Moxml's XPath engine.
+    # HeadedOx adapter - Ox parsing with Moxml's XPath engine.
     #
-    # This adapter uses:
-    # - Ox for XML parsing (fast C-based parser)
-    # - Moxml::XPath engine for comprehensive XPath 1.0 support
-    #
-    # Unlike the standard Ox adapter which has limited XPath support through
-    # Ox's locate() method, HeadedOx provides full XPath 1.0 functionality
-    # including all axes, predicates, and 27 standard functions.
+    # Since the Ox adapter now routes XPath through Moxml's pure-Ruby
+    # XPath 1.0 engine, HeadedOx is the historical name for exactly
+    # that combination and inherits everything from Adapter::Ox. It
+    # exists for backwards compatibility and reports its own
+    # capabilities.
     #
     # @example
     #   context = Moxml.new(:headed_ox)
@@ -23,138 +21,23 @@ module Moxml
     #
     class HeadedOx < Ox
       class << self
-        # Override parse to use lazy wrapping like the Ox adapter.
-        # Previously used DocumentBuilder (eager tree construction causing
-        # ~176K allocations per 100-element parse). Lazy parse defers wrapper
-        # creation until nodes are accessed, matching Ox adapter behavior.
-        def parse(xml, options = {}, _context = nil)
-          processed_xml = preprocess_entities(xml)
-          native_doc = begin
-            result = ::Ox.parse(processed_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
-            raise Moxml::ParseError.new(
-              e.message,
-              source: xml.is_a?(String) ? xml[0..100] : nil,
-            )
-          end
-
-          # Use provided context if available, otherwise create new one
-          ctx = _context || Context.new(:headed_ox)
-          Document.new(native_doc, ctx)
-        end
-
-        # Execute XPath query using Moxml's XPath engine
-        #
-        # This overrides the Ox adapter's xpath method which uses locate().
-        #
-        # @param node Starting node (native or wrapped)
-        # @param [String] expression XPath expression
-        # @param [Hash] namespaces Namespace prefix mappings
-        # @return [Array, Object] Native node array or scalar value
-        def xpath(node, expression, namespaces = {})
-          unless node.is_a?(Moxml::Node)
-            ctx = Context.new(:headed_ox)
-            node = Moxml::Node.wrap(node, ctx)
-          end
-
-          # Parse XPath expression to AST
-          ast = XPath::Parser.parse(expression)
-
-          # Compile AST to executable Proc using class method
-          proc = XPath::Compiler.compile_with_cache(ast, namespaces: namespaces)
-
-          # Execute on the node (now guaranteed to be wrapped Moxml node)
-          result = proc.call(node)
-
-          # Return native arrays for Node#xpath to wrap, scalars directly.
-          # The adapter contract: xpath() returns Array<native> | scalar.
-          case result
-          when Array
-            # XPath engine returns wrapped Moxml::Node objects.
-            # Extract native nodes and deduplicate by object identity.
-            native_nodes = result.map { |n| n.is_a?(Moxml::Node) ? n.native : n }
-            seen = {}
-            native_nodes.select do |native|
-              id = native.object_id
-              if seen[id]
-                false
-              else
-                seen[id] = true
-              end
-            end
-          when NodeSet
-            # NodeSet from intermediate evaluation - extract natives and deduplicate
-            seen = {}
-            result.to_a.map(&:native).select do |native|
-              id = native.object_id
-              if seen[id]
-                false
-              else
-                seen[id] = true
-              end
-            end
-          else
-            # Scalar values (string, number, boolean) - return as-is
-            result
-          end
-        rescue StandardError => e
-          raise Moxml::XPathError.new(
-            "XPath execution failed: #{e.message}",
-            expression: expression,
-            adapter: "HeadedOx",
-            node: node,
-          )
-        end
-
-        # Execute XPath query and return first result
-        #
-        # @param [Moxml::Node] node Starting node
-        # @param [String] expression XPath expression
-        # @param [Hash] namespaces Namespace prefix mappings
-        # @return [Object, nil] First native node or scalar value
-        def at_xpath(node, expression, namespaces = {})
-          result = xpath(node, expression, namespaces)
-          result.is_a?(Array) ? result.first : result
-        end
-
-        # Check if XPath is supported
-        #
-        # @return [Boolean] Always true for HeadedOx
-        def xpath_supported?
-          true
+        def context_adapter_name
+          :headed_ox
         end
 
         # Report adapter capabilities
         #
-        # HeadedOx extends Ox's capabilities with full XPath support
-        # through Moxml's XPath engine
-        #
         # @return [Hash] Capability flags
         def capabilities
           {
-            # Core adapter capabilities
             parse: true,
-
-            # Parsing capabilities (inherited from Ox)
             sax_parsing: true,
             namespace_aware: true,
             namespace_support: :partial,
             dtd_support: true,
             parsing_speed: :fast,
 
-            # XPath capabilities (provided by Moxml's XPath engine)
+            # XPath via Moxml's XPath engine
             xpath_support: :full,
             xpath_full: true,
             xpath_axes: :partial, # 6 of 13 axes: child, descendant, descendant-or-self, self, attribute, parent
@@ -163,11 +46,9 @@ module Moxml
             xpath_namespaces: true,
             xpath_variables: true,
 
-            # Serialization capabilities (inherited from Ox)
             namespace_serialization: true,
             pretty_print: true,
 
-            # Known limitations
             schema_validation: false,
             xslt_support: false,
           }