moxml 0.5.30 → 0.5.31

data/lib/moxml/node_set.rb

@@ -6,10 +6,14 @@ module Moxml
 
     attr_reader :context
 
+    # nodes: Array of natives, or an adapter's LazyNodeSet — the
+    # native set is held unmaterialized until an operation needs an
+    # Array (#+, #<<, #delete, Range slices).
     def initialize(nodes, context, parent_node = nil)
-      @nodes = Array(nodes)
+      @nodes = nodes.is_a?(Array) ? nodes : nil
+      @lazy = @nodes ? nil : nodes
       @context = context
-      @wrapped = Array.new(@nodes.size)
+      @wrapped = nil
       @parent_node = parent_node
     end
 
@@ -17,15 +21,17 @@ module Moxml
     # The public surface is wrapper-only: every Enumerable access
     # goes through #each/#[]/#to_a, which wrap.
     def native_nodes
-      @nodes
+      return @nodes unless @nodes.nil?
+
+      @nodes = @lazy.to_a
     end
 
     def each
       return to_enum(:each) unless block_given?
 
-      wrapped = @wrapped
+      wrapped = wrapped_buffer
       index = 0
-      @nodes.each do |node|
+      (@nodes || @lazy).each do |node|
         wrapper = wrapped[index]
         unless wrapper
           wrapper = wrap_with_parent(node)
@@ -40,51 +46,56 @@ module Moxml
     def [](index)
       case index
       when Integer
-        actual = index.negative? ? @nodes.size + index : index
-        return nil unless actual >= 0 && actual < @nodes.size
+        actual = index.negative? ? native_size + index : index
+        return nil unless actual >= 0 && actual < native_size
 
-        @wrapped[actual] ||= wrap_with_parent(@nodes[actual])
+        wrapped_buffer[actual] ||= wrap_with_parent((@nodes || @lazy)[actual])
       when Range
-        self.class.new(@nodes[index], @context)
+        self.class.new(native_nodes[index], @context)
       end
     end
 
     def first(n = nil)
       if n.nil?
-        @nodes.empty? ? nil : self[0]
+        native_size.zero? ? nil : self[0]
       else
         n.times.filter_map { |i| self[i] }
       end
     end
 
     def last
-      @nodes.empty? ? nil : self[@nodes.size - 1]
+      native_size.zero? ? nil : self[native_size - 1]
     end
 
     def empty?
-      @nodes.empty?
+      native_size.zero?
     end
 
     def size
-      @nodes.size
+      native_size
     end
     alias length size
 
     def to_a
-      @nodes.each_with_index do |_node, i|
-        @wrapped[i] ||= wrap_with_parent(@nodes[i])
+      i = 0
+      wrapped = wrapped_buffer
+      (@nodes || @lazy).each do |node|
+        wrapped[i] ||= wrap_with_parent(node)
+        i += 1
       end
-      @wrapped.compact
+      wrapped.compact
     end
 
     def +(other)
-      self.class.new(@nodes + other.native_nodes, @context, @parent_node)
+      self.class.new(native_nodes + other.native_nodes, @context, @parent_node)
     end
 
     def <<(node)
       native_node = node.is_a?(Node) ? node.native : node
-      @nodes << native_node
-      @wrapped << nil
+      # Materialize the buffer first so it allocates at the pre-append
+      # size and stays in lockstep with the natives.
+      wrapped_buffer << nil
+      native_nodes << native_node
       self
     end
     alias push <<
@@ -94,7 +105,7 @@ module Moxml
     # which may yield the same native node multiple times
     def uniq_by_native
       seen = {}
-      unique_natives = @nodes.select do |native|
+      unique_natives = native_nodes.select do |native|
         id = native.object_id
         if seen[id]
           false
@@ -109,7 +120,7 @@ module Moxml
     def ==(other)
       self.class == other.class &&
         length == other.length &&
-        @nodes.each_with_index.all? do |_node, index|
+        native_nodes.each_with_index.all? do |_node, index|
           self[index] == other[index]
         end
     end
@@ -127,18 +138,30 @@ module Moxml
     # Accepts both wrapped Moxml nodes and native nodes
     def delete(node)
       native_node = node.is_a?(Node) ? node.native : node
-      idx = @nodes.index(native_node)
+      idx = native_nodes.index(native_node)
       if idx
-        @nodes.delete_at(idx)
-        @wrapped.delete_at(idx)
+        native_nodes.delete_at(idx)
+        wrapped_buffer.delete_at(idx) if @wrapped
       else
-        @nodes.delete(native_node)
+        native_nodes.delete(native_node)
       end
       self
     end
 
     private
 
+    # Allocated on first wrapped access — .size/.empty? consumers of
+    # large result sets never pay for the slot array.
+    def wrapped_buffer
+      return @wrapped unless @wrapped.nil?
+
+      @wrapped = Array.new(native_size)
+    end
+
+    def native_size
+      @nodes ? @nodes.size : @lazy.length
+    end
+
     def wrap_with_parent(native_node)
       wrapped = Moxml::Node.wrap(native_node, @context)
       if @parent_node && wrapped

data/lib/moxml/sax/block_handler.rb

@@ -139,24 +139,28 @@ module Moxml
         @handlers[:start_document]&.call
       end
 
+      # The per-event hash lookup fires for every node in the
+      # document; the DSL is fixed after construction, so the
+      # resolved block memoizes into an ivar on first fire (nil
+      # short-circuits the same way &. does).
       # @private
       def on_end_document
-        @handlers[:end_document]&.call
+        (@end_document_block ||= @handlers[:end_document])&.call
       end
 
       # @private
       def on_start_element(name, attributes = {}, namespaces = {})
-        @handlers[:start_element]&.call(name, attributes, namespaces)
+        (@start_element_block ||= @handlers[:start_element])&.call(name, attributes, namespaces)
       end
 
       # @private
       def on_end_element(name)
-        @handlers[:end_element]&.call(name)
+        (@end_element_block ||= @handlers[:end_element])&.call(name)
       end
 
       # @private
       def on_characters(text)
-        @handlers[:characters]&.call(text)
+        (@characters_block ||= @handlers[:characters])&.call(text)
       end
 
       # @private

data/lib/moxml/sax/namespace_splitter.rb

@@ -12,22 +12,31 @@ module Moxml
       # @yieldparam value [Object] raw attribute/namespace value
       # @yieldreturn [Object] transformed value to store
       # @return [Array(Hash, Hash)] [regular_attrs, namespaces]
+      # Shared for the overwhelmingly common no-declaration element:
+      # one Hash allocation per start_element event saved. Frozen —
+      # event hashes are read-only data, not scratch.
+      EMPTY_NAMESPACES = {}.freeze
+
       def split_attributes_and_namespaces(attributes)
         attrs = {}
-        ns = {}
+        ns = nil
 
         each_attribute(attributes) do |name, value|
           name_s = name.to_s
-          v = block_given? ? yield(value) : value
-          if name_s == "xmlns" || name_s.start_with?("xmlns:")
-            prefix = name_s == "xmlns" ? nil : name_s.sub("xmlns:", "")
-            ns[prefix] = v
+          if name_s.start_with?("xmlns")
+            if name_s == "xmlns"
+              (ns ||= {})[nil] = block_given? ? yield(value) : value
+            elsif name_s.bytesize > 5 && name_s.getbyte(5) == 58 # ":"
+              (ns ||= {})[name_s[6..]] = block_given? ? yield(value) : value
+            else
+              attrs[name_s] = block_given? ? yield(value) : value
+            end
           else
-            attrs[name_s] = v
+            attrs[name_s] = block_given? ? yield(value) : value
           end
         end
 
-        [attrs, ns]
+        [attrs, ns || EMPTY_NAMESPACES]
       end
 
       private

data/lib/moxml/version.rb

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

data/lib/moxml/xml_utils.rb

@@ -42,8 +42,19 @@ module Moxml
       raise ValidationError, "XML comment cannot contain double hyphens (--)"
     end
 
+    # Real documents reuse a handful of distinct element names; the
+    # memo turns the per-create regex into a hash probe after the
+    # first sight of a name. Capped — hostile vocabularies fall back
+    # to the regex.
+    VALID_ELEMENT_NAMES = {}.compare_by_identity
+
     def validate_element_name(name)
-      return if name.is_a?(String) && name.match?(/^[a-zA-Z_][\w\-.:]*$/)
+      return if name.is_a?(String) && VALID_ELEMENT_NAMES.key?(name)
+
+      if name.is_a?(String) && name.match?(/^[a-zA-Z_][\w\-.:]*$/)
+        VALID_ELEMENT_NAMES[name] = true if VALID_ELEMENT_NAMES.size < 1024
+        return
+      end
 
       raise ValidationError, "Invalid XML element name: #{name}"
     end

data/lib/moxml.rb

@@ -68,6 +68,7 @@ module Moxml
   autoload :Context, "moxml/context"
   autoload :Node, "moxml/node"
   autoload :NodeSet, "moxml/node_set"
+  autoload :LazyNodeSet, "moxml/lazy_node_set"
   autoload :Document, "moxml/document"
   autoload :Element, "moxml/element"
   autoload :Text, "moxml/text"

data/spec/moxml/adapter/leptris_spec.rb

@@ -52,10 +52,15 @@ RSpec.describe Moxml::Adapter::Leptris do
       expect(doc.xpath("//item[@p:kind='a']").map { |n| n["id"] }).to eq(["1"])
     end
 
-    it "falls back to the Ruby engine for attribute-node results" do
+    it "evaluates attribute-node queries with proper wrappers" do
+      # Native since 1.9.105 (leptris-ruby#153: ResultAttr with
+      # name/value); earlier bindings returned generic nodes whose
+      # #name raised, so the Ruby engine owned them.
+      skip "requires native attr results (leptris 1.9.105+)" unless described_class::ATTR_RESULT_NATIVE
       attrs = doc.xpath("//item/@id")
       expect(attrs.map(&:name)).to eq(%w[id id])
       expect(attrs.map(&:value)).to eq(%w[1 2])
+      expect(attrs.first).to be_a(Moxml::Attribute)
     end
 
     it "evaluates element-context queries on the native engine" do
@@ -314,6 +319,216 @@ RSpec.describe Moxml::Adapter::Leptris do
     end
   end
 
+  describe "HTML parsing (leptris/leptris#659)" do
+    before do
+      skip "requires leptris 1.9.80+ (HTML engine mode)" unless described_class::HTML_PARSE_SUPPORTED
+    end
+
+    let(:ctx) { Moxml.new(:leptris) }
+
+    it "synthesizes the html/body structure with lowercased names" do
+      doc = ctx.parse_html(%(<DIV CLASS="x">t</DIV>))
+      expect(doc.root.name).to eq("html")
+      body = doc.root.children.find(&:element?)
+      expect(body.name).to eq("body")
+      div = body.at_xpath(".//div")
+      expect(div["class"]).to eq("x")
+      expect(div.text).to eq("t")
+    end
+
+    it "implies end tags for list items" do
+      doc = ctx.parse_html(%(<ul><li>one<li>two</ul>))
+      expect(doc.xpath("//li").map(&:text)).to eq(%w[one two])
+    end
+
+    it "keeps void elements as empty elements" do
+      doc = ctx.parse_html(%(<br><img src="x.png">))
+      expect(doc.xpath("//br").size).to eq(1)
+      expect(doc.xpath("//img").first["src"]).to eq("x.png")
+    end
+
+    it "decodes HTML named entities into text" do
+      doc = ctx.parse_html(%(<p>caf&eacute; &nbsp;&copy;</p>))
+      expect(doc.at_xpath("//p").text).to eq("caf\u00e9 \u00a0\u00a9")
+    end
+
+    it "materializes boolean attributes" do
+      doc = ctx.parse_html(%(<a href="/x" disabled>t</a>))
+      link = doc.at_xpath("//a")
+      expect(link["href"]).to eq("/x")
+      expect(link["disabled"]).to eq("")
+    end
+
+    it "reads script content as raw text" do
+      doc = ctx.parse_html(%(<script>if (a < b) { x("</div>"); }</script>))
+      expect(doc.at_xpath("//script").text).to include("a < b")
+      expect(doc.at_xpath("//script").text).to include("</div>")
+    end
+
+    it "serializes to well-formed XML that reparses strictly" do
+      doc = ctx.parse_html(%(<p>a &amp; b < c</p><script>y = "</q>";</script>))
+      out = doc.to_xml
+      expect(out).to include("&lt;")
+      reparsed = Nokogiri::XML(out, &:strict)
+      expect(reparsed).to be_a(Nokogiri::XML::Document)
+      expect(reparsed.errors).to be_empty
+    end
+
+    it "round-trips a parsed tree through mutation" do
+      doc = ctx.parse_html(%(<ul><li>a<li>b</ul>))
+      doc.at_xpath("//ul").add_child(doc.create_element("li"))
+      expect(doc.xpath("//li").map(&:name)).to eq(%w[li li li])
+    end
+  end
+
+  describe "iterparse streaming" do
+    let(:ctx) { Moxml.new(:leptris) }
+    let(:xml) do
+      %(<catalog>#{Array.new(3) { |i| %(<record id="r#{i}"><field name="f">v#{i} &amp; x</field></record>) }.join}</catalog>)
+    end
+
+    it "yields completed top-level children with readable attributes" do
+      seen = []
+      ctx.iterparse(xml) { |e| seen << [e.name, e["id"]] }
+      expect(seen).to eq([["record", "r0"], ["record", "r1"], ["record", "r2"]])
+    end
+
+    it "full_document yields every element in completion order" do
+      seen = []
+      ctx.iterparse(xml, mode: :full_document) { |e| seen << e.name }
+      expect(seen).to eq(%w[field record field record field record catalog])
+    end
+
+    it "reads children, text, and serializes inside the block" do
+      outs = []
+      ctx.iterparse(xml) do |e|
+        outs << [e.children.first["name"], e.children.first.text,
+                 Nokogiri::XML(e.to_xml, &:strict).root["id"]]
+      end
+      expect(outs.map(&:first)).to all(eq("f"))
+      expect(outs.map { |row| row[1] }).to all(match(/v\d & x/))
+      expect(outs.map { |row| row[2] }).to eq(%w[r0 r1 r2])
+    end
+
+    it "streams from a file" do
+      require "tmpdir"
+      Dir.mktmpdir do |dir|
+        path = File.join(dir, "doc.xml")
+        File.write(path, xml)
+        seen = []
+        ctx.iterparse_file(path) { |e| seen << e["id"] }
+        expect(seen).to eq(%w[r0 r1 r2])
+      end
+    end
+
+    it "answers subqueries on yielded elements via the Ruby engine" do
+      # Parentless elements have no document handle for the compiled
+      # native eval — the gate must route them, not crash.
+      seen = []
+      ctx.iterparse(xml) do |e|
+        seen << [e.at_xpath(".//field")["name"], e.xpath("count(.//field)")]
+      end
+      expect(seen).to eq([["f", 1.0]] * 3)
+    end
+
+    it "requires a block" do
+      expect { ctx.iterparse(xml) }.to raise_error(ArgumentError, /block/)
+    end
+  end
+
+  describe "C14n native delegation" do
+    it "matches the Ruby reference byte-for-byte on the default path" do
+      # Whether the NATIVE_C14N_BYTE_SAFE probe is armed (fixed
+      # engine builds delegate to the C canonicalizer) or not, the
+      # default-path output must equal the Ruby reference — this is
+      # the safety net that lets the probe auto-adopt future builds.
+      xml = %(<?xml version="1.0"?><doc xmlns:p="urn:p" xmlns="urn:d" b="2" a="1"><e p:x="v" z="w">t &amp; u</e><!-- c --></doc>)
+      ctx = Moxml.new(:leptris)
+      root = ctx.parse(xml).root
+      expect(Moxml::C14n.canonicalize(root))
+        .to eq(Moxml::C14n::Inclusive10.new.canonicalize(root))
+    end
+  end
+
+  describe "wrapper lifecycle" do
+    it "releases wrappers when documents are dropped (WeakMap registry)" do
+      # The identity map must hold wrappers weakly: parse-and-drop
+      # workloads otherwise pin wrappers, natives, and (via the
+      # binding finalizer never running) the C subtrees.
+      xml = %(<r>#{Array.new(50) { |i| "<e id=\"i#{i}\">x</e>" }.join}</r>)
+      ctx = Moxml.new(:leptris)
+      count = -> {
+        n = 0
+        ObjectSpace.each_object(Moxml::Element) { n += 1 }
+        n
+      }
+      walk = ->(doc) { doc.root.children.to_a }
+
+      GC.start
+      before = count.call
+      20.times do
+        doc = ctx.parse(xml)
+        walk.(doc)
+        nil
+      end
+      5.times { GC.start }
+
+      # The binding retains a constant one-document wrapper set of
+      # its own; moxml must not retain beyond a couple of dropped
+      # documents' worth (was: all 20 pinned under the strong map).
+      expect(count.call - before).to be < 2 * 51
+    end
+
+    it "keeps wrapper identity while a document is alive" do
+      ctx = Moxml.new(:leptris)
+      doc = ctx.parse(%(<r><a/></r>))
+      expect(doc.root.children.first).to equal(doc.root.children.first)
+      GC.start
+      expect(doc.root.children.first).to equal(doc.root.children.first)
+    end
+  end
+
+  describe "lazy xpath result sets" do
+    let(:ctx) { Moxml.new(:leptris) }
+    let(:doc) do
+      ctx.parse(%(<r>#{Array.new(50) { |i| "<li>#{i}</li>" }.join}</r>))
+    end
+
+    it "answers size, first, and indexing without materializing" do
+      set = doc.xpath("//li")
+      expect(set.size).to eq(50)
+      expect(set.first.text).to eq("0")
+      expect(set[10].text).to eq("10")
+      expect(set[-1].text).to eq("49")
+      expect(set.empty?).to be(false)
+    end
+
+    it "enumerates and wraps on demand" do
+      expect(doc.xpath("//li").each.to_a.size).to eq(50)
+      expect(doc.xpath("//li").to_a.map(&:name).uniq).to eq(%w[li])
+    end
+
+    it "keeps the mutating set operations working" do
+      set = doc.xpath("//li")
+      expect((set + set).size).to eq(100)
+      expect(set.uniq_by_native.size).to eq(50)
+      set << doc.create_element("li")
+      expect(set.size).to eq(51)
+      expect(set.last.name).to eq("li")
+    end
+
+    it "slices ranges" do
+      expect(doc.xpath("//li")[0..2].size).to eq(3)
+      expect(doc.xpath("//li")[5...8].map(&:text)).to eq(%w[5 6 7])
+    end
+
+    it "returns scalars and at_xpath firsts unwrapped-set" do
+      expect(doc.xpath("count(//li)")).to eq(50.0)
+      expect(doc.at_xpath("//li").text).to eq("0")
+      expect(doc.at_xpath("//nope")).to be_nil
+    end
+  end
+
   describe "DTD ATTLIST defaults" do
     # libleptris 1.9.8: plain parse excludes ATTLIST defaults,
     # matching libxml2/Nokogiri/REXML; dtdattr: true opts in.

data/spec/moxml/adapter/nokogiri_spec.rb

@@ -12,6 +12,23 @@ RSpec.describe Moxml::Adapter::Nokogiri do
 
   it_behaves_like "xml adapter"
 
+  describe "HTML parsing" do
+    let(:ctx) { Moxml.new(:nokogiri) }
+
+    it "synthesizes the html/body structure with lowercased names" do
+      doc = ctx.parse_html(%(<DIV CLASS="x">t</DIV>))
+      expect(doc.root.name).to eq("html")
+      body = doc.root.children.find(&:element?)
+      expect(body.name).to eq("body")
+      expect(body.at_xpath(".//div")["class"]).to eq("x")
+    end
+
+    it "implies end tags and decodes HTML entities" do
+      doc = ctx.parse_html(%(<ul><li>caf&eacute;</ul>))
+      expect(doc.xpath("//li").map(&:text)).to eq(["caf\u00e9"])
+    end
+  end
+
   describe "recover-mode error channel" do
     it "exposes recoverable syntax errors as parse_errors" do
       doc = Moxml.new(:nokogiri).parse("<root><unclosed>", strict: false)

data/spec/moxml/context_spec.rb

@@ -13,6 +13,19 @@ RSpec.describe Moxml::Context do
     end
   end
 
+  describe "#parse_html" do
+    it "delegates to the adapter's HTML mode" do
+      ctx = Moxml.new(:nokogiri)
+      doc = ctx.parse_html(%(<p>x</p>))
+      expect(doc.root.name).to eq("html")
+    end
+
+    it "raises Moxml::AdapterError on adapters without an HTML mode" do
+      ctx = Moxml.new(:ox)
+      expect { ctx.parse_html(%(<p>x</p>)) }.to raise_error(Moxml::AdapterError, /not supported/)
+    end
+  end
+
   describe "#config" do
     it "has a configuration" do
       expect(context.config).to be_a(Moxml::Config)

data/spec/moxml/element_spec.rb

@@ -140,4 +140,29 @@ RSpec.describe Moxml::Element do
       end
     end
   end
+
+  describe "#append_xml" do
+    it "appends a fragment's top-level nodes with entities round-tripped" do
+      %w[leptris nokogiri oga rexml].each do |adapter|
+        ctx = Moxml.new(adapter.to_sym)
+        doc = ctx.parse(%(<root/>))
+        result = doc.root.append_xml(%(<a x="1">t1 &amp; u</a><b/>tail))
+        expect(result).to equal(doc.root)
+        out = doc.to_xml
+        expect(out).to include(%(<a x="1">t1 &amp; u</a>))
+        expect(out).to include("<b></b>")
+        expect(out).to include("tail")
+      end
+    end
+
+    it "raises AdapterError on the ox adapter" do
+      doc = Moxml.new(:ox).parse(%(<root/>))
+      expect { doc.root.append_xml(%(<a/>)) }.to raise_error(Moxml::AdapterError, /Ox/)
+    end
+
+    it "raises ParseError for non-well-formed fragments" do
+      doc = Moxml.new(:leptris).parse(%(<root/>))
+      expect { doc.root.append_xml(%(<a><b></a>)) }.to raise_error(Moxml::ParseError)
+    end
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: moxml
 version: !ruby/object:Gem::Version
-  version: 0.5.30
+  version: 0.5.31
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-09-04 00:00:00.000000000 Z
+date: 2026-09-12 00:00:00.000000000 Z
 dependencies: []
 description: |
   Moxml is a unified XML manipulation library that provides a common API
@@ -205,6 +205,7 @@ files:
 - lib/moxml/entity_registry.rb
 - lib/moxml/entity_registry_opal_data.rb
 - lib/moxml/error.rb
+- lib/moxml/lazy_node_set.rb
 - lib/moxml/materializer.rb
 - lib/moxml/namespace.rb
 - lib/moxml/native_attachment.rb