leptris 1.1.2 → 1.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 949fe73711448bd7857072004c75d6201b06829e9eb632124ae922a2fb7ff3f1
-  data.tar.gz: 259bbac7ce3e90389cce4f0e79dc979e7bc8ca844caa7745680ba352c010ba86
+  metadata.gz: e9d9e951ee8e7b15451e02933c6e5e80d6cb78fa970ff4411153ec1358c50ab1
+  data.tar.gz: 5aab53987963478c27bb0d9bfe96e804672dcc6b7da1842cc3422f9e0b91c235
 SHA512:
-  metadata.gz: cdab285d1fe462fcf7bc66681ebfbe1af74748ae99a8f0eebe1e502dfd72313b4429ac5943a18ebebd5706a308b135c33dfd7e8aab4bd313e383adcd91bb682f
-  data.tar.gz: 18240f20ed093b9e6434d0f9036ab93545b6af47237aa5ee72f616f3b10836148a3850fec5332fb2e44f416a53d25523d69f8bc4e4e1bb17c1f1181f16515f98
+  metadata.gz: 7de27428d6e469b405889481a78bdbe1680d28e4b8c4bd2041ccfb49dd3b9a620359f5d66a4bc4f4573e16c332916348cf4313bedbb1c5d1876cf08cb64b243e
+  data.tar.gz: c71f63da347773adfd341782dd10326ff5993c673080e63554013eed453137014f76f2b4a0474b9fa452c5009f573d4d65f01213822016e296735a0a1eea30e3

data/CHANGELOG.md

@@ -5,6 +5,56 @@ All notable changes to Leptris will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [1.2.1] - 2026-08-23
+
+Completes the libleptris 1.2.0 public surface in the binding.
+
+### Added
+
+- **Namespace-bound XPath**: `doc.xpath("//p:title", "p" => "urn:p")`
+  (Nokogiri parity) — expression prefixes now resolve to caller-supplied
+  URIs regardless of the prefixes the document declared, via
+  `leptris_xpath_ns_set_new/_add/_free` + `leptris_xpath_eval_ns`. The
+  binding set is built per call and freed under `ensure`. Previously
+  the trailing namespace hash was silently ignored.
+- `leptris_error_message` / `leptris_last_error` bound; the status seam
+  and parse errors now append the library's last-error detail when
+  present (best-effort: it is a library-global string).
+
+## [1.2.0] - 2026-08-23
+
+Lockstep with libleptris 1.2.0.
+
+### Added
+
+- `Leptris::XML::Document.create` — empty document with its own memory
+  pool (backs `leptris_document_create`); elements are created against
+  it via the factories and attached with `root=`.
+- `Document#root=` — attach an element as the document root
+  (`leptris_document_set_root`). Companion to the moxml Leptris
+  adapter (lutaml/moxml#96).
+- `Attr#to_xml` — serialized `name="value"` form with the five XML
+  special characters escaped.
+
+### Fixed
+
+- `Node#text` / `#inner_text` now dispatch to `#content` instead of
+  aliasing the base implementation — the alias snapshot meant subclass
+  overrides (`Text#content`, `Comment#content`, …) were never seen
+  through `text`.
+- `Element#namespace` carries the element's own prefix, so consumers
+  can distinguish `{"p" => "urn:p"}` from the default namespace.
+- CI/Rakefile pin libleptris v1.2.0, whose fixes resolve leptris#477
+  (mixed-nodeset kinds, `node_name`/`node_value` on non-element
+  entries, and `//node()` now including the context root). NodeSet
+  keeps its per-index fallback for the still-under-copying batch
+  accessor.
+
+### Unbound v1.2.0 surface (follow-up)
+
+Namespace-bound XPath (`leptris_xpath_ns_set_*`, `leptris_xpath_eval_ns`)
+and error introspection (`leptris_error_message`, `leptris_last_error`).
+
 ## [1.1.1] - 2026-08-22
 
 ### Added

data/Rakefile

@@ -8,7 +8,7 @@ RSpec::Core::RakeTask.new(:spec)
 # Pin for `rake compile` and the platform-gem builds. Keep in lockstep
 # with .github/workflows/build.yml (which calls `rake compile`) and the
 # CHANGELOG when libleptris releases.
-LIBLEPTRIS_VERSION = "1.1.1"
+LIBLEPTRIS_VERSION = "1.2.0"
 
 CMAKE_FLAGS = %w[
   -DCMAKE_BUILD_TYPE=Release

data/lib/leptris/version.rb

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

data/lib/leptris/xml/attr.rb

@@ -29,6 +29,17 @@ class Leptris::XML::Attr
   def to_s; @value; end
   def to_str; @value; end
 
+  # Serialized attribute form: name="value" with the five XML special
+  # characters escaped in the value.
+  def to_xml
+    escaped = @value.to_s.gsub("&", "&")
+                       .gsub("<", "&lt;")
+                       .gsub(">", "&gt;")
+                       .gsub('"', "&quot;")
+                       .gsub("'", "&apos;")
+    "#{@name}=\"#{escaped}\""
+  end
+
   def ==(other)
     other.is_a?(Leptris::XML::Attr) &&
       @name == other.name && @value == other.value &&

data/lib/leptris/xml/document.rb

@@ -50,7 +50,8 @@ class Leptris::XML::Document
     if raw.null?
       status = status_ptr.read_int
       raise Leptris::XML::ParseError,
-        "leptris_parse_string failed (status=#{status})"
+        "leptris_parse_string failed (status=#{status}): " +
+        Leptris::XML::FFI.status_message(status)
     end
     wrap(raw)
   end
@@ -66,6 +67,16 @@ class Leptris::XML::Document
     wrap(raw)
   end
 
+  # Create an empty document (no root element) backed by its own memory
+  # pool. Elements for the tree are created against it via
+  # #create_element and friends, then attached with #root=.
+  def self.create
+    raw = Leptris::XML::FFI.leptris_document_create
+    raise Leptris::XML::Error,
+      "leptris_document_create failed" if raw.null?
+    wrap(raw)
+  end
+
   # Convert a raw LeptrisDocument pointer into a Ruby Document with safe
   # GC lifetime management. The finalizer captures the raw address
   # integer (not the Document or Pointer object — those would prevent
@@ -107,6 +118,17 @@ class Leptris::XML::Document
     Leptris::XML::Node.wrap(ptr, self)
   end
 
+  # Attach +element+ as the document's root element. The element must
+  # have been created against this document and must not already have
+  # a parent. Any previous root is left detached (still owned by the
+  # document's pool until #free).
+  def root=(element)
+    raise Leptris::XML::UseAfterFreeError if @freed.state == :freed
+    Leptris::XML::FFI.check_status(
+      Leptris::XML::FFI.leptris_document_set_root(@c_ptr, element.c_ptr))
+    element
+  end
+
   def create_element(name)
     ptr = Leptris::XML::FFI.leptris_element_create(@c_ptr, name)
     raise Leptris::XML::Error, "leptris_element_create failed" if ptr.null?

data/lib/leptris/xml/element.rb

@@ -191,7 +191,12 @@ class Leptris::XML::Element < Leptris::XML::Node
   def namespace
     uri = Leptris::XML::FFI.leptris_element_namespace(@c_ptr)
     return nil if uri.nil? || uri.empty?
-    Leptris::XML::Namespace.new(self, uri)
+    # The resolved namespace is reached via this element's own prefix,
+    # so carry it through: consumers that distinguish
+    # {"p" => "urn:p"} from the default {"nil => "urn:p"} need it.
+    prefix = Leptris::XML::FFI.leptris_element_prefix(@c_ptr)
+    prefix = nil if prefix.nil? || prefix.empty?
+    Leptris::XML::Namespace.new(self, uri, prefix: prefix)
   end
 
   def namespace_definitions

data/lib/leptris/xml/ffi.rb

@@ -23,6 +23,7 @@ module Leptris
       typedef :pointer, :leptris_attribute
       typedef :pointer, :leptris_doctype
       typedef :pointer, :leptris_xpath_result
+      typedef :pointer, :leptris_xpath_ns_set
       typedef :pointer, :leptris_xpath_var_set
       typedef :pointer, :leptris_sax_parser
       typedef :int, :leptris_status
@@ -66,6 +67,10 @@ module Leptris
         [:string, :pointer], :pointer
       attach_function :leptris_document_free,
         [:leptris_document], :void
+      attach_function :leptris_document_create,
+        [], :leptris_document
+      attach_function :leptris_document_set_root,
+        [:leptris_document, :leptris_element], :leptris_status
       attach_function :leptris_document_root,
         [:leptris_document], :leptris_element
       attach_function :leptris_document_encoding,
@@ -361,6 +366,18 @@ module Leptris
       attach_function :leptris_xpath_variable_set_string,
         [:leptris_xpath_var_set, :string, :string], :leptris_status
 
+      # Namespace-bound XPath (v1.2.0): expression prefixes resolve to
+      # caller-supplied URIs regardless of the document's declarations.
+      attach_function :leptris_xpath_ns_set_new,
+        [], :leptris_xpath_ns_set
+      attach_function :leptris_xpath_ns_set_free,
+        [:leptris_xpath_ns_set], :void
+      attach_function :leptris_xpath_ns_set_add,
+        [:leptris_xpath_ns_set, :string, :string], :leptris_status
+      attach_function :leptris_xpath_eval_ns,
+        [:leptris_document, :leptris_element, :string, :leptris_xpath_ns_set],
+        :leptris_xpath_result
+
       attach_function :leptris_sax_parse,
         [:string, :size_t, :pointer, :pointer], :int
       attach_function :leptris_sax_parser_create,
@@ -415,6 +432,8 @@ module Leptris
       attach_function :leptris_document_set_allocators,
         [:leptris_document, :pointer, :pointer], :leptris_status
       attach_function :leptris_status_string, [:leptris_status], :string
+      attach_function :leptris_error_message, [:leptris_status], :string
+      attach_function :leptris_last_error, [], :string
 
       LEPTRIS_OK = 0
       LEPTRIS_ERROR_MEMORY = -1
@@ -463,13 +482,22 @@ module Leptris
         ptr.read_string.tap { leptris_free_string(ptr) }
       end
 
-      # Single status seam: turns a C status code into a Ruby error.
+      # Single status seam: turns a C status code into a Ruby error,
+      # appending the library's last-error detail when present. The
+      # detail is a library-global string, so it can only be treated
+      # as best-effort context.
       def self.check_status(status)
         unless status == LEPTRIS_OK
-          raise Leptris::XML::Error, leptris_status_string(status)
+          raise Leptris::XML::Error, status_message(status)
         end
         status
       end
+
+      def self.status_message(status)
+        base = leptris_status_string(status).to_s
+        detail = leptris_last_error.to_s
+        detail.empty? ? base : "#{base} (#{detail})"
+      end
     end
   end
 end

data/lib/leptris/xml/node.rb

@@ -45,8 +45,17 @@ class Leptris::XML::Node
   def content
     raise NotImplementedError, "#{self.class}#content not implemented"
   end
-  alias_method :text, :content
-  alias_method :inner_text, :content
+
+  # Dispatching defs, not alias_method: an alias snapshots this base
+  # #content (the raise), so subclass overrides would never be seen
+  # through the alias. A plain method resolves #content per-call.
+  def text
+    content
+  end
+
+  def inner_text
+    content
+  end
 
   def type
     Leptris::XML::FFI.leptris_node_get_type(@c_ptr)

data/lib/leptris/xml/searchable.rb

@@ -2,14 +2,19 @@
 
 module Leptris::XML::Searchable
   def xpath(*paths)
-    handler, _ns, _vars = parse_search_args(paths)
+    handler, ns, _vars = parse_search_args(paths)
     raise ArgumentError, "custom XPath handlers not supported" if handler
     expr = paths.join(" | ")
 
     doc_ptr = is_a?(Leptris::XML::Document) ? c_ptr : document.c_ptr
     context_ptr = is_a?(Leptris::XML::Document) ? nil : c_ptr
 
-    result_ptr = Leptris::XML::FFI.leptris_xpath_eval(doc_ptr, context_ptr, expr)
+    result_ptr =
+      if ns && !ns.empty?
+        xpath_eval_with_namespaces(doc_ptr, context_ptr, expr, ns)
+      else
+        Leptris::XML::FFI.leptris_xpath_eval(doc_ptr, context_ptr, expr)
+      end
     if result_ptr.null?
       raise Leptris::XML::XPathError,
         Leptris::XML::FFI.leptris_status_string(Leptris::XML::FFI::LEPTRIS_ERROR_XPATH)
@@ -50,6 +55,22 @@ module Leptris::XML::Searchable
 
   protected
 
+  # Builds a caller-owned namespace binding set, evaluates via
+  # leptris_xpath_eval_ns, and frees the set regardless of outcome.
+  def xpath_eval_with_namespaces(doc_ptr, context_ptr, expr, ns)
+    set = Leptris::XML::FFI.leptris_xpath_ns_set_new
+    begin
+      ns.each do |prefix, uri|
+        Leptris::XML::FFI.check_status(
+          Leptris::XML::FFI.leptris_xpath_ns_set_add(
+            set, prefix.to_s, uri.to_s))
+      end
+      Leptris::XML::FFI.leptris_xpath_eval_ns(doc_ptr, context_ptr, expr, set)
+    ensure
+      Leptris::XML::FFI.leptris_xpath_ns_set_free(set)
+    end
+  end
+
   def parse_search_args(args)
     handler = args.find { |a| !a.is_a?(String) && !a.is_a?(Hash) && !a.is_a?(Symbol) }
     args = args - [handler] if handler

metadata

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