moxml 0.2.0 → 0.4.0

data/lib/moxml/version.rb

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

data/lib/moxml/xpath/compiler.rb

@@ -22,6 +22,7 @@ module Moxml
     class Compiler
       # Shared context for compiled Procs
       CONTEXT = Context.new
+      private_constant :CONTEXT
 
       # Expression cache
       CACHE = Cache.new
@@ -294,6 +295,12 @@ module Moxml
 
         handler = axis_name.gsub("-", "_")
 
+        unless respond_to?(:"on_axis_#{handler}", true)
+          raise XPath::Error.new(
+            "XPath axis #{axis_name.inspect} is not supported by this engine",
+          )
+        end
+
         send(:"on_axis_#{handler}", test, input, &block)
       end
 
@@ -362,6 +369,78 @@ module Moxml
         end
       end
 
+      # AXIS: ancestor - all ancestors up to the document
+      def on_axis_ancestor(ast, input)
+        ancestor = unique_literal(:ancestor)
+
+        document_or_node(input).if_true do
+          input.ancestors.each.add_block(ancestor) do
+            condition = process(ast, ancestor)
+            if block_given?
+              condition.if_true { yield ancestor }
+            else
+              condition.if_true { ancestor }
+            end
+          end
+        end
+      end
+
+      # AXIS: ancestor-or-self - the context node and its ancestors
+      def on_axis_ancestor_or_self(ast, input)
+        ancestor = unique_literal(:ancestor)
+
+        document_or_node(input).if_true do
+          self_result = process(ast, input)
+          self_collection = if block_given?
+                              self_result.if_true { yield input }
+                            else
+                              self_result.if_true { input }
+                            end
+          self_collection.followed_by do
+            input.ancestors.each.add_block(ancestor) do
+              condition = process(ast, ancestor)
+              if block_given?
+                condition.if_true { yield ancestor }
+              else
+                condition.if_true { ancestor }
+              end
+            end
+          end
+        end
+      end
+
+      # AXIS: following-sibling - siblings after the context node
+      def on_axis_following_sibling(ast, input)
+        sibling = unique_literal(:sibling)
+
+        document_or_node(input).if_true do
+          input.following_siblings.each.add_block(sibling) do
+            condition = process(ast, sibling)
+            if block_given?
+              condition.if_true { yield sibling }
+            else
+              condition.if_true { sibling }
+            end
+          end
+        end
+      end
+
+      # AXIS: preceding-sibling - siblings before the context node
+      def on_axis_preceding_sibling(ast, input)
+        sibling = unique_literal(:sibling)
+
+        document_or_node(input).if_true do
+          input.preceding_siblings.each.add_block(sibling) do
+            condition = process(ast, sibling)
+            if block_given?
+              condition.if_true { yield sibling }
+            else
+              condition.if_true { sibling }
+            end
+          end
+        end
+      end
+
       # AXIS: descendant-or-self - Enables // operator
       def on_axis_descendant_or_self(ast, input)
         node = unique_literal(:descendant)
@@ -623,7 +702,11 @@ module Moxml
 
       # Parent node (..)
       def on_parent(_ast, input)
-        input.parent
+        if block_given?
+          yield input.parent
+        else
+          input.parent
+        end
       end
 
       # ===== OPERATORS =====
@@ -1752,7 +1835,7 @@ module Moxml
 
       # Helper: Check if AST node is a number
       def number?(ast)
-        %i[int float number].include?(ast.type)
+        ast.type == :number
       end
 
       # Helper: Check if AST contains a call node with given name

data/lib/moxml.rb

@@ -26,7 +26,6 @@ module Moxml
         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,
@@ -48,7 +47,6 @@ module Moxml
         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]
@@ -82,7 +80,6 @@ module Moxml
   autoload :Namespace, "moxml/namespace"
   autoload :Doctype, "moxml/doctype"
   autoload :EntityReference, "moxml/entity_reference"
-  autoload :DocumentBuilder, "moxml/document_builder"
   autoload :Builder, "moxml/builder"
   autoload :Entity, "moxml/entity"
   autoload :EntityRegistry, "moxml/entity_registry"

data/spec/integration/all_adapters_spec.rb

@@ -31,7 +31,7 @@ RSpec.describe "Cross-adapter integration" do
     "Moxml::EntityReference",
     "Moxml::Context",
     "Moxml::Builder",
-    "Moxml::DocumentBuilder",
+    "Moxml::Parse Behavior",
     "Moxml Integration",
     "Moxml Edge Cases",
     "Attribute Examples",

data/spec/integration/shared_examples/high_level/{document_builder_behavior.rb → parse_behavior.rb}

@@ -1,8 +1,7 @@
 # frozen_string_literal: true
 
-RSpec.shared_examples "Moxml::DocumentBuilder" do
+RSpec.shared_examples "Moxml::Parse Behavior" do
   let(:context) { Moxml.new }
-  let(:builder) { Moxml::DocumentBuilder.new(context) }
 
   describe "#build" do
     it "builds a document model from native document" do

data/spec/integration/shared_examples/node_wrappers/node_behavior.rb

@@ -106,5 +106,20 @@ RSpec.shared_examples "Moxml::Node" do
         expect(node.text).to eq("1")
       end
     end
+
+    describe "duplication" do
+      it "returns an independent deep copy" do
+        doc = context.parse("<root><a id='1'>text</a></root>")
+        original = doc.at_xpath("//a")
+        copy = original.dup
+
+        expect(copy).not_to equal(original)
+        expect(copy.name).to eq("a")
+        expect(copy["id"]).to eq("1")
+        expect(copy.text).to eq("text")
+        copy["id"] = "changed"
+        expect(original["id"]).to eq("1")
+      end
+    end
   end
 end

data/spec/moxml/adapter/leptris_spec.rb

@@ -58,8 +58,16 @@ RSpec.describe Moxml::Adapter::Leptris do
       expect(attrs.map(&:value)).to eq(%w[1 2])
     end
 
-    it "falls back to the Ruby engine for element-context queries" do
+    it "evaluates element-context queries on the native engine" do
       expect(doc.root.xpath(".//item").size).to eq(2)
+      first_item = doc.root.children.find(&:element?)
+      expect(first_item.xpath("following-sibling::*").map(&:name)).to eq(%w[item])
+    end
+
+    it "falls back to the Ruby engine for parent-axis queries from the root" do
+      # The binding reports the root element parentless; moxml roots
+      # it at the document
+      expect(doc.root.xpath("../*").size).to eq(1)
     end
 
     it "falls back to the Ruby engine for the xmlns: reserved prefix" do

data/spec/moxml/adapter/libxml_internals_spec.rb

@@ -154,7 +154,7 @@ RSpec.describe Moxml::Adapter::Libxml do
     end
   end
 
-  describe Moxml::Adapter::Libxml::EntityRestorer do
+  describe Moxml::Entity::Restorer do
     let(:context) { Moxml.new(:libxml) }
 
     it "restores entities through its public entry point" do

data/spec/moxml/config_spec.rb

@@ -11,7 +11,6 @@ RSpec.describe Moxml::Config do
       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
 
     it "sets default entity_load_mode to :required" do

data/spec/moxml/context_spec.rb

@@ -39,4 +39,26 @@ RSpec.describe Moxml::Context do
       expect(doc.root.name).to eq("root")
     end
   end
+
+  describe "wrapper identity map" do
+    it "hands back the same wrapper for the same native" do
+      doc = context.parse("<root><item id='1'/></root>")
+      first = doc.xpath("//item").first
+      second = doc.xpath("//item").first
+      expect(first).to equal(second)
+
+      again = doc.root.children.last
+      expect(again).to equal(first)
+    end
+
+    it "re-keys when refresh_native! swaps the native" do
+      doc = context.create_document
+      element = doc.create_element("x")
+      doc.add_child(element)
+
+      refreshed = doc.root
+      expect(refreshed.name).to eq("x")
+      expect(context.wrapper_for(refreshed.native)).to equal(refreshed)
+    end
+  end
 end

data/spec/moxml/error_spec.rb

@@ -150,31 +150,6 @@ RSpec.describe "Moxml errors" do
     end
   end
 
-  describe Moxml::SerializationError do
-    it "includes node, adapter, and format information" do
-      error = described_class.new(
-        "Failed to serialize",
-        adapter: "LibXML",
-        format: "xml",
-      )
-      expect(error.adapter).to eq("LibXML")
-      expect(error.format).to eq("xml")
-    end
-
-    it "provides helpful error message" do
-      error = described_class.new(
-        "Failed to serialize",
-        adapter: "Ox",
-        format: "xml",
-      )
-      message = error.to_s
-      expect(message).to include("Failed to serialize")
-      expect(message).to include("Adapter: Ox")
-      expect(message).to include("Format: xml")
-      expect(message).to include("Hint:")
-    end
-  end
-
   describe Moxml::DocumentStructureError do
     it "includes attempted operation and state" do
       error = described_class.new(
@@ -200,31 +175,6 @@ RSpec.describe "Moxml errors" do
     end
   end
 
-  describe Moxml::AttributeError do
-    it "includes attribute name, element, and value" do
-      error = described_class.new(
-        "Invalid attribute",
-        name: "id",
-        value: 123,
-      )
-      expect(error.attribute_name).to eq("id")
-      expect(error.value).to eq(123)
-    end
-
-    it "provides helpful error message" do
-      error = described_class.new(
-        "Invalid attribute name",
-        name: "123invalid",
-        value: "test",
-      )
-      message = error.to_s
-      expect(message).to include("Invalid attribute name")
-      expect(message).to include("Attribute: 123invalid")
-      expect(message).to include("Value: \"test\"")
-      expect(message).to include("Hint:")
-    end
-  end
-
   describe Moxml::NotImplementedError do
     it "includes feature and adapter information" do
       error = described_class.new(

data/spec/moxml/xpath/axes_spec.rb

@@ -205,6 +205,46 @@ RSpec.describe "XPath Axes" do
       end
     end
 
+    describe "ancestor and sibling axes" do
+      let(:family) do
+        context.parse("<root><parent id='p1'><b id='1'/><b id='2'/><c/><d/></parent></root>")
+      end
+
+      def select(expression, node = family)
+        ast = Moxml::XPath::Parser.parse(expression)
+        proc = Moxml::XPath::Compiler.compile_with_cache(ast)
+        proc.call(node).map(&:name)
+      end
+
+      it "selects ancestors with ancestor::" do
+        expect(select("//c/ancestor::*")).to eq(%w[parent root])
+      end
+
+      it "includes the context node with ancestor-or-self::" do
+        expect(select("//c/ancestor-or-self::*")).to eq(%w[c parent root])
+      end
+
+      it "selects following siblings" do
+        expect(select("//c/following-sibling::*")).to eq(%w[d])
+        expect(select("//b[@id='1']/following-sibling::b")).to eq(%w[b])
+        expect(select("//b[@id='1']/following-sibling::*").size).to eq(3)
+      end
+
+      it "selects preceding siblings" do
+        expect(select("//c/preceding-sibling::*")).to eq(%w[b b])
+      end
+
+      it "resolves the bare parent step and steps after it" do
+        expect(select("//c/..")).to eq(%w[parent])
+        expect(select("//c/../*").size).to eq(4)
+      end
+
+      it "raises a clear error for unimplemented axes" do
+        expect { select("//c/following::*") }
+          .to raise_error(Moxml::XPath::Error, /not supported/)
+      end
+    end
+
     describe "descendant-or-self shorthand from an element" do
       it "selects descendants with .//step" do
         ast = Moxml::XPath::Parser.parse(".//grandchild")

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: moxml
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.4.0
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-08-25 00:00:00.000000000 Z
+date: 2026-08-26 00:00:00.000000000 Z
 dependencies: []
 description: |
   Moxml is a unified XML manipulation library that provides a common API
@@ -151,7 +151,6 @@ files:
 - lib/moxml/adapter/leptris.rb
 - lib/moxml/adapter/libxml.rb
 - lib/moxml/adapter/libxml/entity_ref_registry.rb
-- lib/moxml/adapter/libxml/entity_restorer.rb
 - lib/moxml/adapter/nokogiri.rb
 - lib/moxml/adapter/oga.rb
 - lib/moxml/adapter/ox.rb
@@ -187,10 +186,10 @@ files:
 - lib/moxml/declaration.rb
 - lib/moxml/doctype.rb
 - lib/moxml/document.rb
-- lib/moxml/document_builder.rb
 - lib/moxml/element.rb
 - lib/moxml/entity.rb
 - lib/moxml/entity/reference.rb
+- lib/moxml/entity/restorer.rb
 - lib/moxml/entity_reference.rb
 - lib/moxml/entity_registry.rb
 - lib/moxml/entity_registry_opal_data.rb
@@ -390,7 +389,7 @@ files:
 - spec/integration/shared_examples/high_level/.gitkeep
 - spec/integration/shared_examples/high_level/builder_behavior.rb
 - spec/integration/shared_examples/high_level/context_behavior.rb
-- spec/integration/shared_examples/high_level/document_builder_behavior.rb
+- spec/integration/shared_examples/high_level/parse_behavior.rb
 - spec/integration/shared_examples/integration_workflows.rb
 - spec/integration/shared_examples/line_ending_behavior.rb
 - spec/integration/shared_examples/node_wrappers/.gitkeep
@@ -444,7 +443,6 @@ files:
 - spec/moxml/declaration_preservation_spec.rb
 - spec/moxml/declaration_spec.rb
 - spec/moxml/doctype_spec.rb
-- spec/moxml/document_builder_spec.rb
 - spec/moxml/document_spec.rb
 - spec/moxml/element_spec.rb
 - spec/moxml/entity_preservation_spec.rb

data/lib/moxml/adapter/libxml/entity_restorer.rb

@@ -1,94 +0,0 @@
-# frozen_string_literal: true
-
-module Moxml
-  module Adapter
-    class Libxml < Base
-      # Restores configured character entities into explicit Moxml
-      # EntityReference nodes after LibXML has parsed the native tree.
-      class EntityRestorer
-        def initialize(doc, adapter: Libxml)
-          @doc = doc
-          @ctx = doc.context
-          @registry = @ctx.entity_registry
-          @config = @ctx.config
-          @adapter = adapter
-        end
-
-        def run
-          return unless @registry && @doc.root
-
-          walk(@doc.root)
-        end
-
-        private
-
-        def walk(element)
-          # Snapshot because we may add/remove siblings during the walk.
-          element.children.to_a.each do |child|
-            if child.is_a?(::Moxml::Text)
-              restore_text_node(child)
-            elsif child.is_a?(::Moxml::Element)
-              walk(child)
-            end
-          end
-        end
-
-        # Matches DocumentBuilder's previous behavior, including the libxml
-        # limitation that adjacent native text nodes get merged.
-        def restore_text_node(text_node)
-          content = text_node.content
-          return unless content
-
-          chunks = chunk_text(content)
-          return if chunks.size == 1 && chunks.first.first == :text
-
-          parent = text_node.parent
-          return unless parent
-
-          text_node.remove
-          chunks.each { |type, payload| append_chunk(parent, type, payload) }
-        end
-
-        def chunk_text(content)
-          chunks = []
-          buffer = +""
-          restorable = @registry.restorable_codepoints
-
-          content.each_char do |char|
-            cp = char.ord
-            if restorable.include?(cp) &&
-                (name = @registry.primary_name_for_codepoint(cp)) &&
-                @registry.should_restore?(cp, config: @config)
-              unless buffer.empty?
-                chunks << [:text, buffer.dup]
-                buffer.clear
-              end
-              chunks << [:eref, name]
-            else
-              buffer << char
-            end
-          end
-
-          chunks << [:text, buffer.dup] unless buffer.empty?
-          chunks
-        end
-
-        def append_chunk(parent, type, payload)
-          case type
-          when :text
-            parent.add_child(::Moxml::Text.new(
-                               @adapter.create_native_text(payload), @ctx
-                             ))
-          when :eref
-            parent.add_child(
-              ::Moxml::EntityReference.new(
-                @adapter.create_native_entity_reference(payload),
-                @ctx,
-              ),
-            )
-          end
-        end
-      end
-    end
-  end
-end

data/lib/moxml/document_builder.rb

@@ -1,167 +0,0 @@
-# frozen_string_literal: true
-
-module Moxml
-  class DocumentBuilder
-    attr_reader :context
-
-    def initialize(context)
-      @context = context
-      @node_stack = []
-    end
-
-    def build(native_doc)
-      @current_doc = context.create_document(native_doc)
-
-      # Transfer has_declaration flag if present in attachments
-      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.attachments.key?(native_doc, :doctype)
-        doctype = adapter.attachments.get(native_doc, :doctype)
-        if doctype
-          adapter.attachments.set(@current_doc.native, :doctype, doctype)
-        end
-      end
-
-      visit_node(native_doc)
-      @current_doc
-    end
-
-    private
-
-    def visit_node(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)
-      @node_stack.push(@current_doc)
-      visit_children(doc)
-      @node_stack.clear
-    end
-
-    def visit_element(node)
-      childless_node = adapter.duplicate_node(node)
-      adapter.replace_children(childless_node, [])
-      # Prepare node for new document (LibXML needs this)
-      childless_node = adapter.prepare_for_new_document(
-        childless_node,
-        @current_doc.native,
-      )
-      element = Element.new(childless_node, context)
-      @node_stack.last.add_child(element)
-
-      @node_stack.push(element) # add a parent for its children
-      visit_children(node)
-      @node_stack.pop # remove the parent
-    end
-
-    def visit_text(node)
-      # Prepare node for new document before wrapping
-      prepared = adapter.prepare_for_new_document(node, @current_doc.native)
-      content = adapter.text_content(node)
-
-      # Check if we should restore entity references for this text
-      if context.config.restore_entities && text_has_restorable_entities?(content)
-        restore_entities_in_text(content)
-      else
-        @node_stack.last&.add_child(Text.new(prepared, context))
-      end
-    end
-
-    def text_has_restorable_entities?(content)
-      return false unless content
-
-      registry = context.entity_registry
-      codepoints = registry.restorable_codepoints
-      content.each_char do |char|
-        return true if codepoints.include?(char.ord)
-      end
-      false
-    end
-
-    def restore_entities_in_text(content)
-      parent = @node_stack.last
-      return unless parent
-
-      registry = context.entity_registry
-      config = context.config
-      buffer = +""
-
-      content.to_s.each_char do |char|
-        codepoint = char.ord
-        name = registry.primary_name_for_codepoint(codepoint)
-
-        if name && registry.should_restore?(codepoint, config: config)
-          # Flush buffered text before the entity
-          unless buffer.empty?
-            parent.add_child(Text.new(adapter.create_text(buffer), context))
-            buffer.clear
-          end
-          parent.add_child(
-            EntityReference.new(adapter.create_entity_reference(name), context),
-          )
-        else
-          buffer << char
-        end
-      end
-
-      # Flush remaining buffer
-      unless buffer.empty?
-        parent.add_child(Text.new(adapter.create_text(buffer), context))
-      end
-    end
-
-    def visit_cdata(node)
-      prepared = adapter.prepare_for_new_document(node, @current_doc.native)
-      @node_stack.last&.add_child(Cdata.new(prepared, context))
-    end
-
-    def visit_comment(node)
-      prepared = adapter.prepare_for_new_document(node, @current_doc.native)
-      @node_stack.last&.add_child(Comment.new(prepared, context))
-    end
-
-    def visit_processing_instruction(node)
-      prepared = adapter.prepare_for_new_document(node, @current_doc.native)
-      @node_stack.last&.add_child(ProcessingInstruction.new(prepared, context))
-    end
-
-    def visit_doctype(node)
-      prepared = adapter.prepare_for_new_document(node, @current_doc.native)
-      @node_stack.last&.add_child(Doctype.new(prepared, context))
-    end
-
-    def visit_entity_reference(node)
-      prepared = adapter.prepare_for_new_document(node, @current_doc.native)
-      @node_stack.last&.add_child(EntityReference.new(prepared, context))
-    end
-
-    def visit_children(node)
-      children(node).each { |child| visit_node(child) }
-    end
-
-    def node_type(node)
-      context.config.adapter.node_type(node)
-    end
-
-    def children(node)
-      context.config.adapter.children(node)
-    end
-
-    def adapter
-      context.config.adapter
-    end
-  end
-end