moxml 0.1.23 → 0.1.24

data/lib/moxml/document.rb

@@ -1,16 +1,5 @@
 # frozen_string_literal: true
 
-require_relative "node"
-require_relative "element"
-require_relative "text"
-require_relative "cdata"
-require_relative "comment"
-require_relative "processing_instruction"
-require_relative "declaration"
-require_relative "namespace"
-require_relative "doctype"
-require_relative "entity_reference"
-
 module Moxml
   class Document < Node
     attr_accessor :has_xml_declaration

data/lib/moxml/document_builder.rb

@@ -13,15 +13,13 @@ module Moxml
       @current_doc = context.create_document(native_doc)
 
       # Transfer has_declaration flag if present in attachments
-      if adapter.respond_to?(:attachments) &&
-          adapter.attachments.key?(native_doc, :has_declaration)
+      if adapter.attachments.key?(native_doc, :has_declaration)
         has_declaration = adapter.attachments.get(native_doc, :has_declaration)
         @current_doc.has_xml_declaration = has_declaration
       end
 
       # Transfer DOCTYPE from parsed document if it exists in attachments
-      if adapter.respond_to?(:attachments) &&
-          adapter.attachments.key?(native_doc, :doctype)
+      if adapter.attachments.key?(native_doc, :doctype)
         doctype = adapter.attachments.get(native_doc, :doctype)
         if doctype
           adapter.attachments.set(@current_doc.native, :doctype, doctype)
@@ -35,10 +33,16 @@ module Moxml
     private
 
     def visit_node(node)
-      method_name = "visit_#{node_type(node)}"
-      return unless respond_to?(method_name, true)
-
-      send(method_name, node)
+      case node_type(node)
+      when :document then visit_document(node)
+      when :element then visit_element(node)
+      when :text then visit_text(node)
+      when :cdata then visit_cdata(node)
+      when :comment then visit_comment(node)
+      when :processing_instruction then visit_processing_instruction(node)
+      when :doctype then visit_doctype(node)
+      when :entity_reference then visit_entity_reference(node)
+      end
     end
 
     def visit_document(doc)

data/lib/moxml/element.rb

@@ -1,8 +1,5 @@
 # frozen_string_literal: true
 
-require_relative "attribute"
-require_relative "namespace"
-
 module Moxml
   class Element < Node
     def name
@@ -137,6 +134,8 @@ module Moxml
       adapter.restore_entities(val)
     end
 
+    alias content text
+
     def text=(content)
       adapter.set_text_content(@native, normalize_xml_value(content))
       invalidate_children_cache!
@@ -158,7 +157,8 @@ module Moxml
     end
 
     def inner_xml=(xml)
-      doc = context.parse("<root>#{xml}</root>")
+      wrapper = "_moxml_inner_#{Process.pid}_#{object_id}"
+      doc = context.parse("<#{wrapper}>#{xml}</#{wrapper}>")
       adapter.replace_children(@native, doc.root.children.map(&:native))
       invalidate_children_cache!
     end

data/lib/moxml/node.rb

@@ -1,11 +1,9 @@
 # frozen_string_literal: true
 
-require_relative "xml_utils"
-require_relative "node_set"
-
 module Moxml
   class Node
     include XmlUtils
+    include Enumerable
 
     TYPES = %i[
       element text cdata comment processing_instruction document
@@ -143,13 +141,14 @@ module Moxml
       ""
     end
 
-    # Attribute accessor - only works on Element nodes
-    # Returns nil for non-element nodes
-    def [](name)
-      return nil unless respond_to?(:attribute)
-
-      attr = attribute(name)
-      attr&.value if attr.respond_to?(:value)
+    # Returns the content/value of this node as a string.
+    # Each subclass overrides this with type-specific semantics:
+    # - Text, Comment, Cdata: raw text content
+    # - ProcessingInstruction: instruction content
+    # - Attribute: attribute value
+    # - Element: delegates to text (descendant text concatenation)
+    def content
+      ""
     end
 
     # Returns the namespace of this node
@@ -176,15 +175,39 @@ module Moxml
     def each_node(&block)
       children.each do |child|
         yield child
-        child.each_node(&block) if child.respond_to?(:each_node)
+        child.each_node(&block)
       end
     end
 
-    # Clone node (deep copy)
-    def clone
+    # Yield direct children, enabling Enumerable on the node.
+    def each(&block)
+      return to_enum(:each) unless block
+
+      children.each(&block)
+    end
+
+    def outer_xml
+      to_xml
+    end
+
+    def before(node)
+      add_previous_sibling(node)
+    end
+
+    def after(node)
+      add_next_sibling(node)
+    end
+
+    def blank?
+      text.strip.empty?
+    end
+
+    # Deep copy of the node (both dup and clone create deep copies for XML nodes)
+    def dup
       Moxml::Node.wrap(adapter.dup(@native), context)
     end
-    alias dup clone
+
+    alias clone dup
 
     def ==(other)
       self.class == other.class && @native == other.native

data/lib/moxml/node_set.rb

@@ -68,8 +68,7 @@ module Moxml
     end
 
     def <<(node)
-      # If it's a wrapped Moxml node, unwrap to native before storing
-      native_node = node.respond_to?(:native) ? node.native : node
+      native_node = node.is_a?(Node) ? node.native : node
       @nodes << native_node
       @wrapped << nil
       self
@@ -113,8 +112,7 @@ module Moxml
     # Delete a node from the set
     # Accepts both wrapped Moxml nodes and native nodes
     def delete(node)
-      # If it's a wrapped Moxml node, unwrap to native
-      native_node = node.respond_to?(:native) ? node.native : node
+      native_node = node.is_a?(Node) ? node.native : node
       idx = @nodes.index(native_node)
       if idx
         @nodes.delete_at(idx)

data/lib/moxml/sax/block_handler.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require_relative "handler"
-
 module Moxml
   module SAX
     # Block-based SAX handler with DSL

data/lib/moxml/sax/element_handler.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require_relative "handler"
-
 module Moxml
   module SAX
     # Element-focused SAX handler with stack tracking

data/lib/moxml/sax/namespace_splitter.rb

@@ -38,11 +38,12 @@ module Moxml
         when nil
           # nothing
         else
-          if attributes.respond_to?(:each)
+          if attributes.is_a?(Enumerable)
             attributes.each do |item|
-              if item.is_a?(Array) && item.size >= 2
-                yield item[0], item[1]
-              elsif item.respond_to?(:name) && item.respond_to?(:value)
+              case item
+              when Array
+                yield item[0], item[1] if item.size >= 2
+              else
                 yield item.name, item.value
               end
             end

data/lib/moxml/sax.rb

@@ -1,31 +1,10 @@
 # frozen_string_literal: true
 
-require_relative "sax/handler"
-require_relative "sax/element_handler"
-require_relative "sax/block_handler"
-
 module Moxml
-  # SAX (Simple API for XML) parsing interface
-  #
-  # Provides event-driven XML parsing across all Moxml adapters.
-  # SAX parsing is memory-efficient and suitable for processing large XML files.
-  #
-  # @example Class-based handler
-  #   class MyHandler < Moxml::SAX::Handler
-  #     def on_start_element(name, attributes = {}, namespaces = {})
-  #       puts "Started element: #{name}"
-  #     end
-  #   end
-  #
-  #   context = Moxml.new
-  #   context.sax_parse(xml_string, MyHandler.new)
-  #
-  # @example Block-based handler
-  #   context.sax_parse(xml_string) do
-  #     start_element { |name, attrs| puts "Element: #{name}" }
-  #     characters { |text| puts "Text: #{text}" }
-  #   end
-  #
   module SAX
+    autoload :Handler, "moxml/sax/handler"
+    autoload :ElementHandler, "moxml/sax/element_handler"
+    autoload :BlockHandler, "moxml/sax/block_handler"
+    autoload :NamespaceSplitter, "moxml/sax/namespace_splitter"
   end
 end

data/lib/moxml/version.rb

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

data/lib/moxml/xml_utils.rb

@@ -1,12 +1,10 @@
 # frozen_string_literal: true
 
-require_relative "xml_utils/encoder"
-
-# Ruby 3.3+ requires the URI module to be explicitly required
 require "uri" unless defined?(URI)
 
 module Moxml
   module XmlUtils
+    autoload :Encoder, "moxml/xml_utils/encoder"
     def encode_entities(text, mode = nil)
       Encoder.new(text, mode).call
     end

data/lib/moxml/xpath/compiler.rb

@@ -62,16 +62,6 @@ module Moxml
         matched = matched_literal
         context_var = context_literal
 
-        # Enable debug output
-        debug = ENV["DEBUG_XPATH"] == "1"
-        if debug
-          puts "\n#{'=' * 60}"
-          puts "COMPILING XPath"
-          puts "=" * 60
-          puts "AST: #{ast.inspect}"
-          puts
-        end
-
         ruby_ast = if return_nodeset?(ast)
                      process(ast, document) { |node| matched.push(node) }
                    else
@@ -103,14 +93,6 @@ module Moxml
         generator = Ruby::Generator.new
         source = generator.process(proc_ast)
 
-        if debug
-          puts "GENERATED RUBY CODE:"
-          puts "-" * 60
-          puts source
-          puts "=" * 60
-          puts
-        end
-
         CONTEXT.evaluate(source)
       ensure
         @literal_id = 0
@@ -1506,7 +1488,7 @@ module Moxml
             xml_lang.assign(string("xml:lang"))
           end
           .followed_by do
-            node.respond_to?(symbol(:attribute)).while_true do
+            node.is_a?(const_ref("Moxml", "Element")).while_true do
               found.assign(node.get(xml_lang))
                 .followed_by do
                   found.if_true do
@@ -1622,36 +1604,6 @@ module Moxml
         arg_var.assign(arg_ast).followed_by { yield arg_var }
       end
 
-      # Helper: Try to match first node v1
-      def try_match_first_node_v1(ast, input, optimize_first = true)
-        if return_nodeset?(ast) && optimize_first
-          matched_set = unique_literal(:matched_set)
-          first_node = unique_literal(:first_node)
-          context_var = context_literal
-
-          # Create NodeSet for results
-          nodeset_class = const_ref("Moxml", "NodeSet")
-          empty_array = Ruby::Node.new(:array, [])
-          nodeset_new = Ruby::Node.new(:send,
-                                       [nodeset_class, "new", empty_array,
-                                        context_var])
-
-          matched_set.assign(nodeset_new)
-            .followed_by do
-              # Process with block to accumulate results
-              process(ast, input) { |node| matched_set.push(node) }
-            end
-            .followed_by do
-              first_node.assign(matched_set[literal(0)])
-            end
-            .followed_by do
-              first_node.if_true { first_node }.else { string("") }
-            end
-        else
-          process(ast, input)
-        end
-      end
-
       # Helper: Create mass assignment node
       def mass_assign(vars, value)
         Ruby::Node.new(:massign, [vars, value])

data/lib/moxml/xpath/conversion.rb

@@ -12,11 +12,11 @@ module Moxml
       # @param [Object] right
       # @return [Array<Object, Object>]
       def self.to_compatible_types(left, right)
-        if left.is_a?(Moxml::NodeSet) || left.respond_to?(:text)
+        if left.is_a?(Moxml::NodeSet) || left.is_a?(Moxml::Node)
           left = to_string(left)
         end
 
-        if right.is_a?(Moxml::NodeSet) || right.respond_to?(:text)
+        if right.is_a?(Moxml::NodeSet) || right.is_a?(Moxml::Node)
           right = to_string(right)
         end
 
@@ -51,7 +51,7 @@ module Moxml
           value = first_node_text(value)
         end
 
-        if value.respond_to?(:text)
+        if value.is_a?(Moxml::Node)
           value = value.text
         end
 
@@ -67,7 +67,7 @@ module Moxml
           value = first_node_text(value)
         end
 
-        if value.respond_to?(:text)
+        if value.is_a?(Moxml::Node)
           value = value.text
         end
 
@@ -95,7 +95,7 @@ module Moxml
           bool = !value.nan? && !value.zero?
         elsif value.is_a?(Integer)
           bool = !value.zero?
-        elsif value.respond_to?(:empty?)
+        elsif value.is_a?(String) || value.is_a?(Moxml::NodeSet) || value.is_a?(Array)
           bool = !value.empty?
         elsif value
           bool = true
@@ -117,7 +117,8 @@ module Moxml
       # @param [Moxml::NodeSet] set
       # @return [String]
       def self.first_node_text(set)
-        set[0].respond_to?(:text) ? set[0].text : ""
+        first = set[0]
+        first.is_a?(Moxml::Node) ? first.text : ""
       end
     end
   end

data/lib/moxml/xpath/ruby/generator.rb

@@ -13,13 +13,7 @@ module Moxml
         # @param [Moxml::XPath::Ruby::Node] ast
         # @return [String]
         def process(ast)
-          handler = :"on_#{ast.type}"
-          unless respond_to?(handler, true)
-            raise NotImplementedError,
-                  "Generator missing handler for node type :#{ast.type}. Node: #{ast.inspect}"
-          end
-
-          send(handler, ast)
+          send(:"on_#{ast.type}", ast)
         end
 
         # @param [Moxml::XPath::Ruby::Node] ast
@@ -81,6 +75,15 @@ module Moxml
           "#{left_str} == #{right_str}"
         end
 
+        def on_neq(ast)
+          left, right = *ast
+
+          left_str = process(left)
+          right_str = process(right)
+
+          "#{left_str} != #{right_str}"
+        end
+
         # Processes a boolean "and" node.
         #
         # @param [Moxml::XPath::Ruby::Node] ast
@@ -167,14 +170,8 @@ module Moxml
           brackets = name == "[]"
 
           unless args.empty?
-            arg_strs = []
-            args.each do |arg|
-              result = process(arg)
-              # Keep processing if we got a Node back (happens with nested send nodes)
-              while result.respond_to?(:type)
-                result = process(result)
-              end
-              arg_strs << result
+            arg_strs = args.map do |arg|
+              process(arg)
             end
             arg_str = arg_strs.join(", ")
             call = brackets ? "[#{arg_str}]" : "#{call}(#{arg_str})"
@@ -182,10 +179,6 @@ module Moxml
 
           if receiver
             rec_str = process(receiver)
-            # Keep processing if we got a Node back
-            while rec_str.respond_to?(:type)
-              rec_str = process(rec_str)
-            end
             call = brackets ? "#{rec_str}#{call}" : "#{rec_str}.#{call}"
           end
 

data/lib/moxml/xpath/ruby/node.rb

@@ -95,15 +95,7 @@ module Moxml
         # @param [Class] klass
         # @return [Moxml::XPath::Ruby::Node]
         def is_a?(klass)
-          # If klass is already a Node (e.g., a const node), use it directly
-          # Otherwise wrap it in a lit node
-          klass_node = if klass.respond_to?(:type)
-                         klass
-                       else
-                         Node.new(:lit, [klass.to_s])
-                       end
-
-          Node.new(:send, [self, "is_a?", klass_node])
+          Node.new(:send, [self, "is_a?", klass])
         end
 
         # Wraps the current node in a block.

data/lib/moxml/xpath.rb

@@ -1,16 +1,6 @@
 # frozen_string_literal: true
 
 module Moxml
-  # XPath 1.0 implementation for Moxml
-  #
-  # This module provides a complete XPath 1.0 engine for querying XML
-  # documents, particularly for the Ox adapter which has limited native
-  # XPath support.
-  #
-  # @example Basic usage
-  #   engine = Moxml::XPath::Engine.new(document)
-  #   results = engine.evaluate("//book[@id='123']")
-  #
   module XPath
     autoload :Engine, "moxml/xpath/engine"
     autoload :Context, "moxml/xpath/context"
@@ -20,15 +10,17 @@ module Moxml
     autoload :Parser, "moxml/xpath/parser"
     autoload :Compiler, "moxml/xpath/compiler"
 
-    # Require errors directly so classes are immediately available
-    require_relative "xpath/errors"
+    autoload :Error, "moxml/xpath/errors"
+    autoload :SyntaxError, "moxml/xpath/errors"
+    autoload :EvaluationError, "moxml/xpath/errors"
+    autoload :FunctionError, "moxml/xpath/errors"
+    autoload :NodeTypeError, "moxml/xpath/errors"
+    autoload :InvalidContextError, "moxml/xpath/errors"
 
-    # AST nodes for expression representation
     module AST
       autoload :Node, "moxml/xpath/ast/node"
     end
 
-    # Ruby AST generation for compiling XPath
     module Ruby
       autoload :Node, "moxml/xpath/ruby/node"
       autoload :Generator, "moxml/xpath/ruby/generator"

data/lib/moxml.rb

@@ -8,13 +8,30 @@ module Moxml
       context
     end
 
+    def parse(xml, adapter: nil, **options)
+      Context.new(adapter).parse(xml, options)
+    end
+
     def configure
       yield Config.default if block_given?
     end
 
     def with_config(adapter_name = nil, strict_parsing = nil,
                     default_encoding = nil)
-      original_config = Config.default.dup
+      original = Config.default
+      saved_values = {
+        adapter: original.adapter_name,
+        strict_parsing: original.strict_parsing,
+        default_encoding: original.default_encoding,
+        default_indent: original.default_indent,
+        default_line_ending: original.default_line_ending,
+        entity_load_mode: original.entity_load_mode,
+        entity_encoding: original.entity_encoding,
+        restore_entities: original.restore_entities,
+        namespace_validation_mode: original.namespace_validation_mode,
+        entity_restoration_mode: original.entity_restoration_mode,
+        preload_entity_sets: original.preload_entity_sets.dup,
+      }
 
       configure do |config|
         config.adapter = adapter_name unless adapter_name.nil?
@@ -23,15 +40,22 @@ module Moxml
       end
 
       yield if block_given?
-
-      # restore the original config
+    ensure
       configure do |config|
-        config.adapter = original_config.adapter_name
-        config.strict_parsing = original_config.strict_parsing
-        config.default_encoding = original_config.default_encoding
+        config.adapter = saved_values[:adapter]
+        config.strict_parsing = saved_values[:strict_parsing]
+        config.default_encoding = saved_values[:default_encoding]
+        config.default_indent = saved_values[:default_indent]
+        config.default_line_ending = saved_values[:default_line_ending]
+        config.entity_load_mode = saved_values[:entity_load_mode]
+        config.entity_encoding = saved_values[:entity_encoding]
+        config.restore_entities = saved_values[:restore_entities]
+        config.namespace_validation_mode = saved_values[:namespace_validation_mode]
+        config.entity_restoration_mode = saved_values[:entity_restoration_mode]
+        config.preload_entity_sets = saved_values[:preload_entity_sets]
       end
-      original_config = nil
     end
+
     def preprocess_entities(xml)
       Adapter::Base.preprocess_entities(xml)
     end
@@ -40,17 +64,40 @@ module Moxml
       Adapter::Base.restore_entities(text)
     end
   end
-end
 
-require_relative "moxml/version"
-require_relative "moxml/document"
-require_relative "moxml/document_builder"
-require_relative "moxml/error"
-require_relative "moxml/builder"
-require_relative "moxml/config"
-require_relative "moxml/context"
-require_relative "moxml/entity_registry"
-require_relative "moxml/native_attachment"
-require_relative "moxml/adapter"
-require_relative "moxml/xpath"
-require_relative "moxml/sax"
+  autoload :VERSION, "moxml/version"
+  autoload :Config, "moxml/config"
+  autoload :Context, "moxml/context"
+  autoload :Node, "moxml/node"
+  autoload :NodeSet, "moxml/node_set"
+  autoload :Document, "moxml/document"
+  autoload :Element, "moxml/element"
+  autoload :Text, "moxml/text"
+  autoload :Cdata, "moxml/cdata"
+  autoload :Comment, "moxml/comment"
+  autoload :Attribute, "moxml/attribute"
+  autoload :ProcessingInstruction, "moxml/processing_instruction"
+  autoload :Declaration, "moxml/declaration"
+  autoload :Namespace, "moxml/namespace"
+  autoload :Doctype, "moxml/doctype"
+  autoload :EntityReference, "moxml/entity_reference"
+  autoload :DocumentBuilder, "moxml/document_builder"
+  autoload :Builder, "moxml/builder"
+  autoload :EntityRegistry, "moxml/entity_registry"
+  autoload :NativeAttachment, "moxml/native_attachment"
+  autoload :XmlUtils, "moxml/xml_utils"
+  autoload :Adapter, "moxml/adapter"
+  autoload :XPath, "moxml/xpath"
+  autoload :SAX, "moxml/sax"
+
+  # Error hierarchy — each subclass autoloads from the same file
+  autoload :Error, "moxml/error"
+  autoload :NotImplementedError, "moxml/error"
+  autoload :ValidationError, "moxml/error"
+  autoload :ParseError, "moxml/error"
+  autoload :DocumentStructureError, "moxml/error"
+  autoload :NamespaceError, "moxml/error"
+  autoload :EntityDataError, "moxml/error"
+  autoload :XPathError, "moxml/error"
+  autoload :AdapterError, "moxml/error"
+end

data/spec/moxml/attribute_spec.rb

@@ -27,4 +27,20 @@ RSpec.describe Moxml::Attribute do
       expect(attr.to_s).to match(/\w+="\w+"/)
     end
   end
+
+  describe "#element" do
+    it "returns wrapped Element" do
+      attr = element.attributes.find { |a| a.name == "id" }
+      parent = attr.element
+      expect(parent).to be_a(Moxml::Element)
+      expect(parent.name).to eq("root")
+    end
+  end
+
+  describe "#content" do
+    it "returns attribute value" do
+      attr = element.attributes.find { |a| a.name == "id" }
+      expect(attr.content).to eq("123")
+    end
+  end
 end