moxml 0.5.30 → 0.5.32

data/lib/moxml/lazy_node_set.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Moxml
+  # Marker for an adapter's native node-set result that NodeSet can
+  # hold without materializing the natives. The leptris binding's
+  # NodeSet mints one Ruby wrapper per result node in #to_a — the
+  # whole 900-node result set is built even when the caller only
+  # asks .size or .first — so the adapter hands the native set
+  # through instead. Contract: responds to length, empty?, [],
+  # each, to_a (yielding natives).
+  module LazyNodeSet
+    def size
+      length
+    end
+  end
+end

data/lib/moxml/native_attachment/native.rb

@@ -25,8 +25,13 @@ module Moxml
         @monitor = Monitor.new
       end
 
+      # Reads are lock-free: MRI Hash#[] is atomic under the GVL, and
+      # the only mid-write race (set assigns the inner hash before its
+      # key) resolves to a miss — the same answer as "not set yet",
+      # which every reader treats conservatively. This method sits on
+      # per-element hot paths (entity_bearing? on every serialize).
       def get(native, key)
-        @monitor.synchronize { @data[native.object_id]&.[](key) }
+        @data[native.object_id]&.[](key)
       end
 
       def set(native, key, value)
@@ -39,7 +44,8 @@ module Moxml
       end
 
       def key?(native, key)
-        @monitor.synchronize { @data[native.object_id]&.key?(key) || false }
+        h = @data[native.object_id]
+        !h.nil? && h.key?(key)
       end
 
       def delete(native, key)

data/lib/moxml/node.rb

@@ -35,6 +35,7 @@ module Moxml
     def clear_native_memo!
       @name = nil
       @attribute_cache = nil
+      @entity_bearing_gen = nil
     end
 
     def document
@@ -64,9 +65,12 @@ module Moxml
     def add_child(node)
       node = prepare_node(node)
       adapter.add_child(@native, node.native)
-      # Refresh native in case adapter changed identity (e.g., LibXML doc.root=)
-      refreshed = adapter.actual_native(node.native, @native)
-      node.refresh_native!(refreshed) if refreshed && refreshed != node.native
+      # Refresh native in case adapter changed identity (e.g., LibXML
+      # doc.root=); stable-identity adapters skip the round trip.
+      unless adapter.native_identity_stable?
+        refreshed = adapter.actual_native(node.native, @native)
+        node.refresh_native!(refreshed) if refreshed && refreshed != node.native
+      end
       node.parent_node = self
       # The adopted subtree's in-scope namespaces changed
       node.invalidate_namespace_cache!
@@ -113,23 +117,43 @@ module Moxml
       # Determine if we should include XML declaration
       # For Document nodes: check native then wrapper, unless explicitly overridden
       # For other nodes: default to no declaration unless explicitly set
-      serialize_options = default_options.merge(options)
-      serialize_options[:no_declaration] = !should_include_declaration?(options)
+      serialize_options = if options.empty? && !is_a?(Document)
+                            context.default_element_serialize_options
+                          else
+                            merged = context.default_serialize_options.merge(options)
+                            merged[:no_declaration] = !should_include_declaration?(options)
+                            merged
+                          end
 
       result = adapter.serialize(@native, serialize_options)
       result = apply_line_ending(result, serialize_options[:line_ending])
 
       # Restore entity markers to named entity references; skipped
       # when the adapter knows the document carries no markers.
-      result = adapter.restore_entities(result) if adapter.entity_bearing?(@native)
+      result = adapter.restore_entities(result) if entity_bearing?
       result
     end
 
+    # Memoized against the adapter's serialize generation — the
+    # entity-marker flag flips at parse and entity-reference mint,
+    # both adapter-level, and the generation bump is the invalidation
+    # signal. Adapters with static answers (base class) never bump.
+    def entity_bearing?
+      gen = adapter.serialize_generation
+      if @entity_bearing_gen == gen
+        @entity_bearing
+      else
+        @entity_bearing_gen = gen
+        @entity_bearing = adapter.entity_bearing?(@native)
+      end
+    end
+
     def xpath(expression, namespaces = {})
       result = adapter.xpath(@native, expression, namespaces)
-      # Adapter contract: Array<native> | scalar. Scalars (count(),
-      # string-length(), booleans) pass through unwrapped.
-      result.is_a?(Array) ? NodeSet.new(result, context) : result
+      # Adapter contract: Array<native> | LazyNodeSet | scalar.
+      # Scalars (count(), string-length(), booleans) pass through
+      # unwrapped; the set forms wrap lazily.
+      result.is_a?(Array) || result.is_a?(LazyNodeSet) ? NodeSet.new(result, context) : result
     end
 
     # Flattened post-order records for this subtree without
@@ -459,19 +483,6 @@ module Moxml
       end
     end
 
-    def default_options
-      {
-        encoding: context.config.default_encoding,
-        indent: context.config.default_indent,
-        line_ending: context.config.default_line_ending,
-        # The short format of empty tags in Oga and Nokogiri isn't configurable
-        # Oga: <empty /> (with a space)
-        # Nokogiri: <empty/> (without a space)
-        # The expanded format is enforced to avoid this conflict
-        expand_empty: true,
-      }
-    end
-
     def should_include_declaration?(options)
       return options[:declaration] if options.key?(:declaration)
       return options.fetch(:declaration, false) unless is_a?(Document)

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.32"
 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,247 @@ 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 "preserves foreign content (SVG/MathML) in HTML documents" do
+      doc = ctx.parse_html(%(<p>a</p><svg viewBox="0 0 1 1"><circle r="1"/></svg><math><mi>a</mi></math>))
+      body = doc.root.children.find(&:element?)
+      names = body.children.select(&:element?).map(&:name)
+      expect(names).to include("svg", "math")
+      expect(body.at_xpath(".//circle")["r"]).to eq("1")
+      expect(body.at_xpath(".//mi").text).to eq("a")
+    end
+
+    it "preserves foreignObject content Nokogiri drops (name lowercased)" do
+      # WHATWG keeps foreign-content camelCase (foreignObject,
+      # viewBox); the engine currently lowercases like it does HTML
+      # names, but preserves the subtree — Nokogiri drops it
+      # entirely. Pins current behavior; engine conformance note
+      # filed for the adjust-tables.
+      doc = ctx.parse_html(%(<svg><foreignObject><p>x</p></foreignObject></svg>))
+      out = doc.to_xml
+      expect(out).to include("<foreignobject>")
+      expect(out).to include("<p>x</p>")
+    end
+
+    it "round-trips an HTML doctype with external identifiers" do
+      doc = ctx.parse_html(%(<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01//EN" "x.dtd"><p>a</p>))
+      expect(doc.to_xml).to include(%(<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01//EN" "x.dtd">))
+    end
+
+    it "preserves template element placement" do
+      doc = ctx.parse_html(%(<div><template><p>t</p></template></div>))
+      expect(doc.at_xpath("//template/p")&.text).to eq("t")
+    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.