leptris 1.1.0 → 1.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ec7aed2502125d89ff790ecd754cab242aec563ee58c45ceaf7e86cac4e96f85
-  data.tar.gz: 6e9a72b02fc76907143756992afa7866415912bbe5fa9282d1800974cfde8b74
+  metadata.gz: 949fe73711448bd7857072004c75d6201b06829e9eb632124ae922a2fb7ff3f1
+  data.tar.gz: 259bbac7ce3e90389cce4f0e79dc979e7bc8ca844caa7745680ba352c010ba86
 SHA512:
-  metadata.gz: 1e2a587372714a54f60e560bd175885f09fa3dd5ec3c0d620715c58e152f36651606e63770000f1a7c5162590299328967942093a96a45f9cac923db2c86d369
-  data.tar.gz: 60aee00fff31eeba0e89a4b5d4affdf93dff22e5080db1093d17b05e6b029d94608f7934f5ec9c1c4eed3b7bfb3d905adb47f8e51ecc0645f8d52cb3e51da453
+  metadata.gz: cdab285d1fe462fcf7bc66681ebfbe1af74748ae99a8f0eebe1e502dfd72313b4429ac5943a18ebebd5706a308b135c33dfd7e8aab4bd313e383adcd91bb682f
+  data.tar.gz: 18240f20ed093b9e6434d0f9036ab93545b6af47237aa5ee72f616f3b10836148a3850fec5332fb2e44f416a53d25523d69f8bc4e4e1bb17c1f1181f16515f98

data/CHANGELOG.md

@@ -5,6 +5,54 @@ 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.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.1.1"
+
+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.1.2"
 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

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)

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",
@@ -186,6 +187,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 +321,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 +374,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 +431,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_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.1.2
 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