moxml 0.1.22 → 0.1.24

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.22"
+  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
@@ -82,6 +80,7 @@ module Moxml
       else
         # Accept relative references and bare paths
         return unless uri.match?(/[\x00-\x08\x0B\x0C\x0E-\x1F]/)
+
         raise ValidationError, "Invalid URI: #{uri}"
       end
     rescue URI::InvalidURIError

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,27 +40,64 @@ 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
+
+    def restore_entities(text)
+      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/integration/all_adapters_spec.rb

@@ -29,6 +29,7 @@ RSpec.describe "Cross-adapter integration" do
     "Memory Usage Examples",
     "Thread Safety Examples",
     "Entity Reference Whitespace Preservation",
+    "Moxml Line Ending",
     "Performance Examples",
   ]
 

data/spec/integration/shared_examples/line_ending_behavior.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+RSpec.shared_examples "Moxml Line Ending" do
+  describe "Line ending configuration" do
+    let(:context) { Moxml.new }
+    let(:xml) { "<root><child>text</child></root>" }
+
+    it "produces no CRLF with LF default" do
+      doc = context.parse(xml)
+      expect(doc.to_xml).not_to include("\r\n")
+    end
+
+    it "produces no bare LF with CRLF configured" do
+      context.config.default_line_ending = Moxml::Config::LINE_ENDING_CRLF
+      doc = context.parse(xml)
+      expect(doc.to_xml).not_to match(/(?<!\r)\n/)
+    end
+
+    it "allows per-call CRLF override producing no bare LF" do
+      doc = context.parse(xml)
+      output = doc.to_xml(line_ending: Moxml::Config::LINE_ENDING_CRLF)
+      expect(output).not_to match(/(?<!\r)\n/)
+    end
+
+    it "per-call LF override wins over config CRLF" do
+      context.config.default_line_ending = Moxml::Config::LINE_ENDING_CRLF
+      doc = context.parse(xml)
+      expect(doc.to_xml(line_ending: Moxml::Config::LINE_ENDING_LF))
+        .not_to include("\r\n")
+    end
+
+    it "produces identical bytes on re-serialization with CRLF" do
+      context.config.default_line_ending = Moxml::Config::LINE_ENDING_CRLF
+      doc = context.parse(xml)
+      first = doc.to_xml
+
+      ctx2 = Moxml.new
+      ctx2.config.default_line_ending = Moxml::Config::LINE_ENDING_CRLF
+      result = ctx2.parse(first)
+      expect(result.to_xml).to eq(first)
+    end
+
+    it "preserves element structure through CRLF round-trip" do
+      doc = context.parse("<root><a>text</a><b>more</b></root>")
+      context.config.default_line_ending = Moxml::Config::LINE_ENDING_CRLF
+      crlf_output = doc.to_xml
+
+      ctx2 = Moxml.new
+      result = ctx2.parse(crlf_output)
+      elements = result.root.children.select(&:element?)
+      expect(elements.map(&:name)).to eq(%w[a b])
+      expect(elements[0].children.first.content).to eq("text")
+      expect(elements[1].children.first.content).to eq("more")
+    end
+  end
+end

data/spec/moxml/adapter/libxml_internals_spec.rb

@@ -105,7 +105,8 @@ RSpec.describe Moxml::Adapter::Libxml do
 
     it "returns [nil, nil] when the document has no entity-ref attachments" do
       root = libxml_native(context.parse("<root><a/></root>").root)
-      expect(adapter.send(:lookup_entity_ref_serialization, root)).to eq([nil, nil])
+      expect(adapter.send(:lookup_entity_ref_serialization,
+                          root)).to eq([nil, nil])
     end
 
     it "returns [nil, nil] for an element with no entity refs even when the doc has erefs elsewhere" do
@@ -129,7 +130,8 @@ RSpec.describe Moxml::Adapter::Libxml do
       )
       a.add_child(eref)
 
-      refs, seq = adapter.send(:lookup_entity_ref_serialization, libxml_native(a))
+      refs, seq = adapter.send(:lookup_entity_ref_serialization,
+                               libxml_native(a))
       expect(refs).to be_an(Array).and(satisfy { |r| !r.empty? })
       expect(seq).to be_an(Array).and(include(:eref))
     end

data/spec/moxml/adapter/platform_spec.rb

@@ -4,7 +4,8 @@ require "spec_helper"
 
 RSpec.describe Moxml::Adapter, ".platform_adapters" do
   it "includes all known adapters under MRI" do
-    expect(described_class.platform_adapters).to include(:nokogiri, :oga, :rexml, :ox)
+    expect(described_class.platform_adapters).to include(:nokogiri, :oga,
+                                                         :rexml, :ox)
   end
 
   it "uses the AVAILABLE_ADAPTERS constant under MRI" do

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

data/spec/moxml/config_spec.rb

@@ -10,6 +10,7 @@ RSpec.describe Moxml::Config do
       expect(config.strict_parsing).to be true
       expect(config.default_encoding).to eq("UTF-8")
       expect(config.default_indent).to eq(2)
+      expect(config.default_line_ending).to eq("\n")
       expect(config.entity_encoding).to eq(:basic)
     end
 
@@ -89,6 +90,38 @@ RSpec.describe Moxml::Config do
     end
   end
 
+  describe "#default_line_ending=" do
+    it "accepts LINE_ENDING_LF" do
+      config.default_line_ending = Moxml::Config::LINE_ENDING_LF
+      expect(config.default_line_ending).to eq("\n")
+    end
+
+    it "accepts LINE_ENDING_CRLF" do
+      config.default_line_ending = Moxml::Config::LINE_ENDING_CRLF
+      expect(config.default_line_ending).to eq("\r\n")
+    end
+
+    it "rejects nil" do
+      expect { config.default_line_ending = nil }
+        .to raise_error(ArgumentError, /Invalid line_ending/)
+    end
+
+    it "rejects arbitrary strings" do
+      expect { config.default_line_ending = "BAD" }
+        .to raise_error(ArgumentError, /Invalid line_ending/)
+    end
+
+    it "rejects bare CR" do
+      expect { config.default_line_ending = "\r" }
+        .to raise_error(ArgumentError, /Invalid line_ending/)
+    end
+
+    it "rejects empty string" do
+      expect { config.default_line_ending = "" }
+        .to raise_error(ArgumentError, /Invalid line_ending/)
+    end
+  end
+
   describe "#adapter=" do
     it "sets valid adapter" do
       config.adapter = :ox

data/spec/moxml/context_spec.rb

@@ -25,4 +25,18 @@ RSpec.describe Moxml::Context do
       expect(context.config.adapter.ancestors).to include(Moxml::Adapter::Base)
     end
   end
+
+  describe "#build" do
+    it "creates a document via builder DSL" do
+      doc = context.build do
+        element("root") do
+          element("child") do
+            text("hello")
+          end
+        end
+      end
+      expect(doc).to be_a(Moxml::Document)
+      expect(doc.root.name).to eq("root")
+    end
+  end
 end

data/spec/moxml/moxml_spec.rb

@@ -52,4 +52,17 @@ RSpec.describe Moxml do
       expect(Moxml::Config::VALID_ADAPTERS).to include(Moxml::Config.runtime_default_adapter)
     end
   end
+
+  describe ".parse" do
+    it "parses XML with shorthand" do
+      doc = described_class.parse("<root>hello</root>")
+      expect(doc).to be_a(Moxml::Document)
+      expect(doc.root.text).to eq("hello")
+    end
+
+    it "accepts adapter option" do
+      doc = described_class.parse("<root/>", adapter: :rexml)
+      expect(doc).to be_a(Moxml::Document)
+    end
+  end
 end