leptris 1.7.0 → 1.9.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c730c4f07fa9f337b543dc841c39e3c18b36e9cc819cb94073153bfe183ed116
-  data.tar.gz: 3536b7dd7fe1cae01ffb0c11e5f56f19bdfbba7acd9f07c3058185fa8bcb9642
+  metadata.gz: ed2f1d5755923f389734df36cc9c40c513535e58e7abe5a40aa87dd93f858788
+  data.tar.gz: eb4e9c9c3b12a7584572746053c9aaf318ee5481fa002909d8502d5565bcf543
 SHA512:
-  metadata.gz: ac1842632da49256d913a14f9d7c7ea73b2753d5eafc15c33b3898d48e2238e0e24ca24096e454e17f158c1d795280f220612e3b70a2b32ceeccaa6b41c873b9
-  data.tar.gz: 031ee5fa00251dbde3f1aad9c6dad15e5ef79c309de0d5bd4875028a1a1d2160b6a9fe4a53e698c24b8333b9214ad824523c9de89e598ede14cf8e6737030378
+  metadata.gz: 35a1a34584014746679c39098f60c6009871007e3e5016562b669437e6f00d84412c7a26f286034f628421f72846c810b1b3568faacbbae86fa3e6c47b6db20f
+  data.tar.gz: 5e4785ee975db46c2f7798a4effd7c3d2be729e94ded98db78e3cdd830891b0704170e104d9b2287ff1e4e8a98833917a70a7ec4d5591615931020cf67f18e54

data/CHANGELOG.md

@@ -2,70 +2,78 @@
 
 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/),
+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.7.0] - 2026-08-24
+## [1.9.1] - 2026-08-24
 
-Lockstep with libleptris 1.7.0. New engine surface:
-leptris_node_children (all-kind batch) and the document/element
-serialize-into caller buffers (#535).
+### Fixed
 
-## [1.6.2] - 2026-08-24
+- **Autoload manifest restored after `require "leptris"`** (issue
+  #53): 1.9.0's eager FFI require ran inside `module Leptris`
+  before `autoload :XML` was registered, so ffi.rb's module opening
+  created `Leptris::XML` first — the autoload registration was
+  shadowed, xml.rb never loaded, and the entire API was unreachable
+  (`Leptris::XML.constants == [:FFI]`, no `Leptris::XML.parse`).
+  The eager require now runs after the registration: ffi.rb's
+  module opening triggers the autoload, FFI lands inside the real
+  manifest module, and a downstream `require "leptris/xml"` is a
+  no-op (the moxml workaround becomes unnecessary). Eager library
+  resolution at require time (#49) is unchanged. Regression spec
+  runs the cold `require "leptris"` path in a subprocess.
 
-Lockstep with libleptris 1.6.2 (fix releases, no public API changes).
+## [1.9.0] - 2026-08-24
 
-### Changed
-
-- CI/build pin libleptris v1.6.2, carrying the serializer fix for
-  mixed-content indentation (upstream #534 — never indent inside
-  mixed-content elements).
-
-## [1.6.1] - 2026-08-24
+Lockstep with libleptris 1.9.0 (covers the 1.8.0 and 1.9.0 engine
+releases; CI/build pin libleptris v1.9.0).
 
 ### Added
 
-- **Readonly mode**: `Leptris::XML.parse(xml, readonly: true)` /
-  `Document#readonly!` (one-way). Mutations raise
-  `Leptris::XML::ReadOnlyError`; read paths memoize aggressively
-  (names, content, children NodeSets, attribute hashes) since they can
-  never go stale; the C document is frozen (advisory upstream).
-  Detached factories (`create_element` etc.) remain usable.
-  Purpose: steady-state read performance for the dominant
-  parse-query-serialize workload — see Changed.
-
-### Changed
-
-- Micro-optimizations targeting the small-document gap versus C
-  extension bindings:
-  - node type is memoized from `Node.wrap`'s dispatch call — every
-    predicate and `#type` is now FFI-free
-  - the default serialize options struct is built once and reused
-  - `Document.parse` skips the per-parse status MemoryPointer (the C
-    out-param is nullable; failure detail comes from the thread-local
-    last error)
-  - `Element#name` memoizes (invalidated by `name=`)
-
-## [1.6.0] - 2026-08-24
-
-Lockstep with libleptris 1.6.0 — the moxml-adapter blockers fixed:
-same-parent node moves no longer corrupt the sibling chain (#518),
-detached PI/comment/CDATA mutation works on rootless documents
-(#519); union nodesets keep attribute identity (#514); document-level
-processing instructions gained a public API (#526).
+- **Expanded-name attribute access** (engine #542):
+  `Element#attribute_ns(uri, local)` and `#has_attribute_ns?(uri,
+  local)` look attributes up by namespace URI + local name with XML
+  Namespaces 1.0 semantics — cross-prefix matches, nil/"" URI for
+  no-namespace only, xmlns declarations invisible. `Element#[]`
+  inherits the corrected by-name semantics: bare names match only
+  no-namespace attributes, qualified names resolve through
+  declarations, undeclared prefixes return nil.
+- **Per-attribute namespace accessors** (engine #542): `Attr#prefix`
+  (as written in the QName) and `Attr#namespace_uri` (resolved
+  through the owning element's in-scope declarations at read time;
+  xml prebound; nil for undeclared prefixes). `Attr#namespace`
+  serves the URI instead of the pre-1.8.0 nil stub.
+- **Recover parsing** (engine #547): `Leptris::XML.parse(xml,
+  recover: true)` / `ParseOptions.recovering` — a parse failure
+  returns an empty document (failure detail on the thread-global
+  last error) instead of raising ParseError: the libxml2
+  XML_PARSE_RECOVER semantics adapters emulate. Struct-only option;
+  carrying it routes the parse through `leptris_parse_string_ex`.
+- **Caller-buffer serialization**: `#to_xml` (document + element)
+  now rides `leptris_document/element_serialize_into` (engine #541)
+  — options carried, the size-query + fill pair reuses one
+  serialization through a per-document cache invalidated on
+  mutation, and no C-side result-string allocation remains.
 
-## [1.5.0] - 2026-08-24
+### Fixed
 
-Lockstep with libleptris 1.5.0 — the engine pins the TODO.engine
-release: file-backed pull/iterparse streaming (bounded memory off
-disk), compiled XPath ns/vars contexts, Rust crate publish workflow.
+- Rootless documents with document-level PIs no longer serialize to
+  "" (engine #546) — the declaration and every document-level PI are
+  emitted.
+- Detached sibling inserts chain (engine #540): bottom-up
+  construction via `add_next_sibling` on detached elements works;
+  attaching the head of a detached chain carries the whole chain.
+- Eager library resolution at require time (issue leptris-ruby#49):
+  the FFI library list is loaded when the gem loads, so a
+  ruby-platform install (no vendored libleptris) fails immediately
+  with an actionable message instead of deep inside Document.parse
+- Packaging policy: this gem never publishes ruby-platform releases
+  without the vendored library — platform variants only
 
-## [1.4.0] - 2026-08-23
+## [1.7.0] - 2026-08-24
 
-Lockstep with libleptris 1.4.0 — engine pins the TODO.bindings
-release: pull (StAX) API, bounded iterparse, compiled XPath
-expressions, per-parse options, truthful serialization encoding
-declarations. Binding-side adoption of the new APIs follows.
+Lockstep with libleptris 1.7.0. New engine surface:
+leptris_node_children (all-kind batch) and the document/element
+serialize-into caller buffers (#535).
 
 ## [1.6.2] - 2026-08-24
 
@@ -104,8 +112,11 @@ Lockstep with libleptris 1.6.2 (fix releases, no public API changes).
 
 ## [1.6.0] - 2026-08-24
 
-Lockstep with libleptris 1.6.0 (v1.4/v1.5 were fix releases with no
-public API changes).
+Lockstep with libleptris 1.6.0 — the moxml-adapter blockers fixed:
+same-parent node moves no longer corrupt the sibling chain (#518),
+detached PI/comment/CDATA mutation works on rootless documents
+(#519); union nodesets keep attribute identity (#514); document-level
+processing instructions gained a public API (#526).
 
 ### Added
 
@@ -130,6 +141,19 @@ public API changes).
 - `leptris_parse_string_ex` bound (options-struct parse; the flags
   path remains the default).
 
+## [1.5.0] - 2026-08-24
+
+Lockstep with libleptris 1.5.0 — the engine pins the TODO.engine
+release: file-backed pull/iterparse streaming (bounded memory off
+disk), compiled XPath ns/vars contexts, Rust crate publish workflow.
+
+## [1.4.0] - 2026-08-23
+
+Lockstep with libleptris 1.4.0 — engine pins the TODO.bindings
+release: pull (StAX) API, bounded iterparse, compiled XPath
+expressions, per-parse options, truthful serialization encoding
+declarations. Binding-side adoption of the new APIs follows.
+
 ## [1.3.0] - 2026-08-23
 
 Lockstep with libleptris 1.3.0 — takes full advantage of the

data/README.adoc

@@ -91,6 +91,18 @@ doc = Leptris::XML.parse_file("books.xml")
 This is the direct Nokogiri equivalent of `Nokogiri::XML(...)`. The
 returned object is a `Leptris::XML::Document`.
 
+Malformed input raises `Leptris::XML::ParseError`. Parse with
+`recover: true` to get libxml2's `XML_PARSE_RECOVER` semantics
+instead — an empty document back, with the failure recorded on the
+thread-global last error:
+
+[source,ruby]
+----
+doc = Leptris::XML.parse("<broken", recover: true)
+doc.root                                # => nil
+Leptris::XML::FFI.leptris_last_error    # => "..."
+----
+
 == Reading nodes
 
 [horizontal]
@@ -251,6 +263,10 @@ doc.root.name = "catalog"
 `Element#add_namespace_definition(prefix, href)` (alias `#add_namespace`) :: declare `xmlns:prefix="href"` on this element.
 `Element#default_namespace=(href)` :: declare/replace `xmlns="href"`.
 `Element#remove_namespace_definition(prefix)` :: drop a declaration.
+`Element#attribute_ns(uri, local)` :: attribute value by expanded name (URI + local); nil URI matches no-namespace attributes only.
+`Element#has_attribute_ns?(uri, local)` :: presence by expanded name.
+`Attr#prefix` :: the attribute's prefix as written (`nil` when none).
+`Attr#namespace_uri` :: resolved through the owning element's in-scope declarations at read time (`xml` prebound; `nil` for undeclared prefixes).
 
 [source,ruby]
 ----

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.7.0"
+LIBLEPTRIS_VERSION = "1.9.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.7.0"
+  VERSION = "1.9.1"
 end

data/lib/leptris/xml/attr.rb

@@ -1,16 +1,21 @@
 # frozen_string_literal: true
 
-# Lightweight attribute wrapper: a (name, value, parent_element) triple
-# materialized from the attribute-iteration face. Mutation goes through
-# the parent element via #[].
+# Lightweight attribute wrapper: a (name, value, parent_element)
+# triple materialized from the attribute-iteration face, carrying
+# the C attribute handle for the per-attribute namespace accessors.
+# Mutation goes through the parent element via #[].
 
 class Leptris::XML::Attr
   attr_reader :name, :value, :element
 
-  def initialize(name, value, element)
+  # c_handle is the C LeptrisAttribute pointer from the owning
+  # element's iteration face — document-owned and borrowed. Absent
+  # only when an Attr is constructed by hand.
+  def initialize(name, value, element, c_handle: nil)
     @name = name
     @value = value
     @element = element
+    @c_handle = c_handle
   end
 
   def value=(new_value)
@@ -18,8 +23,25 @@ class Leptris::XML::Attr
     @value = new_value
   end
 
+  # The prefix as written in the qualified name (bytes before the
+  # colon), nil for a no-namespace attribute. Name-derived and
+  # immutable — the same semantics as leptris_attribute_prefix, so
+  # no declaration lookup is involved.
+  def prefix
+    @name.include?(":") ? @name.split(":", 2).first : nil
+  end
+
+  # The attribute's namespace URI, resolved through the OWNING
+  # element's in-scope declarations at read time (libleptris 1.8.0).
+  # nil for a no-namespace attribute or an undeclared prefix; xml
+  # is prebound to http://www.w3.org/XML/1998/namespace.
+  def namespace_uri
+    return nil if @c_handle.nil?
+    Leptris::XML::FFI.leptris_attribute_namespace_uri(@c_handle)
+  end
+
   def namespace
-    nil  # upstream gap: per-attribute namespace not exposed
+    namespace_uri
   end
 
   def remove

data/lib/leptris/xml/document.rb

@@ -34,23 +34,41 @@ class Leptris::XML::Document
     @wrapper_cache = {}
   end
 
-  def self.parse(xml_or_io, options: nil, readonly: false)
+  def self.parse(xml_or_io, options: nil, readonly: false, recover: false)
     xml = xml_or_io.respond_to?(:read) ? xml_or_io.read : xml_or_io.to_s
     if xml.empty?
       raise Leptris::XML::ParseError, "empty input"
     end
-    flags = resolve_flags(options)
+    if options.nil?
+      options = Leptris::XML::ParseOptions.new(recover: recover)
+    elsif recover && !options.recover?
+      options = options | Leptris::XML::ParseOptions.new(recover: true)
+    elsif !options.is_a?(Leptris::XML::ParseOptions)
+      raise ArgumentError, "options must be a Leptris::XML::ParseOptions"
+    end
     # The status out-param is nullable; the thread-local last error
     # carries failure detail, and skipping the per-parse MemoryPointer
     # is measurable on small documents.
     raw =
-      if flags.zero?
+      if options.struct_required?
+        # Recover is a struct field, not a parse flag — the options
+        # struct path (leptris_parse_string_ex) is the only carrier.
+        options_struct = options.to_c_struct
+        Leptris::XML::FFI.leptris_parse_string_ex(
+          xml, xml.bytesize, options_struct.pointer, nil)
+      elsif options.flags.zero?
         Leptris::XML::FFI.leptris_parse_string(xml, xml.bytesize, nil)
       else
         Leptris::XML::FFI.leptris_parse_string_flags(
-          xml, xml.bytesize, flags, nil)
+          xml, xml.bytesize, options.flags, nil)
       end
     if raw.null?
+      if options.recover?
+        # Unreachable in practice: recover returns an empty document
+        # rather than NULL; kept so a contract change fails loudly.
+        raise Leptris::XML::Error,
+          "leptris_parse_string_ex returned NULL under recover"
+      end
       raise Leptris::XML::ParseError,
         "leptris_parse_string failed: " +
         Leptris::XML::FFI.leptris_last_error.to_s
@@ -102,15 +120,6 @@ class Leptris::XML::Document
   end
   private_class_method :finalizer
 
-  def self.resolve_flags(options)
-    return Leptris::XML::FFI::LEPTRIS_PARSE_DEFAULT if options.nil?
-    unless options.is_a?(Leptris::XML::ParseOptions)
-      raise ArgumentError, "options must be a Leptris::XML::ParseOptions"
-    end
-    options.flags
-  end
-  private_class_method :resolve_flags
-
   def root
     raise Leptris::XML::UseAfterFreeError if @freed.state == :freed
     return nil if @c_ptr.nil?
@@ -182,7 +191,7 @@ class Leptris::XML::Document
     raise Leptris::XML::UseAfterFreeError if @freed.state == :freed
     return "" if @c_ptr.nil?
     Leptris::XML::Serialization.to_xml(
-      Leptris::XML::FFI.method(:leptris_document_serialize), @c_ptr,
+      Leptris::XML::FFI.method(:leptris_document_serialize_into), @c_ptr,
       indent: indent, no_decl: no_decl, encoding: encoding)
   end
   alias_method :to_s, :to_xml

data/lib/leptris/xml/element.rb

@@ -47,6 +47,21 @@ class Leptris::XML::Element < Leptris::XML::Node
   end
   alias_method :has_attribute?, :key?
 
+  # Expanded-name attribute access (libleptris 1.8.0): URI + local
+  # name with XML Namespaces 1.0 semantics — the written prefix
+  # never matters, only what it resolves to through this element's
+  # in-scope declarations. uri nil/"" matches no-namespace
+  # attributes only; xmlns declarations are invisible.
+  def attribute_ns(uri, local)
+    Leptris::XML::FFI.leptris_element_attribute_ns(
+      @c_ptr, uri&.to_s, local.to_s)
+  end
+
+  def has_attribute_ns?(uri, local)
+    Leptris::XML::FFI.leptris_element_has_attribute_ns(
+      @c_ptr, uri&.to_s, local.to_s) != 0
+  end
+
   def remove_attribute(name)
     ensure_writable!
     Leptris::XML::FFI.check_status(
@@ -58,13 +73,15 @@ class Leptris::XML::Element < Leptris::XML::Node
   # 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).
+  # The C attribute handle rides along so Attr can serve the
+  # per-attribute namespace accessors (libleptris 1.8.0).
   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)
+      yield Leptris::XML::Attr.new(name, value, self, c_handle: attr)
       attr = Leptris::XML::FFI.leptris_attribute_next(attr)
     end
     self
@@ -238,7 +255,7 @@ class Leptris::XML::Element < Leptris::XML::Node
 
   def to_xml(indent: 0, no_decl: false, encoding: nil)
     Leptris::XML::Serialization.to_xml(
-      Leptris::XML::FFI.method(:leptris_element_serialize), @c_ptr,
+      Leptris::XML::FFI.method(:leptris_element_serialize_into), @c_ptr,
       indent: indent, no_decl: no_decl, encoding: encoding)
   end
 

data/lib/leptris/xml/ffi.rb

@@ -7,15 +7,32 @@ module Leptris
     module FFI
       extend ::FFI::Library
 
-      ffi_lib [
-        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",
-      ].compact
+      # Issue leptris-ruby#49: name the remedy when the library is
+      # missing (ruby-platform gem without a vendored libleptris).
+      begin
+        ffi_lib [
+          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",
+        ].compact
+      rescue LoadError => e
+        raise LoadError, <<~MSG
+          leptris: cannot load the vendored libleptris library.
+          You may have installed the ruby-platform variant of this
+          gem (#{Gem.loaded_specs["leptris"]&.full_name rescue "unknown"}),
+          which does not vendor the native library. Fix:
+
+            bundle update leptris        # force platform gems
+            # or: gem install leptris --platform ruby is unsupported
+            # or: set LEPTRIS_LIB_PATH=/path/to/libleptris.so
+
+          Original error: #{e.message}
+        MSG
+      end
 
       typedef :pointer, :leptris_document
       typedef :pointer, :leptris_element
@@ -53,6 +70,16 @@ module Leptris
           :encoding, :pointer
       end
 
+      # Mirrors LeptrisParseOptions (libleptris >= 1.9.0 carries the
+      # recover field; earlier fields unchanged since v1.6.0).
+      class ParseOptionsStruct < ::FFI::Struct
+        layout \
+          :flags, :int,
+          :strict_mode, :int,
+          :max_depth, :int,
+          :recover, :int
+      end
+
       attach_function :leptris_version, [], :string
       attach_function :leptris_version_components, [:pointer, :pointer, :pointer], :void
 
@@ -209,6 +236,20 @@ module Leptris
         [:leptris_element, :string, :int], :int
       attach_function :leptris_element_has_attribute,
         [:leptris_element, :string], :int
+      # libleptris 1.8.0: expanded-name lookup — (uri, local) with
+      # XML Namespaces 1.0 semantics; NULL/"" uri matches only
+      # no-namespace attributes, xmlns declarations never match.
+      attach_function :leptris_element_attribute_ns,
+        [:leptris_element, :string, :string], :string
+      attach_function :leptris_element_has_attribute_ns,
+        [:leptris_element, :string, :string], :int
+      # libleptris 1.8.0: per-attribute prefix (name-derived) and
+      # namespace URI (resolved through the owning element's
+      # in-scope declarations at read time).
+      attach_function :leptris_attribute_prefix,
+        [:leptris_attribute], :string
+      attach_function :leptris_attribute_namespace_uri,
+        [:leptris_attribute], :string
       attach_function :leptris_element_first_attribute,
         [:leptris_element], :leptris_attribute
       attach_function :leptris_attribute_next,
@@ -451,10 +492,18 @@ module Leptris
 
       attach_function :leptris_document_serialize,
         [:leptris_document, :pointer], :pointer
+      # libleptris >= 1.9.0: caller-buffer serialization with options
+      # (leptris#541). buf=NULL is a size query; the size-query +
+      # fill pair reuses one serialization through a per-document
+      # cache invalidated on mutation.
+      attach_function :leptris_document_serialize_into,
+        [:leptris_document, :pointer, :size_t, :pointer, :pointer], :size_t
       attach_function :leptris_document_get_dtd,
         [:leptris_document], :pointer
       attach_function :leptris_element_serialize,
         [:leptris_element, :pointer], :pointer
+      attach_function :leptris_element_serialize_into,
+        [:leptris_element, :pointer, :size_t, :pointer, :pointer], :size_t
       attach_function :leptris_document_save_file,
         [:leptris_document, :string, :pointer], :leptris_status
       attach_function :leptris_c14n_canonicalize,

data/lib/leptris/xml/parse_options.rb

@@ -11,19 +11,52 @@ class Leptris::XML::ParseOptions
 
   attr_reader :flags
 
-  def initialize(flags = Leptris::XML::FFI::LEPTRIS_PARSE_DEFAULT)
+  # Recover (libleptris 1.9.0, #547): a parse failure returns an
+  # empty document with the failure recorded in Document#last_error
+  # instead of raising — the libxml2 XML_PARSE_RECOVER semantics
+  # adapters emulate. Struct-only (not a parse flag): carrying it
+  # routes Document.parse through leptris_parse_string_ex.
+  attr_reader :recover
+
+  def initialize(flags = Leptris::XML::FFI::LEPTRIS_PARSE_DEFAULT,
+                 recover: false)
     @flags = flags.to_i
+    @recover = recover ? true : false
   end
 
   def self.noblanks
     new(NOBLANKS)
   end
 
+  def self.recovering
+    new(recover: true)
+  end
+
   def noblanks?
     @flags & NOBLANKS != 0
   end
 
+  def recover?
+    @recover == true
+  end
+
   def |(other)
-    self.class.new(@flags | other.flags)
+    self.class.new(@flags | other.flags, recover: @recover || other.recover?)
+  end
+
+  # True when the options cannot ride the flags-only parse path and
+  # need the full LeptrisParseOptions struct (leptris_parse_string_ex).
+  def struct_required?
+    recover?
+  end
+
+  # Builds the C LeptrisParseOptions struct mirroring this instance.
+  def to_c_struct
+    struct = Leptris::XML::FFI::ParseOptionsStruct.new
+    struct[:flags] = @flags
+    struct[:strict_mode] = -1
+    struct[:max_depth] = 0
+    struct[:recover] = @recover ? 1 : 0
+    struct
   end
 end

data/lib/leptris/xml/serialization.rb

@@ -18,8 +18,12 @@ module Leptris::XML::Serialization
   end
   private_constant :DEFAULT_OPTIONS
 
-  # +ffi_function+ is a bound FFI function taking (c_ptr, opts_ptr):
-  # leptris_document_serialize or leptris_element_serialize.
+  # +ffi_function+ is a bound _serialize_into function taking
+  # (c_ptr, buf, capacity, out_len, opts): size query with buf=NULL,
+  # then one fill into a caller buffer. Since libleptris 1.9.0 the
+  # pair reuses a single serialization through a per-document cache
+  # (leptris#541) — no C-side result-string allocation, and repeated
+  # serializations of an unmutated document skip the serialize pass.
   def self.to_xml(ffi_function, c_ptr, indent: 0, no_decl: false, encoding: nil)
     opts =
       if indent.to_i.zero? && !no_decl && encoding.nil?
@@ -29,8 +33,18 @@ module Leptris::XML::Serialization
           indent: indent, no_decl: no_decl, encoding: encoding)
         opts
       end
-    str_ptr = ffi_function.call(c_ptr, opts.pointer)
-    Leptris::XML::FFI.read_owned_string(str_ptr)
+    need = ffi_function.call(c_ptr, nil, 0, nil, opts.pointer)
+    return "" if need.zero?
+    buf = ::FFI::MemoryPointer.new(:char, need)
+    begin
+      ffi_function.call(c_ptr, buf, need, nil, opts.pointer)
+      # The buffer holds exactly the serialization + NUL; XML output
+      # is NUL-free, so a bounded read_string is exact. (Avoids the
+      # out_len param — no portable size_t read exists on Pointer.)
+      buf.read_string
+    ensure
+      buf.free
+    end
   end
 
   # +ffi_function+ is a bound FFI function taking

data/lib/leptris/xml.rb

@@ -27,8 +27,9 @@ module Leptris
 
     # Nokogiri-style top-level entry points (Nokogiri::XML(...) /
     # Nokogiri::XML.parse). Delegates to Document.parse.
-    def self.parse(xml_or_io, options: nil, readonly: false)
-      Document.parse(xml_or_io, options: options, readonly: readonly)
+    def self.parse(xml_or_io, options: nil, readonly: false, recover: false)
+      Document.parse(xml_or_io, options: options, readonly: readonly,
+                     recover: recover)
     end
 
     def self.parse_file(path)

data/lib/leptris.rb

@@ -5,3 +5,29 @@ require "leptris/version"
 module Leptris
   autoload :XML, "leptris/xml"
 end
+
+# Eager library resolution (issue leptris-ruby#49): resolve the
+# native library at require time instead of lazily inside
+# Document.parse, so a missing library fails immediately.
+#
+# The require MUST come after the autoload registration above.
+# ffi.rb opens `module Leptris; module XML`, and when that runs
+# before `autoload :XML` exists it creates the constant first — the
+# later autoload registration is then shadowed, xml.rb never loads,
+# and the entire API is unreachable (Leptris::XML.constants ==
+# [:FFI]; issue leptris-ruby#53). Requiring from here after the
+# registration makes ffi.rb's module opening trigger the autoload,
+# landing FFI inside the real manifest module; a downstream
+# `require "leptris/xml"` is then a no-op.
+begin
+  require "leptris/xml/ffi"
+rescue LoadError => e
+  raise LoadError, <<~MSG
+    Leptris could not load the native libleptris library.
+    The ruby-platform gem is a fallback variant and ships no
+    binary; install the platform-specific variant for your system
+    (e.g. `gem install leptris --platform=arm64-darwin`), or set
+    LEPTRIS_LIB_PATH to a libleptris.{so,dylib,dll} file.
+    (Underlying error: #{e.message})
+  MSG
+end

metadata

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