leptris 1.9.3 → 1.9.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c3e961e97c5ce359508474f70efda320521debdd4eb5e851241a82a49ffe7512
-  data.tar.gz: 8fd855b22026aacac080e734658e115826b45e59dcbfee6bb01a0e2b024a8cd1
+  metadata.gz: 4bb5caf8a4c09cfd0ad16d3dc414d205e957ef1994875963bf5c4202666925cb
+  data.tar.gz: 65ff8352d6b7efc9bc7178605af80d6d336e6692b41826dcc6927b1e56d96478
 SHA512:
-  metadata.gz: b1e58c09914cc12d9541410e1e5e46ff1c7135646bed22a46c6f796e41444ebdb0d039d1eabc1a5dc6790c6bcf2c3e1e31ae8fa6d8a33e25005138c5c0889fef
-  data.tar.gz: 42acbecab9c56654468540fa1cf7cda8dd666023a0d40b8f298ef2e18691d50e1e577393a0fb8bee36db27b743cdddf349db745e3b9c1bbb817d0a8681687a78
+  metadata.gz: 027f61b41cb7a0b9270ca974ca82b0d227b02598f21f757aeebadc3d1158d8a8d7335a2657512756e3143b446222817520074d83071065520209714889085951
+  data.tar.gz: 93c71428856e7d460fce88242ab315f63f18382806f76ecd4f7cedcb5f87a55cbe3890ed2f9937dd0dbd0be0a38dbbc16e8900803dcf116112221d3cf517ed36

data/CHANGELOG.md

@@ -5,6 +5,36 @@ 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.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/lib/leptris/version.rb

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

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_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/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
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: leptris
 version: !ruby/object:Gem::Version
-  version: 1.9.3
+  version: 1.9.4
 platform: ruby
 authors:
 - Ribose Inc.