moxml 0.1.7 → 0.1.9

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

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Moxml
+  module Adapter
+    module CustomizedLibxml
+      # Base wrapper class for LibXML nodes
+      #
+      # This wrapper hides LibXML's strict document ownership model,
+      # allowing nodes to be moved between documents transparently.
+      # Similar pattern to Ox adapter's customized classes.
+      class Node
+        attr_reader :native
+
+        def initialize(native_node)
+          @native = native_node
+        end
+
+        # Compare wrappers based on their native nodes
+        def ==(other)
+          return false unless other
+
+          other_native = other.respond_to?(:native) ? other.native : other
+          @native == other_native
+        end
+
+        alias eql? ==
+
+        def hash
+          @native.hash
+        end
+
+        # Check if node has a document
+        def document_present?
+          @native.respond_to?(:doc) && !@native.doc.nil?
+        end
+
+        # Get the document this node belongs to
+        def document
+          @native.doc if document_present?
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require_relative "node"
+
+module Moxml
+  module Adapter
+    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
+        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}?>"
+          else
+            "<?#{target}?>"
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require_relative "node"
+
+module Moxml
+  module Adapter
+    module CustomizedLibxml
+      # Wrapper for LibXML text nodes
+      class Text < Node
+        def to_s
+          @native.content
+        end
+
+        def text
+          @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)
+        def to_xml
+          @native.content.gsub("&quot;", '"')
+        end
+      end
+    end
+  end
+end

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

@@ -95,7 +95,7 @@ module Moxml
           input&.gsub(
             ::Oga::XML::Entities::ENCODE_ATTRIBUTE_REGEXP,
             # Keep apostrophes in attributes
-            ::Oga::XML::Entities::ENCODE_ATTRIBUTE_MAPPING.merge("'" => "'")
+            ::Oga::XML::Entities::ENCODE_ATTRIBUTE_MAPPING.merge("'" => "'"),
           )
         end
       end

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

@@ -9,11 +9,15 @@ module Moxml
         def initialize(attr_name, value, parent = nil)
           self.name = attr_name
           @parent = parent
+          @value = value # Explicitly set @value
           super(value)
         end
 
         def name=(new_name)
-          @prefix, new_name = new_name.to_s.split(":", 2) if new_name.to_s.include?(":")
+          if new_name.to_s.include?(":")
+            @prefix, new_name = new_name.to_s.split(":",
+                                                    2)
+          end
 
           @name = new_name
         end
@@ -21,6 +25,29 @@ module Moxml
         def expanded_name
           [prefix, name].compact.join(":")
         end
+
+        # Expose the value stored in Ox::Node
+        # Ox stores attribute values using @value instance variable
+        def value
+          @value
+        end
+
+        # Serialize the attribute to XML format with proper escaping
+        def to_xml
+          escaped_value = @value.to_s
+            .gsub("&", "&")
+            .gsub("<", "&lt;")
+            .gsub(">", "&gt;")
+            .gsub('"', "&quot;")
+            .gsub("'", "&apos;")
+
+          "#{expanded_name}=\"#{escaped_value}\""
+        end
+
+        # Support string conversion
+        def to_s
+          to_xml
+        end
       end
     end
   end

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "rexml/formatters/pretty"
 
 module Moxml
@@ -36,7 +38,7 @@ module Moxml
 
           # Check for mixed content
           has_text = node.children.any? { |c| c.is_a?(::REXML::Text) && !c.to_s.strip.empty? }
-          has_elements = node.children.any? { |c| c.is_a?(::REXML::Element) }
+          has_elements = node.children.any?(::REXML::Element)
           mixed = has_text && has_elements
 
           # Handle children based on content type
@@ -46,8 +48,8 @@ module Moxml
             node.children.each_with_index do |child, _index|
               # Skip insignificant whitespace
               next if child.is_a?(::REXML::Text) &&
-                      child.to_s.strip.empty? &&
-                      !(child.next_sibling.nil? && child.previous_sibling.nil?)
+                child.to_s.strip.empty? &&
+                !(child.next_sibling.nil? && child.previous_sibling.nil?)
 
               # Indent non-text nodes in non-mixed content
               # if !mixed && !child.is_a?(::REXML::Text)
@@ -95,7 +97,7 @@ module Moxml
         def find_significant_sibling(node, direction)
           method = direction == :next ? :next_sibling : :previous_sibling
           sibling = node.send(method)
-          sibling = sibling.send(method) while sibling && sibling.is_a?(::REXML::Text) && sibling.to_s.strip.empty?
+          sibling = sibling.send(method) while sibling.is_a?(::REXML::Text) && sibling.to_s.strip.empty?
           sibling
         end
 
@@ -144,7 +146,9 @@ module Moxml
         def write_declaration(node, output)
           output << "<?xml"
           output << %( version="#{node.version}") if node.version
-          output << %( encoding="#{node.encoding.to_s.upcase}") if node.writeencoding
+          if node.writeencoding
+            output << %( encoding="#{node.encoding.to_s.upcase}")
+          end
           output << %( standalone="#{node.standalone}") if node.standalone
           output << "?>"
           # output << "\n"
@@ -155,13 +159,14 @@ module Moxml
           node.attributes.each do |name, attr|
             next unless name.to_s.start_with?("xmlns:") || name.to_s == "xmlns"
 
-            name = "xmlns" if name.to_s == "xmlns:" # convert the default namespace
+            # convert the default namespace
+            name = "xmlns" if name.to_s == "xmlns:"
             value = attr.respond_to?(:value) ? attr.value : attr
             output << " #{name}=\"#{value}\""
           end
 
           # Then write regular attributes
-          node.attributes.each do |name, attr|
+          node.attributes.each do |name, attr| # rubocop:disable Style/CombinableLoops
             next if name.to_s.start_with?("xmlns:") || name.to_s == "xmlns"
 
             output << " "
@@ -175,7 +180,7 @@ module Moxml
             value = attr.respond_to?(:value) ? attr.value : attr
             output << escape_attribute_value(value.to_s)
             output << "\""
-          end
+          end # rubocop:enable Style/CombinableLoops
         end
 
         def escape_attribute_value(value)

data/lib/moxml/adapter/headed_ox.rb

@@ -0,0 +1,161 @@
+# frozen_string_literal: true
+
+require_relative "ox"
+require_relative "../xpath"
+# Force load XPath modules (autoload doesn't work well with relative requires in examples)
+require_relative "../xpath/parser"
+require_relative "../xpath/compiler"
+
+module Moxml
+  module Adapter
+    # HeadedOx adapter - combines Ox's fast 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.
+    #
+    # @example
+    #   context = Moxml.new(:headed_ox)
+    #   doc = context.parse(xml_string)
+    #   results = doc.xpath('//book[@price < 10]/title')
+    #
+    class HeadedOx < Ox
+      class << self
+        # Override parse to use HeadedOx context instead of Ox context
+        def parse(xml, _options = {})
+          native_doc = begin
+            result = ::Ox.parse(xml)
+
+            # result can be either Document or Element
+            if result.is_a?(::Ox::Document)
+              result
+            else
+              doc = ::Ox::Document.new
+              doc << result
+              doc
+            end
+          rescue ::Ox::ParseError => e
+            raise Moxml::ParseError.new(
+              e.message,
+              source: xml.is_a?(String) ? xml[0..100] : nil,
+            )
+          end
+
+          # Use :headed_ox context instead of :ox
+          DocumentBuilder.new(Context.new(:headed_ox)).build(native_doc)
+        end
+
+        # Execute XPath query using Moxml's XPath engine
+        #
+        # This overrides the Ox adapter's xpath method which uses locate().
+        #
+        # @param [Moxml::Node] node Starting node (wrapped Moxml node)
+        # @param [String] expression XPath expression
+        # @param [Hash] namespaces Namespace prefix mappings
+        # @return [Moxml::NodeSet, Object] Query results
+        def xpath(node, expression, namespaces = {})
+          # If we receive a native node, wrap it first
+          # Document#xpath passes @native, but our compiled XPath needs Moxml nodes
+          unless node.is_a?(Moxml::Node)
+            # Determine the context from the node if possible
+            # For now, create a basic context for wrapped nodes
+            ctx = Context.new(:headed_ox)
+
+            # Wrap the native node - don't rebuild the whole document
+            node = 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)
+
+          # Wrap Array results in NodeSet, return other types directly
+          case result
+          when Array
+            # Deduplicate by native object identity to handle descendant-or-self
+            # which may yield the same native node multiple times
+            nodeset = NodeSet.new(result, node.context)
+            nodeset.uniq_by_native
+          when NodeSet
+            # Deduplicate NodeSet results as well
+            result.uniq_by_native
+          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 [Moxml::Node, Object, nil] First result or nil
+        def at_xpath(node, expression, namespaces = {})
+          result = xpath(node, expression, namespaces)
+          result.is_a?(NodeSet) ? result.first : result
+        end
+
+        # Check if XPath is supported
+        #
+        # @return [Boolean] Always true for HeadedOx
+        def xpath_supported?
+          true
+        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_support: :full,
+            xpath_full: true,
+            xpath_axes: :partial, # 6 of 13 axes: child, descendant, descendant-or-self, self, attribute, parent
+            xpath_functions: :complete, # All 27 XPath 1.0 functions
+            xpath_predicates: true,
+            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,
+          }
+        end
+      end
+    end
+  end
+end