leptris 1.1.0 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ec7aed2502125d89ff790ecd754cab242aec563ee58c45ceaf7e86cac4e96f85
-  data.tar.gz: 6e9a72b02fc76907143756992afa7866415912bbe5fa9282d1800974cfde8b74
+  metadata.gz: 28a6d0b01b14207e6a928eead2f38f84bf2dda03b9c7ae4a3c6bcc3163f2760d
+  data.tar.gz: e23962a817090c8707dc691fe58276f25da7075e1b0b64bb1fa39774cd113d4e
 SHA512:
-  metadata.gz: 1e2a587372714a54f60e560bd175885f09fa3dd5ec3c0d620715c58e152f36651606e63770000f1a7c5162590299328967942093a96a45f9cac923db2c86d369
-  data.tar.gz: 60aee00fff31eeba0e89a4b5d4affdf93dff22e5080db1093d17b05e6b029d94608f7934f5ec9c1c4eed3b7bfb3d905adb47f8e51ecc0645f8d52cb3e51da453
+  metadata.gz: 83e9f30fd09ded2f909d651423db46be8a6baca9f39f310e9b8c3632f5fd7cd5627d193cd57c80d6191a2c00145858b87d9454a72df12e96a28fbd928864a663
+  data.tar.gz: 5991c97a7ea5b8a3462c62492fd70808f4094d2758525ce2ec6ac47a9ffe61bb318c71d1999c95081e5e48ce10cc98d9e671ea8c52400c3a90b01e4f9a5b3ce1

data/CHANGELOG.md

@@ -5,6 +5,88 @@ 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.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
+
+- **Precompiled platform gems** (emf2svg-ruby model): `rake compile`
+  vendors libleptris into `lib/`, and `rake gem:native:<platform>`
+  builds binary gems for x86_64/aarch64-linux (incl. musl, via Alpine
+  containers), x64-mingw32/ucrt + aarch64-mingw-ucrt, and
+  x86_64/arm64-darwin. `gem install leptris` resolves the platform
+  gem and works with no system libleptris and no env vars — the FFI
+  search order prefers the vendored library. The pure-Ruby gem
+  remains the fallback for other setups.
+- `Element#prefix` — the element's own namespace prefix (nil-safe).
+- `Element#each_attribute` — Enumerator over the v1.1.0
+  attribute-iteration face; `attributes`/`attribute_nodes`/`keys`/
+  `values` now use it (O(n) vs the O(n^2) index-re-walk API).
+- Bindings for the v1.1.0 public surface: attribute-iteration face,
+  mixed-nodeset API (`xpath_result_node_kind/get_node/node_name/
+  node_value` + kind constants), `leptris_serialize_document`,
+  `leptris_document_get_dtd`, `leptris_element_prefix`,
+  `leptris_xpath_register_function` (Ruby sugar deferred until the
+  callback return-string ownership is verified).
+- `NodeSet` fetches via `get_node` (all node kinds) instead of the
+  elements-only `result_get`.
+
+### Changed
+
+- `release.yml` is standalone again, building the 8-platform matrix
+  plus musl containers and publishing all gems via OIDC trusted
+  publishing. Requires the rubygems.org trusted publisher to be
+  re-pointed at this workflow (filename `release.yml`, no
+  reusable-workflow fields).
+- CI builds libleptris via `rake compile` (single version pin in the
+  Rakefile) instead of an inline cmake script.
+
+### Fixed
+
+- Removes the resurrected `c14n.rb` (its deletion was lost in a
+  rebase-merge; nothing referenced it).
+
+### Known issues
+
+- Mixed-kind XPath results misreport node types upstream
+  (leptris#477: enum-space collision; `node_name`/`node_value`
+  crash on text entries). Specs assert only the correct surface;
+  `NodeSet` carries a per-index fallback for the under-copying batch
+  accessor.
+
 ## [1.1.0] - 2026-08-22
 
 Lockstep with libleptris 1.1.0.

data/README.adoc

@@ -397,7 +397,7 @@ bundle exec rspec spec/xml/xpath_spec.rb:42   # one example by line
 bundle exec rubocop                  # lint
 ----
 
-CI pins libleptris to a released tag (currently v1.1.0) and builds it
+CI pins libleptris to a released tag (currently v1.1.1) and builds it
 from source on each runner; see `.github/workflows/build.yml`.
 
 == License

data/Rakefile

@@ -4,4 +4,95 @@ require "bundler/gem_tasks"
 require "rspec/core/rake_task"
 
 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.2.0"
+
+CMAKE_FLAGS = %w[
+  -DCMAKE_BUILD_TYPE=Release
+  -DLEPTRIS_BUILD_SHARED=ON
+  -DLEPTRIS_BUILD_STATIC=OFF
+  -DBUILD_TESTING=OFF
+  -DLEPTRIS_BUILD_CLI=OFF
+  -DLEPTRIS_BUILD_BENCHMARKS=OFF
+  -DLEPTRIS_BUILD_MAN_PAGES=OFF
+  -DLEPTRIS_ENABLE_UTF8PROC=OFF
+  -DLEPTRIS_ENABLE_ICONV=OFF
+].freeze
+
+desc "Build libleptris #{LIBLEPTRIS_VERSION} from its release tarball into lib/"
+task :compile do
+  version = ENV.fetch("LIBLEPTRIS_VERSION", LIBLEPTRIS_VERSION)
+  build = File.expand_path("tmp/libleptris-#{version}", __dir__)
+  rm_rf(build)
+  mkdir_p(build)
+  url = "https://api.github.com/repos/leptris/leptris/tarball/v#{version}"
+  sh "curl -sL #{url} | tar xz -C #{build} --strip-components=1"
+  sh "cmake -B #{build}/build -S #{build} #{CMAKE_FLAGS.join(' ')}"
+  sh "cmake --build #{build}/build --config Release -j 4"
+  # Windows names the shared library leptris.dll (no "lib" prefix);
+  # vendoring under the uniform libleptris.* name keeps the FFI
+  # search order simple.
+  lib = Dir.glob("#{build}/build/**/libleptris.{dylib,so}").first ||
+        Dir.glob("#{build}/build/**/leptris.dll").first
+  raise "libleptris shared library not found after build" unless lib
+  ext = File.extname(lib)
+  cp(lib, "lib/libleptris#{ext}")
+  puts "Vendored #{File.basename(lib)} as lib/libleptris#{ext}"
+end
+
+task spec: :compile unless ENV.key?("LEPTRIS_LIB_PATH")
+
 task default: :spec
+
+require "rubygems/package_task"
+
+desc "Build the pure-Ruby gem"
+task "gem:native:any" do
+  sh "rake platform:any gem"
+end
+
+desc "Define the gem task to build the pure-Ruby gem"
+task "platform:any" do
+  spec = Gem::Specification::load("leptris.gemspec").dup
+  task = Gem::PackageTask.new(spec)
+  task.define
+end
+
+platforms = [
+  "x64-mingw32",
+  "x64-mingw-ucrt",
+  "aarch64-mingw-ucrt",
+  "x86_64-linux",
+  "x86_64-linux-musl",
+  "aarch64-linux",
+  "aarch64-linux-musl",
+  "x86_64-darwin",
+  "arm64-darwin",
+]
+
+platforms.each do |platform|
+  desc "Build pre-compiled gem for the #{platform} platform"
+  task "gem:native:#{platform}" do
+    sh "rake compile platform:#{platform} gem"
+  end
+
+  desc "Define the gem task to build on the #{platform} platform (binary gem)"
+  task "platform:#{platform}" do
+    spec = Gem::Specification::load("leptris.gemspec").dup
+    spec.platform = Gem::Platform.new(platform)
+    spec.files += Dir.glob("lib/libleptris.{dll,so,dylib}")
+    task = Gem::PackageTask.new(spec)
+    task.define
+  end
+end
+
+require "rake/clean"
+
+CLOBBER.include("pkg")
+CLEAN.include("tmp",
+              "lib/libleptris.dll",
+              "lib/libleptris.dylib",
+              "lib/libleptris.so")

data/lib/leptris/version.rb

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

data/lib/leptris/xml/attr.rb

@@ -1,10 +1,8 @@
 # frozen_string_literal: true
 
-# Lightweight attribute wrapper. libleptris v0.4.4 doesn't expose per-attribute
-# pointers (no LeptrisAttribute accessors in the public API), so an Attr is a
-# (name, value, parent_element) triple. Mutation goes through the parent
-# element via #[]. Once upstream adds attribute-level accessors, this can
-# become a pointer-backed wrapper.
+# Lightweight attribute wrapper: a (name, value, parent_element) triple
+# materialized from the attribute-iteration face. Mutation goes through
+# the parent element via #[].
 
 class Leptris::XML::Attr
   attr_reader :name, :value, :element
@@ -31,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

@@ -66,6 +66,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 +117,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

@@ -48,34 +48,43 @@ class Leptris::XML::Element < Leptris::XML::Node
   end
   alias_method :delete, :remove_attribute
 
+  # Iterates the element's attributes via the v1.1.0 linked-list face
+  # (one FFI call per attribute; the name_at/value_at indexing API
+  # re-walks the list per index, making it O(n^2) per element).
+  def each_attribute
+    return enum_for(:each_attribute) unless block_given?
+    attr = Leptris::XML::FFI.leptris_element_first_attribute(@c_ptr)
+    until attr.nil? || attr.null?
+      name = Leptris::XML::FFI.leptris_attribute_get_name(attr)
+      value = Leptris::XML::FFI.leptris_attribute_get_value(@c_ptr, attr)
+      yield Leptris::XML::Attr.new(name, value, self)
+      attr = Leptris::XML::FFI.leptris_attribute_next(attr)
+    end
+    self
+  end
+
   def keys
-    count = Leptris::XML::FFI.leptris_element_attribute_count(@c_ptr)
-    count.times.map { |i| Leptris::XML::FFI.leptris_element_attribute_name_at(@c_ptr, i) }
+    each_attribute.to_a.map(&:name)
   end
 
   def values
-    count = Leptris::XML::FFI.leptris_element_attribute_count(@c_ptr)
-    count.times.map { |i| Leptris::XML::FFI.leptris_element_attribute_value_at(@c_ptr, i) }
+    each_attribute.to_a.map(&:value)
   end
 
   def attributes
-    count = Leptris::XML::FFI.leptris_element_attribute_count(@c_ptr)
     result = {}
-    count.times do |i|
-      name = Leptris::XML::FFI.leptris_element_attribute_name_at(@c_ptr, i)
-      value = Leptris::XML::FFI.leptris_element_attribute_value_at(@c_ptr, i)
-      result[name] = Leptris::XML::Attr.new(name, value, self)
-    end
+    each_attribute { |attr| result[attr.name] = attr }
     result
   end
 
   def attribute_nodes
-    count = Leptris::XML::FFI.leptris_element_attribute_count(@c_ptr)
-    count.times.map do |i|
-      name = Leptris::XML::FFI.leptris_element_attribute_name_at(@c_ptr, i)
-      value = Leptris::XML::FFI.leptris_element_attribute_value_at(@c_ptr, i)
-      Leptris::XML::Attr.new(name, value, self)
-    end
+    each_attribute.to_a
+  end
+
+  # The element's own namespace prefix (e.g. "foo" for <foo:child/>),
+  # or nil when the element has none.
+  def prefix
+    Leptris::XML::FFI.leptris_element_prefix(@c_ptr)
   end
 
   def prepend_child(node)
@@ -182,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

@@ -11,6 +11,7 @@ module Leptris
         ENV["LEPTRIS_LIB_PATH"],
         File.expand_path("../../libleptris.dylib", __dir__),
         File.expand_path("../../libleptris.so", __dir__),
+        File.expand_path("../../libleptris.dll", __dir__),
         "/usr/local/lib/libleptris.dylib",
         "/usr/local/lib/libleptris.so",
         "leptris",
@@ -65,6 +66,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,
@@ -186,6 +191,16 @@ module Leptris
         [:leptris_element, :string, :int], :int
       attach_function :leptris_element_has_attribute,
         [:leptris_element, :string], :int
+      attach_function :leptris_element_first_attribute,
+        [:leptris_element], :leptris_attribute
+      attach_function :leptris_attribute_next,
+        [:leptris_attribute], :leptris_attribute
+      attach_function :leptris_attribute_get_name,
+        [:leptris_attribute], :string
+      attach_function :leptris_attribute_get_value,
+        [:leptris_element, :leptris_attribute], :string
+      attach_function :leptris_element_prefix,
+        [:leptris_element], :string
       attach_function :leptris_element_attribute_count,
         [:leptris_element], :size_t
       attach_function :leptris_element_attribute_name_at,
@@ -310,6 +325,22 @@ module Leptris
         [:leptris_xpath_result], :size_t
       attach_function :leptris_xpath_result_get,
         [:leptris_xpath_result, :size_t], :leptris_element
+      # Mixed nodesets (v1.1.0): unlike result_get (elements only),
+      # get_node returns the node whatever its kind; node_kind reports
+      # which (element / synthetic attribute / text / other).
+      attach_function :leptris_xpath_result_node_kind,
+        [:leptris_xpath_result, :size_t], :int
+      attach_function :leptris_xpath_result_get_node,
+        [:leptris_xpath_result, :size_t], :leptris_node_ref
+      attach_function :leptris_xpath_result_node_name,
+        [:leptris_xpath_result, :size_t], :string
+      attach_function :leptris_xpath_result_node_value,
+        [:leptris_xpath_result, :size_t], :string
+      # Document-scoped custom XPath functions. The callback receives
+      # (const char* const* args, int argc, void* user_data) and returns
+      # a heap string the library frees.
+      attach_function :leptris_xpath_register_function,
+        [:leptris_document, :string, :pointer, :pointer], :leptris_status
       attach_function :leptris_xpath_result_get_nodes,
         [:leptris_xpath_result, :pointer, :size_t], :size_t
       attach_function :leptris_xpath_result_boolean,
@@ -347,6 +378,12 @@ module Leptris
 
       attach_function :leptris_document_serialize,
         [:leptris_document, :pointer], :pointer
+      # Legacy simple serializer, declared retroactively in v1.1.0.
+      # Prefer leptris_document_serialize; bound for API completeness.
+      attach_function :leptris_serialize_document,
+        [:leptris_document], :pointer
+      attach_function :leptris_document_get_dtd,
+        [:leptris_document], :pointer
       attach_function :leptris_element_serialize,
         [:leptris_element, :pointer], :pointer
       attach_function :leptris_document_save_file,
@@ -398,6 +435,11 @@ module Leptris
       XPATH_NUMBER = 2
       XPATH_STRING = 3
 
+      XPATH_NODE_ELEMENT = 0
+      XPATH_NODE_ATTRIBUTE = 1
+      XPATH_NODE_TEXT = 2
+      XPATH_NODE_OTHER = 3
+
       NODE_ELEMENT = 0
       NODE_TEXT = 1
       NODE_COMMENT = 2

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/node_set.rb

@@ -52,7 +52,7 @@ class Leptris::XML::NodeSet
   def [](idx)
     if @result_ptr
       return nil if idx < 0 || idx >= length
-      ptr = Leptris::XML::FFI.leptris_xpath_result_get(@result_ptr, idx)
+      ptr = Leptris::XML::FFI.leptris_xpath_result_get_node(@result_ptr, idx)
       return nil if ptr.null?
       Leptris::XML::Node.wrap(ptr, @document)
     else
@@ -77,6 +77,13 @@ class Leptris::XML::NodeSet
             next if ptr.null?
             yield Leptris::XML::Node.wrap(ptr, @document)
           end
+          # The batch accessor under-copies mixed-kind results (upstream
+          # leptris#477); fall back to per-index fetch for the remainder.
+          (copied...n).each do |i|
+            ptr = Leptris::XML::FFI.leptris_xpath_result_get_node(@result_ptr, i)
+            next if ptr.null?
+            yield Leptris::XML::Node.wrap(ptr, @document)
+          end
         ensure
           buf.free
         end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: leptris
 version: !ruby/object:Gem::Version
-  version: 1.1.0
+  version: 1.2.0
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-08-22 00:00:00.000000000 Z
+date: 2026-08-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ffi
@@ -112,7 +112,6 @@ files:
 - lib/leptris/version.rb
 - lib/leptris/xml.rb
 - lib/leptris/xml/attr.rb
-- lib/leptris/xml/c14n.rb
 - lib/leptris/xml/c_string_array.rb
 - lib/leptris/xml/cdata.rb
 - lib/leptris/xml/comment.rb

data/lib/leptris/xml/c14n.rb

@@ -1,23 +0,0 @@
-# frozen_string_literal: true
-
-module Leptris
-  module XML
-    # @api private
-    #
-    # Builds a NULL-terminated `const char**` from a Ruby array of strings,
-    # suitable for passing to leptris_c14n_canonicalize_ex's
-    # `inclusive_ns_prefixes` argument. Returns [pointer, anchor] where
-    # anchor is the underlying MemoryPointer that the caller must keep
-    # alive (e.g. via local variable) for the duration of the FFI call.
-    def self.c14n_build_ns_pointer(inclusive_namespaces)
-      return [nil, nil] if inclusive_namespaces.nil? || inclusive_namespaces.empty?
-      strs = Array(inclusive_namespaces).map(&:to_s)
-      ptr_size = ::FFI.type_size(:pointer)
-      buffer = ::FFI::MemoryPointer.new(:pointer, strs.size + 1)
-      anchors = strs.map { |s| ::FFI::MemoryPointer.from_string(s) }
-      anchors.each_with_index { |p, i| buffer.put_pointer(i * ptr_size, p) }
-      buffer.put_pointer(strs.size * ptr_size, nil)
-      [buffer, anchors]
-    end
-  end
-end