leptris 1.9.3 → 1.9.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c3e961e97c5ce359508474f70efda320521debdd4eb5e851241a82a49ffe7512
-  data.tar.gz: 8fd855b22026aacac080e734658e115826b45e59dcbfee6bb01a0e2b024a8cd1
+  metadata.gz: 996051e28883434c5ac9cf2041278a37a0ebc3ad628685838e6b743cc87e0b9d
+  data.tar.gz: 3909cce576ad3ce14fa65c4058997476ddd814ea9f819e00e0b4bbb969bd09cf
 SHA512:
-  metadata.gz: b1e58c09914cc12d9541410e1e5e46ff1c7135646bed22a46c6f796e41444ebdb0d039d1eabc1a5dc6790c6bcf2c3e1e31ae8fa6d8a33e25005138c5c0889fef
-  data.tar.gz: 42acbecab9c56654468540fa1cf7cda8dd666023a0d40b8f298ef2e18691d50e1e577393a0fb8bee36db27b743cdddf349db745e3b9c1bbb817d0a8681687a78
+  metadata.gz: 61f73189528f9c0ffaff803328304baa44af1e545d6618d252ff8e46b5279a229fb204df807815a22a360bffbf107a0c32e1a33f5110cb699ae8135e06d2777e
+  data.tar.gz: 4b5b197e569e23820b74b1596b3a8f8bf2feefba09af9858bb830cbcd6339d59c196e71177760ab35eb7daeac30bd5c3edb2b384d1ff43fc56726b838bfe0f0a

data/CHANGELOG.md

@@ -5,6 +5,62 @@ All notable changes to Leptris will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [1.9.5] - 2026-08-26
+
+### Fixed
+
+- **Borrowed handles validate their lender**: every c_ptr-
+  dereferencing read and mutation on Node/Element/Text/Comment/
+  CDATA/PI raises `Leptris::XML::UseAfterFreeError` once the owning
+  document has been freed (previously `doc.free; node.name` read
+  freed memory silently — verified returning `""` — and stale
+  mutations risked segfaults; only Document's own methods checked).
+  Memoized readonly results stay check-free. `Document#freed?` is
+  the single state predicate.
+
+### Added
+
+- **`benchmark/read_paths.rb`**: the committed read-path harness
+  (readonly loops, SAX, NodeSet unions, css, parse-query-serialize)
+  with a README methodology note — review-round benchmarks are now
+  reproducible from the repo.
+
+### Changed
+
+- The published gem no longer ships dev tooling (`benchmark/`,
+  `.rspec`, `.rubocop.yml`); it carries lib, gemspec, Rakefile, and
+  documentation only.
+
+## [1.9.4] - 2026-08-25
+
+### Fixed
+
+- **SAX callback strings arrive UTF-8**: element names, comments,
+  CDATA, PI target/data, prefix mappings, and error messages now
+  cross the seam as UTF-8 (previously ASCII-8BIT — only `characters`
+  was corrected). Non-ASCII SAX content no longer leaks BINARY into
+  handler code.
+
+### Changed
+
+- **NodeSet#xpath de-churn**: search arguments parse once (not per
+  member), results accumulate into one plain array, and a single
+  NodeSet is constructed at the end — the per-member
+  `merge_node_sets` (two `to_a`s + a throwaway NodeSet per element)
+  is gone. ~16% on a 500-member union query. Batch-context eval
+  asked upstream (leptris/leptris#560).
+- **SAX handler struct memoized** per handler; `Parser#document=`
+  invalidates it, so swapping the handler takes effect on the next
+  parse (previously the wiring was rebuilt per parse and the
+  struct ↔ handler coupling was only implied).
+- **XPath variable bindings now raise ArgumentError** instead of
+  being silently ignored (no var-bound eval path exists; wire the
+  real thing when a use case arrives). A single trailing hash
+  remains the namespace hash (Nokogiri semantics).
+- Failed XPath evaluations raise `XPathError` with the engine's
+  last-error detail from both the ad-hoc and compiled paths
+  (previously the ad-hoc path used the generic status string).
+
 ## [1.9.3] - 2026-08-25
 
 ### Fixed

data/README.adoc

@@ -411,6 +411,17 @@ Notable differences:
 
 == Performance
 
+=== Internal read-path harness
+
+`benchmark/read_paths.rb` measures the binding's own hot paths
+(readonly read loops, SAX, NodeSet unions, css, parse-query-
+serialize). Machine-relative — compare before/after runs on the same
+machine:
+
+    bundle exec ruby benchmark/read_paths.rb
+
+=== Full-field comparison
+
 Measured with metanorma/serialbench (Ruby 3.4.8, leptris 1.6.0,
 libleptris 1.6.0, macOS arm64) — Leptris vs the full field:
 

data/leptris.gemspec

@@ -28,7 +28,8 @@ Gem::Specification.new do |spec|
   spec.files = Dir.chdir(__dir__) do
     `git ls-files -z`.split("\x0").reject do |f|
       (File.expand_path(f) == __FILE__) ||
-        f.start_with?(*%w[bin/ test/ spec/ features/ .git .github appveyor Gemfile])
+        f.start_with?(*%w[bin/ test/ spec/ features/ benchmark/ .git .github
+                         appveyor Gemfile .rspec .rubocop.yml])
     end
   end
   spec.bindir = "bin"

data/lib/leptris/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Leptris
-  VERSION = "1.9.3"
+  VERSION = "1.9.5"
 end

data/lib/leptris/xml/cdata.rb

@@ -5,6 +5,7 @@ class Leptris::XML::CDATA < Leptris::XML::Text
 
   def content
     return @content if readonly_cached?(:@content)
+    ensure_alive!
     Leptris::XML::FFI.leptris_cdata_node_get_content(@c_ptr).tap do |text|
       @content = text if @document&.readonly?
     end

data/lib/leptris/xml/comment.rb

@@ -5,6 +5,7 @@ class Leptris::XML::Comment < Leptris::XML::Node
 
   def content
     return @content if readonly_cached?(:@content)
+    ensure_alive!
     Leptris::XML::FFI.leptris_comment_node_get_content(@c_ptr).tap do |text|
       @content = text if @document&.readonly?
     end

data/lib/leptris/xml/document.rb

@@ -281,6 +281,12 @@ class Leptris::XML::Document
     @readonly == true
   end
 
+  # True once #free has run (or the GC finalizer fired) — borrowed
+  # handles check this before dereferencing their c_ptr.
+  def freed?
+    @freed.state == :freed || @c_ptr.nil?
+  end
+
   # The most recent error recorded against this document, or nil.
   def last_error
     msg = Leptris::XML::FFI.leptris_document_last_error(@c_ptr)

data/lib/leptris/xml/element.rb

@@ -2,7 +2,9 @@
 
 class Leptris::XML::Element < Leptris::XML::Node
   def name
-    @name ||= Leptris::XML::FFI.leptris_element_name(@c_ptr)
+    return @name if @name
+    ensure_alive!
+    @name = Leptris::XML::FFI.leptris_element_name(@c_ptr)
   end
   alias_method :node_name, :name
 
@@ -16,6 +18,7 @@ class Leptris::XML::Element < Leptris::XML::Node
 
   def content
     return @content if readonly_cached?(:@content)
+    ensure_alive!
     Leptris::XML::FFI.leptris_element_text(@c_ptr).tap do |text|
       @content = text if @document&.readonly?
     end
@@ -29,6 +32,7 @@ class Leptris::XML::Element < Leptris::XML::Node
   end
 
   def [](key)
+    ensure_alive!
     Leptris::XML::FFI.leptris_element_attribute(@c_ptr, key.to_s)
   end
   alias_method :attr, :[]
@@ -43,6 +47,7 @@ class Leptris::XML::Element < Leptris::XML::Node
   alias_method :set_attribute, :[]=
 
   def key?(name)
+    ensure_alive!
     Leptris::XML::FFI.leptris_element_has_attribute(@c_ptr, name.to_s) != 0
   end
   alias_method :has_attribute?, :key?
@@ -53,11 +58,13 @@ class Leptris::XML::Element < Leptris::XML::Node
   # in-scope declarations. uri nil/"" matches no-namespace
   # attributes only; xmlns declarations are invisible.
   def attribute_ns(uri, local)
+    ensure_alive!
     Leptris::XML::FFI.leptris_element_attribute_ns(
       @c_ptr, uri&.to_s, local.to_s)
   end
 
   def has_attribute_ns?(uri, local)
+    ensure_alive!
     Leptris::XML::FFI.leptris_element_has_attribute_ns(
       @c_ptr, uri&.to_s, local.to_s) != 0
   end
@@ -77,6 +84,7 @@ class Leptris::XML::Element < Leptris::XML::Node
   # per-attribute namespace accessors (libleptris 1.8.0).
   def each_attribute
     return enum_for(:each_attribute) unless block_given?
+    ensure_alive!
     attr = Leptris::XML::FFI.leptris_element_first_attribute(@c_ptr)
     until attr.nil? || attr.null?
       name = Leptris::XML::FFI.leptris_attribute_get_name(attr)
@@ -119,6 +127,7 @@ class Leptris::XML::Element < Leptris::XML::Node
   # The element's own namespace prefix (e.g. "foo" for <foo:child/>),
   # or nil when the element has none.
   def prefix
+    ensure_alive!
     Leptris::XML::FFI.leptris_element_prefix(@c_ptr)
   end
 
@@ -231,6 +240,7 @@ class Leptris::XML::Element < Leptris::XML::Node
 
   def namespace
     return @namespace if readonly_cached?(:@namespace)
+    ensure_alive!
     uri = Leptris::XML::FFI.leptris_element_namespace(@c_ptr)
     result =
       if uri.nil? || uri.empty?
@@ -249,6 +259,7 @@ class Leptris::XML::Element < Leptris::XML::Node
 
   def namespace_definitions
     return @namespace_definitions if readonly_cached?(:@namespace_definitions)
+    ensure_alive!
     count = Leptris::XML::FFI.leptris_element_namespace_count(@c_ptr)
     result = count.times.map do |i|
       prefix = Leptris::XML::FFI.leptris_element_namespace_decl_prefix(@c_ptr, i)

data/lib/leptris/xml/iterparse.rb

@@ -18,6 +18,9 @@ require "ffi"
 # Document; #document returns nil and they must not outlive the
 # iteration.
 class Leptris::XML::Iterparse
+  # NOTE: an IO argument is read fully into memory before the C
+  # iterator starts — the bounded-memory path is parse_file (C-side
+  # file streaming). The C API takes one (xml, len) buffer.
   def self.parse(xml_or_io, &block)
     xml = xml_or_io.respond_to?(:read) ? xml_or_io.read : xml_or_io.to_s
     iterator = new(Leptris::XML::FFI.leptris_iterparse_new(xml, xml.bytesize))

data/lib/leptris/xml/node.rb

@@ -62,7 +62,9 @@ class Leptris::XML::Node
   end
 
   def type
-    @node_type ||= Leptris::XML::FFI.leptris_node_get_type(@c_ptr)
+    return @node_type if @node_type
+    ensure_alive!
+    @node_type = Leptris::XML::FFI.leptris_node_get_type(@c_ptr)
   end
   alias_method :node_type, :type
 
@@ -77,13 +79,26 @@ class Leptris::XML::Node
 
   def parent
     return @parent if @parent
+    ensure_alive!
     ptr = Leptris::XML::FFI.leptris_node_parent(@c_ptr)
     return nil if ptr.null?
     Leptris::XML::Node.wrap(ptr, @document)
   end
 
-  # Raises ReadOnlyError when the owning document was marked readonly.
+  # Borrowed-handle lifetime: every c_ptr dereference is valid only
+  # while the owning document lives. Parentless nodes (iterparse
+  # yields) cannot validate and are skipped.
+  def ensure_alive!
+    if @document&.freed?
+      raise Leptris::XML::UseAfterFreeError,
+        "owning document has been freed — handle used on #{inspect}"
+    end
+  end
+
+  # Raises ReadOnlyError when the owning document was marked readonly,
+  # UseAfterFreeError when it was freed.
   def ensure_writable!
+    ensure_alive!
     if @document&.readonly?
       raise Leptris::XML::ReadOnlyError,
         "document is readonly — mutation attempted on #{inspect}"
@@ -91,16 +106,19 @@ class Leptris::XML::Node
   end
 
   def line
+    ensure_alive!
     Leptris::XML::FFI.leptris_node_line(@c_ptr)
   end
 
   def <=>(other)
     return nil unless other.is_a?(Leptris::XML::Node)
     return nil unless @document == other.document
+    ensure_alive!
     Leptris::XML::FFI.leptris_node_compare(@c_ptr, other.c_ptr)
   end
 
   def child
+    ensure_alive!
     ptr = Leptris::XML::FFI.leptris_node_first_child(@c_ptr)
     return nil if ptr.null?
     Leptris::XML::Node.wrap(ptr, @document, parent: as_element_or_self)
@@ -110,6 +128,7 @@ class Leptris::XML::Node
     # Immutable in readonly mode: the batch fetch plus wrapper
     # construction is paid once.
     return @children if readonly_cached?(:@children)
+    ensure_alive!
     parent = as_element_or_self
     nodes = Leptris::XML::FFI.fetch_children(@c_ptr).map do |ptr|
       Leptris::XML::Node.wrap(ptr, @document, parent: parent)
@@ -120,6 +139,7 @@ class Leptris::XML::Node
   end
 
   def next_sibling
+    ensure_alive!
     ptr = Leptris::XML::FFI.leptris_node_next_sibling(@c_ptr)
     return nil if ptr.null?
     Leptris::XML::Node.wrap(ptr, @document, parent: @parent)
@@ -127,6 +147,7 @@ class Leptris::XML::Node
   alias_method :next, :next_sibling
 
   def previous_sibling
+    ensure_alive!
     ptr = Leptris::XML::FFI.leptris_node_previous_sibling(@c_ptr)
     return nil if ptr.null?
     Leptris::XML::Node.wrap(ptr, @document, parent: @parent)
@@ -134,6 +155,7 @@ class Leptris::XML::Node
   alias_method :previous, :previous_sibling
 
   def first_element_child
+    ensure_alive!
     ptr = Leptris::XML::FFI.leptris_node_first_child(@c_ptr)
     until ptr.nil? || ptr.null?
       node = Leptris::XML::Node.wrap(ptr, @document, parent: as_element_or_self)
@@ -189,6 +211,7 @@ class Leptris::XML::Node
   # callback (libleptris #273); the per-node FFI cost is the floor.
   def traverse
     return enum_for(:traverse) unless block_given?
+    ensure_alive!
     callback = ::FFI::Function.new(:int, [:pointer, :pointer], blocking: true) do |node_ptr, _|
       yield Leptris::XML::Node.wrap(node_ptr, @document)
       0
@@ -199,6 +222,7 @@ class Leptris::XML::Node
 
   def path
     return @path if readonly_cached?(:@path)
+    ensure_alive!
     str_ptr = Leptris::XML::FFI.leptris_node_get_xpath(@c_ptr)
     result = str_ptr.null? ? nil : Leptris::XML::FFI.read_owned_string(str_ptr)
     @path = result if @document&.readonly?
@@ -221,6 +245,7 @@ class Leptris::XML::Node
   end
 
   def dup
+    ensure_alive!
     elem_ptr = Leptris::XML::FFI.leptris_node_as_element(@c_ptr)
     raise Leptris::XML::Error, "dup is only supported for element nodes" if elem_ptr.null?
     copy_ptr = Leptris::XML::FFI.leptris_element_copy(elem_ptr, @document.c_ptr)

data/lib/leptris/xml/node_set.rb

@@ -117,29 +117,27 @@ class Leptris::XML::NodeSet
   end
   alias_method :text, :inner_text
 
+  # Union semantics: evaluate the expression against each element
+  # member (one C eval per member — the engine has no multi-context
+  # eval yet; leptris/leptris ask pending) and accumulate into ONE
+  # NodeSet, instead of merging NodeSets per member.
   def xpath(*paths)
     handler, _ns, _vars = parse_search_args(paths)
     raise ArgumentError, "custom XPath handlers not supported" if handler
     expr = paths.join(" | ")
-    accumulated = Leptris::XML::NodeSet.new(@document)
+    accumulated = []
     each do |node|
       next unless node.is_a?(Leptris::XML::Element)
       result_ptr = Leptris::XML::FFI.leptris_xpath_eval(
         @document.c_ptr, node.c_ptr, expr)
       next if result_ptr.null?
-      sub = Leptris::XML::NodeSet.send(:from_result, @document, result_ptr)
-      accumulated = merge_node_sets(accumulated, sub)
+      accumulated.concat(
+        Leptris::XML::NodeSet.from_result(@document, result_ptr).to_a)
     end
-    accumulated
+    Leptris::XML::NodeSet.new(@document, accumulated)
   end
 
   def inspect
     to_a.inspect
   end
-
-  private
-
-  def merge_node_sets(a, b)
-    Leptris::XML::NodeSet.new(@document, a.to_a + b.to_a)
-  end
 end

data/lib/leptris/xml/processing_instruction.rb

@@ -3,6 +3,7 @@
 class Leptris::XML::ProcessingInstruction < Leptris::XML::Node
   def name
     return @name if readonly_cached?(:@name)
+    ensure_alive!
     Leptris::XML::FFI.leptris_pi_node_get_target(@c_ptr).tap do |target|
       @name = target if @document&.readonly?
     end
@@ -11,6 +12,7 @@ class Leptris::XML::ProcessingInstruction < Leptris::XML::Node
 
   def content
     return @content if readonly_cached?(:@content)
+    ensure_alive!
     Leptris::XML::FFI.leptris_pi_node_get_data(@c_ptr).to_s.tap do |data|
       @content = data if @document&.readonly?
     end

data/lib/leptris/xml/sax/parser.rb

@@ -6,13 +6,27 @@ class Leptris::XML::SAX::Parser
   CHUNK_SIZE = 4096
   private_constant :CHUNK_SIZE
 
-  attr_accessor :document, :encoding
+  attr_reader :document, :encoding
 
   def initialize(handler = Leptris::XML::SAX::Document.new, encoding = nil)
     @document = handler
     @encoding = encoding
   end
 
+  # Swapping the handler invalidates the memoized callback struct so
+  # the next parse dispatches to the new handler.
+  def document=(handler)
+    @document = handler
+    @handler_struct = nil
+  end
+
+  # The handler struct (eleven FFI::Function callbacks + the C
+  # struct) is built once per handler and reused across parses; the
+  # memoized struct is anchored against GC by the instance itself.
+  def handler_struct
+    @handler_struct ||= build_handler_struct
+  end
+
   # Parse a string, IO, or file path. Dispatches to parse_memory /
   # parse_io / parse_file based on the argument type.
   def parse(input)
@@ -26,7 +40,7 @@ class Leptris::XML::SAX::Parser
 
   def parse_memory(string)
     string = string.dup.force_encoding("UTF-8")
-    handler_struct = build_handler_struct
+    handler_struct = self.handler_struct
     rc = Leptris::XML::FFI.leptris_sax_parse(
       string, string.bytesize, handler_struct.pointer, nil)
     if rc != 0
@@ -37,7 +51,7 @@ class Leptris::XML::SAX::Parser
   end
 
   def parse_io(io)
-    handler_struct = build_handler_struct
+    handler_struct = self.handler_struct
     parser_ptr = Leptris::XML::FFI.leptris_sax_parser_create(
       handler_struct.pointer, nil)
     if parser_ptr.null?
@@ -69,9 +83,7 @@ class Leptris::XML::SAX::Parser
   private
 
   # Build a LeptrisSAXHandler struct populated with FFI::Function callbacks
-  # that dispatch to the Ruby handler. The struct (and its callbacks) are
-  # anchored against GC via the local variable for the duration of the
-  # synchronous parse call.
+  # that dispatch to the Ruby handler.
   def build_handler_struct
     s = Leptris::XML::FFI::SAXHandler.new
     handler = @document  # capture in closures
@@ -86,39 +98,39 @@ class Leptris::XML::SAX::Parser
 
     s[:start_element] = callback(:void, [:pointer, :string, :pointer]) do |_, name, attrs_ptr|
       attrs = walk_attr_array(attrs_ptr)
-      handler.start_element(name, attrs)
+      handler.start_element(utf8(name), attrs)
     end
 
     s[:end_element] = callback(:void, [:pointer, :string]) do |_, name|
-      handler.end_element(name)
+      handler.end_element(utf8(name))
     end
 
     s[:characters] = callback(:void, [:pointer, :pointer, :size_t]) do |_, text_ptr, len|
-      handler.characters(text_ptr.read_bytes(len).force_encoding("UTF-8"))
+      handler.characters(text_ptr.read_bytes(len).force_encoding(Encoding::UTF_8))
     end
 
     s[:comment] = callback(:void, [:pointer, :string]) do |_, comment|
-      handler.comment(comment)
+      handler.comment(utf8(comment))
     end
 
     s[:cdata] = callback(:void, [:pointer, :string]) do |_, cdata|
-      handler.cdata_block(cdata)
+      handler.cdata_block(utf8(cdata))
     end
 
     s[:processing_instruction] = callback(:void, [:pointer, :string, :string]) do |_, target, data|
-      handler.processing_instruction(target, data)
+      handler.processing_instruction(utf8(target), utf8(data))
     end
 
     s[:start_prefix_mapping] = callback(:void, [:pointer, :string, :string]) do |_, prefix, uri|
-      handler.start_prefix_mapping(prefix, uri)
+      handler.start_prefix_mapping(utf8(prefix), utf8(uri))
     end
 
     s[:end_prefix_mapping] = callback(:void, [:pointer, :string]) do |_, prefix|
-      handler.end_prefix_mapping(prefix)
+      handler.end_prefix_mapping(utf8(prefix))
     end
 
     s[:error] = callback(:void, [:pointer, :string, :int, :int]) do |_, msg, line, col|
-      handler.error(msg, line, col)
+      handler.error(utf8(msg), line, col)
     end
 
     s
@@ -128,6 +140,13 @@ class Leptris::XML::SAX::Parser
     ::FFI::Function.new(return_type, params, blocking: blocking, &block)
   end
 
+  # FFI's implicit :string conversion does not set encoding — every
+  # callback string param crosses the seam as ASCII-8BIT unless
+  # corrected here (the headers contract UTF-8; nil for NULL).
+  def utf8(str)
+    str.nil? ? nil : str.force_encoding(Encoding::UTF_8)
+  end
+
   # The C `const char** attrs` is a NULL-terminated flat array of
   # name/value pairs; CStringArray owns the format, we slice into pairs.
   def walk_attr_array(attrs_ptr)

data/lib/leptris/xml/searchable.rb

@@ -17,7 +17,7 @@ module Leptris::XML::Searchable
       end
     if result_ptr.null?
       raise Leptris::XML::XPathError,
-        Leptris::XML::FFI.leptris_status_string(Leptris::XML::FFI::LEPTRIS_ERROR_XPATH)
+        Leptris::XML::FFI.leptris_last_error.to_s
     end
 
     Leptris::XML::Searchable.wrap_xpath_result(document, result_ptr)
@@ -72,6 +72,9 @@ module Leptris::XML::Searchable
       break if args.empty?
     end
     ns, vars = hashes.reverse
+    unless vars.nil? || vars.empty?
+      raise ArgumentError, "XPath variable bindings are not supported"
+    end
     [handler, ns, vars]
   end
 

data/lib/leptris/xml/text.rb

@@ -5,6 +5,7 @@ class Leptris::XML::Text < Leptris::XML::Node
 
   def content
     return @content if readonly_cached?(:@content)
+    ensure_alive!
     Leptris::XML::FFI.leptris_text_node_get_content(@c_ptr).tap do |text|
       @content = text if @document&.readonly?
     end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: leptris
 version: !ruby/object:Gem::Version
-  version: 1.9.3
+  version: 1.9.5
 platform: ruby
 authors:
 - Ribose Inc.
@@ -63,15 +63,11 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- ".rspec"
-- ".rubocop.yml"
 - CHANGELOG.md
 - CLAUDE.md
 - LICENSE.md
 - README.adoc
 - Rakefile
-- benchmark/README.md
-- benchmark/leptris_vs_nokogiri.rb
 - leptris.gemspec
 - lib/leptris.rb
 - lib/leptris/version.rb

data/.rspec

@@ -1,3 +0,0 @@
---format documentation
---color
---require spec_helper

data/.rubocop.yml

@@ -1,8 +0,0 @@
-AllCops:
-  TargetRubyVersion: 3.1
-
-Style/StringLiterals:
-  EnforcedStyle: double_quotes
-
-Style/StringLiteralsInInterpolation:
-  EnforcedStyle: double_quotes

data/benchmark/README.md

@@ -1,12 +0,0 @@
-# leptris vs the field
-
-The authoritative cross-library numbers live in the README's
-Performance section (measured with metanorma/serialbench).
-
-This local benchmark compares against Nokogiri only:
-
-    LEPTRIS_LIB_PATH=/path/to/libleptris.dylib bundle exec ruby benchmark/leptris_vs_nokogiri.rb
-
-For the full-field race (Ox, Nokogiri, Oga, REXML, Leptris), use
-https://github.com/metanorma/serialbench — leptris's adapter ships
-there under `lib/serialbench/serializers/xml/leptris_serializer.rb`.

data/benchmark/leptris_vs_nokogiri.rb

@@ -1,105 +0,0 @@
-# frozen_string_literal: true
-
-# Ruby-level performance comparison: Leptris::XML (FFI → libleptris v0.12.0)
-# vs Nokogiri (C extension → libxml2).
-#
-# Run with: bundle exec ruby -Ilib benchmark/leptris_vs_nokogiri.rb
-
-require "benchmark"
-require "leptris/xml"
-require "nokogiri"
-
-module Fixtures
-  SMALL = "<catalog>" +
-          (1..10).map { |i| "<book id='#{i}'><title>Book #{i}</title></book>" }.join +
-          "</catalog>"
-
-  MEDIUM = ("<catalog version='2.0'>" +
-            (1..100).map do |i|
-              "<book id='#{i}' lang='en'>" \
-              "<title>Book #{i}</title>" \
-              "<author id='a#{i}'>Author #{i}</author>" \
-              "<price currency='USD'>#{i}.99</price>" \
-              "</book>"
-            end.join +
-            "</catalog>").freeze
-end
-
-def time_it(label, n, &block)
-  GC.start
-  t0 = Process.clock_gettime(Process::CLOCK_MONOTONIC)
-  n.times { yield }
-  elapsed = Process.clock_gettime(Process::CLOCK_MONOTONIC) - t0
-  us_per_iter = (elapsed / n) * 1_000_000
-  printf "  %-40s %8.2f µs/iter  (%d iters in %.3fs)\n", label, us_per_iter, n, elapsed
-  us_per_iter
-end
-
-def ratio(label, leptris_us, nokogiri_us)
-  r = nokogiri_us / leptris_us
-  who = r > 1 ? "Leptris faster" : "Nokogiri faster"
-  printf "  → %-30s Leptris/Nokogiri = %.2fx (%s)\n\n", label, r, who
-end
-
-N_PARSE_SMALL = 5_000
-N_PARSE_MEDIUM = 1_000
-N_QUERY = 10_000
-N_TRAVERSE = 2_000
-N_SERIALIZE = 1_000
-
-puts "===== Parse — small (#{Fixtures::SMALL.bytesize} B) ====="
-t = time_it("leptris parse small", N_PARSE_SMALL) { d = Leptris::XML::Document.parse(Fixtures::SMALL); d.free }
-n = time_it("nokogiri parse small", N_PARSE_SMALL) { Nokogiri::XML(Fixtures::SMALL) }
-ratio("parse small", t, n)
-
-puts "===== Parse — medium (#{Fixtures::MEDIUM.bytesize} B) ====="
-t = time_it("leptris parse medium", N_PARSE_MEDIUM) { d = Leptris::XML::Document.parse(Fixtures::MEDIUM); d.free }
-n = time_it("nokogiri parse medium", N_PARSE_MEDIUM) { Nokogiri::XML(Fixtures::MEDIUM) }
-ratio("parse medium", t, n)
-
-# Pre-parse medium for query benchmarks
-doc_t = Leptris::XML::Document.parse(Fixtures::MEDIUM)
-doc_n = Nokogiri::XML(Fixtures::MEDIUM)
-
-puts "===== XPath — count(//book) ====="
-t = time_it("leptris xpath count()", N_QUERY) { doc_t.xpath("count(//book)") }
-n = time_it("nokogiri xpath count()", N_QUERY) { doc_n.xpath("count(//book)") }
-ratio("xpath count()", t, n)
-
-puts "===== XPath — //book (nodeset of 100) ====="
-t = time_it("leptris xpath //book", N_QUERY) { doc_t.xpath("//book") }
-n = time_it("nokogiri xpath //book", N_QUERY) { doc_n.xpath("//book") }
-ratio("xpath //book", t, n)
-
-puts "===== XPath — predicate //book[@id='50'] ====="
-t = time_it("leptris xpath predicate", N_QUERY) { doc_t.xpath("//book[@id='50']") }
-n = time_it("nokogiri xpath predicate", N_QUERY) { doc_n.xpath("//book[@id='50']") }
-ratio("xpath predicate", t, n)
-
-puts "===== XPath — complex //book[price > 50] ====="
-t = time_it("leptris xpath complex", N_QUERY) { doc_t.xpath("//book[price > 50]") }
-n = time_it("nokogiri xpath complex", N_QUERY) { doc_n.xpath("//book[price > 50]") }
-ratio("xpath complex", t, n)
-
-puts "===== XPath — union //author | //title ====="
-t = time_it("leptris xpath union", N_QUERY) { doc_t.xpath("//author | //title") }
-n = time_it("nokogiri xpath union", N_QUERY) { doc_n.xpath("//author | //title") }
-ratio("xpath union", t, n)
-
-puts "===== Tree traversal (root.traverse) ====="
-t = time_it("leptris traverse", N_TRAVERSE) { doc_t.root.traverse { |n| n.name } }
-n = time_it("nokogiri traverse", N_TRAVERSE) { doc_n.root.traverse { |n| n.name } }
-ratio("traverse", t, n)
-
-puts "===== Serialize — Document#to_xml ====="
-t = time_it("leptris serialize", N_SERIALIZE) { doc_t.to_xml }
-n = time_it("nokogiri serialize", N_SERIALIZE) { doc_n.to_xml }
-ratio("serialize", t, n)
-
-doc_t.free
-
-puts ""
-puts "libleptris v0.12.0 — all upstream issues closed."
-puts "All 176 Ruby specs passing, 0 pending."
-
-