moxml 0.5.97 → 0.5.98

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ec3d9011525010958b918f5c9665d47f54c202c96d0e3917c65d90ced667233b
-  data.tar.gz: 4d7d535d9960f935a6419006c586db0b49981de555cfa362eee641c548c51c1b
+  metadata.gz: 8c17ad7b7e8250a5f143af509bfe551cb5c29deb1a2ae7f5cc64f275d8d460df
+  data.tar.gz: 9c6302666df0ca9a3761b2c072dc098ff3bc49a419b9cba404161e7d352bc70b
 SHA512:
-  metadata.gz: 8e39fcd9157a62fc686befcae1e4ca077e757c6b9bfc399b590f02377199be55e45f281f9cd50dcac5eaff9d32abd8aa2d40de7fc3250b3d02dd69aadd1dfefe
-  data.tar.gz: d947c13ae056a34a65d91d27648b54b89d4bca1c0d7a56712a77c560e7ef89cf798538af3871298ddcf5146379cc57442a7f02d359013228057a707765003f11
+  metadata.gz: f47afe09d0f5cbe9016846c3ca7d8b43bd7f8f79b63b7dfdc51013578a71b82ef4b28701a7dea4be55edbb96e9a2f5cc011c7cc51a7029dcdcad557e542c8c37
+  data.tar.gz: 1d7d971a95328b9397b71c49ff0c01df4af8ffc1e38c461a4801dd294993d58faa6eae05018000dd5c02e719a9162d25fcdf912b334409b2d3731f6fb67b36c5

data/docs/_guides/advanced-features.adoc

@@ -103,3 +103,37 @@ See also:
 
 * link:../pages/compatibility[Adapter compatibility]
 * link:../pages/adapters/[Individual adapter documentation]
+
+=== XSLT transformation (nokogiri, leptris)
+
+Compile-once, apply-many transformations through an implementation-agnostic
+interface. Engines: nokogiri (libxslt, XSLT 1.0) and leptris (XSLT 1.0-3.0
+per its engine). Adapters without an engine raise
+`Moxml::NotImplementedError` at compile; `Moxml::XSLT.supported?(context)`
+answers without raising.
+
+[source,ruby]
+----
+ctx = Moxml.new(:leptris)
+sheet = ctx.xslt(<<~XSL)
+  <xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform" version="1.0">
+    <xsl:template match="/"><out><xsl:value-of select="count(//item)"/></out></xsl:template>
+  </xsl:stylesheet>
+XSL
+
+result = sheet.apply_to(doc)          # Moxml::Document (same adapter)
+text   = sheet.apply_to_string(doc)   # String — fragments and text output
+----
+
+`apply_to` raises `Moxml::XsltError` when the output method cannot produce
+XML (method="text"); `apply_to_string` carries non-XML output. Documents
+parsed by another adapter serialize through their own adapter and re-parse
+into the engine. Top-level parameters are part of the contract
+(`params: { "name" => "value" }`); leptris does not thread them yet
+(leptris-ruby#360) and raises `Moxml::XsltError` when non-empty params are
+passed.
+
+See also:
+
+* link:../pages/compatibility[Adapter compatibility]
+* link:../pages/adapters/[Individual adapter documentation]

data/lib/moxml/adapter/base.rb

@@ -5,6 +5,11 @@ module Moxml
     class Base
       # include XmlUtils
 
+      # Whether this adapter ships an XSLT engine (nokogiri/libxslt
+      # and leptris do). Class-body level so the capability probe is
+      # a plain constant read from outside.
+      XSLT_SUPPORTED = false
+
       class << self
         include XmlUtils
 
@@ -184,6 +189,37 @@ module Moxml
           one == other
         end
 
+        # XSLT transformation. Only engines with an XSLT processor
+        # implement the trio below (currently nokogiri/libxslt and
+        # leptris; leptris covering XSLT 2.0/3.0 per its engine) and
+        # declare XSLT_SUPPORTED = true at class-body level. Base
+        # raises so unsupported adapters fail fast at the seam.
+
+        # Compile a stylesheet source string into an engine handle.
+        # @raise [Moxml::XsltError] on a malformed stylesheet
+        def xslt_compile(_sheet_source)
+          raise Moxml::NotImplementedError, XSLT_UNSUPPORTED_MESSAGE
+        end
+
+        # Apply a compiled stylesheet; returns the engine's result
+        # document, or nil when the output method cannot produce one
+        # (text). @params is the flat quoted name/value list.
+        def xslt_apply_document(_sheet, _document_native, _params)
+          raise Moxml::NotImplementedError, XSLT_UNSUPPORTED_MESSAGE
+        end
+
+        # Apply a compiled stylesheet and serialize in one call —
+        # fragments and text output survive.
+        def xslt_apply_string(_sheet, _document_native, _params)
+          raise Moxml::NotImplementedError, XSLT_UNSUPPORTED_MESSAGE
+        end
+
+        # Plain string: no Moxml::XSLT reference at load time (Opal
+        # resolves the autoload differently); keep in sync with
+        # Moxml::XSLT::SUPPORTED_ADAPTERS.
+        XSLT_UNSUPPORTED_MESSAGE =
+          "XSLT requires an engine; supported adapters: nokogiri, leptris"
+
         # Owner element native for an attribute native, where the
         # engine exposes it (nil elsewhere).
         def attribute_element(_attribute)

data/lib/moxml/adapter/leptris.rb

@@ -142,6 +142,12 @@ module Moxml
       NATIVE_SAX_RECORDS =
         Gem::Version.new(::Leptris::VERSION) >= Gem::Version.new("1.9.242")
 
+      # XSLT 1.0/2.0/3.0 through the engine's compiled-stylesheet
+      # faces (Moxml::XSLT contract). Top-level parameters are not
+      # threaded through the faces yet (leptris-ruby#360) — non-empty
+      # params raise Moxml::XsltError.
+      XSLT_SUPPORTED = true
+
       # Defined unconditionally: the body self-guards, and call
       # sites must never depend on the layer having loaded
       # (issue #217 — binding-only installs crashed on the
@@ -149,7 +155,17 @@ module Moxml
       # Class-body level: a bare @ivar inside `class << self` lands
       # on the singleton's singleton, invisible to the methods at
       # call time (same shape as @native_doc_roots below).
-      @binding_of = ObjectSpace::WeakMap.new
+      @binding_of = if Context::WEAK_WRAPPERS
+                      ObjectSpace::WeakMap.new
+                    else
+                      {}.compare_by_identity
+                    end
+      # Strong-mode valve (MRI < 3.4 only): the registry is
+      # class-level and per-node, so a hard bound keeps parse-heavy
+      # processes flat. A clear re-bridges on the next to_binding —
+      # identity loss is the same trade the 65,536 context valve
+      # made before the weak registry replaced it.
+      BINDING_OF_CAP = 8_192
 
       class << self
         # native -> bridged binding node. The bridge object is
@@ -171,6 +187,7 @@ module Moxml
           doc = doc_for(node)
           ptr = ::FFI::Pointer.new(node.address)
           bridged = ::Leptris::XML::Node.wrap(ptr, doc)
+          @binding_of.clear if @binding_of.size >= BINDING_OF_CAP
           @binding_of[node] = bridged unless bridged.nil?
           bridged
         end
@@ -179,7 +196,13 @@ module Moxml
       if NATIVE_READ_LAYER
         # root NativeNode -> binding document (recorded at #root
         # mint; the native layer exposes no document accessor).
-        @native_doc_roots = ObjectSpace::WeakMap.new
+        @native_doc_roots = if Context::WEAK_WRAPPERS
+                              ObjectSpace::WeakMap.new
+                            else
+                              {}.compare_by_identity
+                            end
+        # Same strong-mode valve, keyed per document root (tiny).
+        NATIVE_DOC_ROOTS_CAP = 1_024
 
         class << self
           # Extend-in-place mint (#230 stage 2): a TypedData native
@@ -405,6 +428,7 @@ module Moxml
           end
 
           def record_native_doc(root_native, doc)
+            @native_doc_roots.clear if @native_doc_roots.size >= NATIVE_DOC_ROOTS_CAP
             @native_doc_roots[root_native] = doc
           end
 
@@ -459,6 +483,36 @@ module Moxml
       # (Document/serialize/C14n), which is circular while THIS
       # adapter file is still loading — the load-time form rescued
       # to false on every build and masked a landed engine fix.
+      # --- XSLT (Moxml::XSLT contract, engine faces) ---
+
+      def self.xslt_compile(sheet_source)
+        ::Leptris::XML::XSLT.parse(sheet_source)
+      rescue ::Leptris::XML::XPathError => e
+        raise Moxml::XsltError, "stylesheet compile failed: #{e.message}"
+      end
+
+      def self.xslt_apply_document(sheet, document_native, params)
+        assert_xslt_no_params(params)
+        sheet.apply_to(document_native)
+      rescue ::Leptris::XML::XPathError => e
+        raise Moxml::XsltError, "transform failed: #{e.message}"
+      end
+
+      def self.xslt_apply_string(sheet, document_native, params)
+        assert_xslt_no_params(params)
+        sheet.serialize(document_native)
+      rescue ::Leptris::XML::XPathError => e
+        raise Moxml::XsltError, "transform failed: #{e.message}"
+      end
+
+      def self.assert_xslt_no_params(params)
+        return if params.nil? || params.empty?
+
+        raise Moxml::XsltError,
+              "XSLT params are not threaded by the leptris engine yet " \
+              "(leptris-ruby#360); pass an empty params hash"
+      end
+
       def self.native_c14n_byte_safe?
         return @native_c14n_byte_safe unless @native_c14n_byte_safe.nil?
 

data/lib/moxml/adapter/nokogiri.rb

@@ -7,6 +7,9 @@ require "nokogiri"
 module Moxml
   module Adapter
     class Nokogiri < Base
+      # libxslt-backed XSLT 1.0 (Moxml::XSLT contract).
+      XSLT_SUPPORTED = true
+
       class << self
         def attachments
           @attachments ||= Moxml::NativeAttachment.new
@@ -50,6 +53,32 @@ module Moxml
           true
         end
 
+        # --- XSLT (Moxml::XSLT contract, libxslt-backed) ---
+
+        def xslt_compile(sheet_source)
+          ::Nokogiri::XSLT.parse(sheet_source)
+        rescue ::RuntimeError => e
+          # Nokogiri raises bare RuntimeError for compilation errors.
+          raise Moxml::XsltError, "stylesheet compile failed: #{e.message}"
+        end
+
+        def xslt_apply_document(sheet, document_native, params)
+          sheet.transform(document_native, params)
+        rescue ::RuntimeError => e
+          raise Moxml::XsltError, "transform failed: #{e.message}"
+        end
+
+        def xslt_apply_string(sheet, document_native, params)
+          # libxslt always yields a document; the string face is its
+          # serialization AS_XML (compact — the default to_xml would
+          # re-indent and diverge from engines that serialize without
+          # formatting).
+          result = xslt_apply_document(sheet, document_native, params)
+          result.to_xml(
+            save_with: ::Nokogiri::XML::Node::SaveOptions::AS_XML,
+          )
+        end
+
         # libxml2-native inclusive C14N: delegated for the default
         # shape (Inclusive 1.0, no comments, no InclusiveNamespaces
         # prefix list) when the probe below proves libxml2's output

data/lib/moxml/context.rb

@@ -5,7 +5,17 @@ module Moxml
     # Opal's default runtime excludes ObjectSpace entirely; the weak
     # registry needs WeakMap, so the strong Hash (with its
     # wholesale-clear valve) covers that platform.
-    WEAK_WRAPPERS = !defined?(ObjectSpace::WeakMap).nil?
+    # MRI 3.3's ObjectSpace::WeakMap has a mark-time hazard: a
+    # dangling VALUE in the weak table is dereferenced during
+    # incremental-GC marking (SIGSEGV in wmap_mark_weak_table_i —
+    # lutaml/moxml#303, reproduced with the leptris adapter on the
+    # xmi suite; 100% crash rate 1.9.261-1.9.282, clean with these
+    # registries strong). Ruby 3.4 rewrote WeakMap and is safe.
+    # MRI < 3.4 takes the strong identity-Hash fallback (the Opal
+    # shape, with the 65,536 valve in register_wrapper).
+    WEAK_WRAPPERS = !defined?(ObjectSpace::WeakMap).nil? &&
+      !(RUBY_ENGINE == "ruby" &&
+        Gem::Version.new(RUBY_VERSION) < Gem::Version.new("3.4"))
     attr_reader :config
 
     def initialize(adapter = nil)
@@ -111,6 +121,26 @@ module Moxml
       config.adapter.parse_html(html, options, self)
     end
 
+    # Compile an XSLT stylesheet with this context's adapter
+    # (implementation-agnostic; nokogiri/libxslt and leptris ship
+    # engines, leptris covering XSLT 2.0/3.0 per its engine). Apply
+    # the returned Stylesheet to documents parsed by this context.
+    #
+    # @param stylesheet [String, Moxml::Document] the stylesheet
+    #   source; documents from other adapters serialize through their
+    #   own adapter first
+    # @return [Moxml::XSLT::Stylesheet]
+    # @raise [Moxml::NotImplementedError] on adapters without an engine
+    # @raise [Moxml::XsltError] on a malformed stylesheet
+    def xslt(stylesheet)
+      source = case stylesheet
+               when Moxml::Document then stylesheet.to_xml
+               else stylesheet.to_s
+               end
+      sheet = config.adapter.xslt_compile(source)
+      Moxml::XSLT::Stylesheet.new(sheet, self)
+    end
+
     # Streaming incremental parse (leptris): yields each completed
     # element while parsing — :top_level yields the root's children,
     # :full_document every element in completion (post-order) order.

data/lib/moxml/error.rb

@@ -144,4 +144,7 @@ module Moxml
       msg
     end
   end
+
+  # Error raised when XSLT compilation or transformation fails
+  class XsltError < Error; end
 end

data/lib/moxml/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Moxml
-  VERSION = "0.5.97"
+  VERSION = "0.5.98"
 end

data/lib/moxml/xslt/stylesheet.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+module Moxml
+  module XSLT
+    # A compiled stylesheet bound to one adapter context. Apply to
+    # documents parsed by the same adapter; cross-adapter documents
+    # take the serialized path (to_xml -> engine -> parse).
+    class Stylesheet
+      # @api adapter — the engine's compiled stylesheet handle
+      attr_reader :native
+
+      def initialize(native_sheet, context)
+        @native = native_sheet
+        @context = context
+        @adapter = context.config.adapter
+      end
+
+      # Transform +document+ and return the result as a
+      # Moxml::Document of this stylesheet's adapter.
+      #
+      # Stylesheets whose output method is not XML raise
+      # Moxml::XsltError — the serialized form is available through
+      # apply_to_string.
+      #
+      # @param params [Hash] top-level stylesheet parameters
+      #   (name => string value); engines without a params face
+      #   raise Moxml::XsltError when non-empty
+      def apply_to(document, params: {})
+        quoted = quote_params(params)
+        return apply_cross_adapter(document, quoted) unless same_adapter?(document)
+
+        result = @adapter.xslt_apply_document(@native, document.native, quoted)
+        return parse_serialized(document, quoted) if result.nil?
+
+        wrapped = Wrappers::Document.new(result, @context)
+        # Engines differ on non-XML output: leptris returns nil, nokogiri
+        # wraps the text into a rootless document. Normalize to a typed
+        # error — apply_to_string carries non-XML output.
+        raise XsltError, non_xml_message if wrapped.root.nil?
+
+        wrapped
+      end
+
+      # Transform +document+ and return the engine-serialized output.
+      # Preserves result fragments and text output that the document
+      # face cannot represent.
+      def apply_to_string(document, params: {})
+        quoted = quote_params(params)
+        return apply_cross_adapter_string(document, quoted) unless same_adapter?(document)
+
+        @adapter.xslt_apply_string(@native, document.native, quoted)
+      end
+
+      private
+
+      def same_adapter?(document)
+        document.context.config.adapter.equal?(@adapter)
+      end
+
+      # Cross-adapter documents serialize through their own adapter
+      # and re-parse into the stylesheet's engine — the engine cannot
+      # share its tree across adapters.
+      def apply_cross_adapter(document, quoted)
+        engine_doc = @context.parse(document.to_xml)
+        result = @adapter.xslt_apply_document(@native, engine_doc.native, quoted)
+        return parse_serialized(engine_doc, quoted) if result.nil?
+
+        Wrappers::Document.new(result, @context)
+      end
+
+      def apply_cross_adapter_string(document, quoted)
+        engine_doc = @context.parse(document.to_xml)
+        @adapter.xslt_apply_string(@native, engine_doc.native, quoted)
+      end
+
+      def parse_serialized(document, quoted)
+        @context.parse(@adapter.xslt_apply_string(@native, document.native, quoted))
+      rescue Moxml::ParseError
+        raise XsltError, non_xml_message
+      end
+
+      def non_xml_message
+        "transform output is not XML (output method text?); use apply_to_string"
+      end
+
+      def quote_params(params)
+        return [] if params.nil? || params.empty?
+
+        XSLT.quote_params(params)
+      end
+    end
+  end
+end

data/lib/moxml/xslt.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Moxml
+  # XSLT transformation. Implementation-agnostic over engines that
+  # ship an XSLT processor (currently nokogiri/libxslt and leptris;
+  # leptris additionally covers XSLT 2.0/3.0 per its engine).
+  #
+  #     ctx    = Moxml.new(:nokogiri)
+  #     sheet  = ctx.xslt(<<~XSL)
+  #       <xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform" version="1.0">
+  #         <xsl:template match="/"><out><xsl:value-of select="count(//i)"/></out></xsl:template>
+  #       </xsl:stylesheet>
+  #     XSL
+  #     sheet.apply_to(doc)          # => Moxml::Document (same adapter)
+  #     sheet.apply_to_string(doc)   # => String (engine-serialized output;
+  #                                  #    fragments and text output preserved)
+  #
+  # Adapters without an engine raise Moxml::NotImplementedError at
+  # compile; Moxml::XSLT.supported?(context) answers without raising.
+  #
+  # Stylesheet top-level parameters are part of the contract but not
+  # every engine threads them yet — passing non-empty params to an
+  # engine without the face raises Moxml::XsltError (leptris:
+  # leptris-ruby#360).
+  module XSLT
+    autoload :Stylesheet, "moxml/xslt/stylesheet"
+
+    SUPPORTED_ADAPTERS = %i[nokogiri leptris].freeze
+
+    class << self
+      # Whether the context's adapter ships an XSLT engine. Answers
+      # without raising; compile raises Moxml::NotImplementedError
+      # regardless (the capability probe is advisory).
+      def supported?(context)
+        adapter = context.config.adapter
+        adapter.const_defined?(:XSLT_SUPPORTED) &&
+          adapter.const_get(:XSLT_SUPPORTED)
+      end
+
+      # Quote XSLT top-level string parameters into the flat
+      # name/value list libxslt-family engines accept. Values are
+      # single-quoted; embedded quotes are escaped.
+      def quote_params(params)
+        params.flat_map do |name, value|
+          quoted = "'#{value.to_s.gsub("'", %q{'\''})}'"
+          [name.to_s, quoted]
+        end
+      end
+    end
+  end
+end

data/lib/moxml.rb

@@ -100,6 +100,7 @@ module Moxml
   autoload :SAX, "moxml/sax"
   autoload :Signature, "moxml/signature"
   autoload :C14n, "moxml/c14n"
+  autoload :XSLT, "moxml/xslt"
 
   # Error hierarchy — each subclass autoloads from the same file
   autoload :Error, "moxml/error"
@@ -111,4 +112,5 @@ module Moxml
   autoload :EntityDataError, "moxml/error"
   autoload :XPathError, "moxml/error"
   autoload :AdapterError, "moxml/error"
+  autoload :XsltError, "moxml/error"
 end

data/spec/consistency/xslt_spec.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require "moxml/c14n"
+
+# Cross-engine agreement for the Moxml::XSLT contract. The corpus
+# sticks to XSLT 1.0 shapes (the common denominator — nokogiri/
+# libxslt speaks 1.0 only; leptris additionally covers 2.0/3.0 in its
+# own suite). apply_to_string output is engine-serialized: the
+# comparison strips a leading declaration when the engines disagree
+# on emitting one.
+SUPPORTED = %i[nokogiri leptris].select do |name|
+  Moxml::Adapter::AVAILABLE_ADAPTERS.include?(name)
+end.freeze
+
+CORPUS = {
+  "value-of with count" => [
+    <<~XSL,
+      <xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform" version="1.0">
+        <xsl:template match="/"><out><xsl:value-of select="count(//i)"/></out></xsl:template>
+      </xsl:stylesheet>
+    XSL
+    "<r><i>1</i><i>2</i></r>",
+    /<out>2<\/out>/,
+  ],
+  "for-each with sort" => [
+    <<~XSL,
+      <xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform" version="1.0">
+        <xsl:template match="/">
+          <out><xsl:for-each select="//i"><xsl:sort select="." order="descending"/><v><xsl:value-of select="."/></v></xsl:for-each></out>
+        </xsl:template>
+      </xsl:stylesheet>
+    XSL
+    "<r><i>3</i><i>1</i><i>2</i></r>",
+    /<v>3<\/v>\s*<v>2<\/v>\s*<v>1<\/v>/,
+  ],
+  "copy-of" => [
+    <<~XSL,
+      <xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform" version="1.0">
+        <xsl:template match="/"><out><xsl:copy-of select="//keep/*"/></out></xsl:template>
+      </xsl:stylesheet>
+    XSL
+    %(<r><keep><a x="1">t</a></keep></r>),
+    /<a x="1">t<\/a>/,
+  ],
+  "named template" => [
+    <<~XSL,
+      <xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform" version="1.0">
+        <xsl:template match="/"><out><xsl:call-template name="greet"/></out></xsl:template>
+        <xsl:template name="greet">hi</xsl:template>
+      </xsl:stylesheet>
+    XSL
+    "<r/>",
+    /<out>hi<\/out>/,
+  ],
+  "attribute value template" => [
+    <<~XSL,
+      <xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform" version="1.0">
+        <xsl:template match="/"><out n="{count(//i)}"/></xsl:template>
+      </xsl:stylesheet>
+    XSL
+    "<r><i/><i/></r>",
+    /<out\s+n="2"\s*\/?>/,
+  ],
+  "namespaced output" => [
+    <<~XSL,
+      <xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform" xmlns:o="urn:o" version="1.0">
+        <xsl:template match="/"><o:out><xsl:value-of select="//t"/></o:out></xsl:template>
+      </xsl:stylesheet>
+    XSL
+    "<r><t>v</t></r>",
+    /<[^>]*:out[^>]*>v<\/[^>]*:out>/,
+  ],
+}.freeze
+
+RSpec.describe "Moxml::XSLT cross-engine agreement" do
+  SUPPORTED.each do |adapter_name|
+    context "with the #{adapter_name} adapter" do
+      let(:ctx) { Moxml.new(adapter_name) }
+
+      def result_body(output)
+        output.sub(/\A<\?xml[^>]*\?>\s*/, "")
+      end
+
+      CORPUS.each do |label, (sheet_xml, input, expected_re)|
+        it "transforms #{label}" do
+          sheet = ctx.xslt(sheet_xml)
+          doc = ctx.parse(input)
+          expect(result_body(sheet.apply_to_string(doc))).to match(expected_re)
+          expect(sheet.apply_to(doc).to_xml).to match(expected_re)
+        end
+      end
+    end
+  end
+
+  it "agrees across engines on the corpus" do
+    return unless SUPPORTED.size == 2
+
+    first, second = SUPPORTED.map { |name| Moxml.new(name) }
+    CORPUS.each do |label, (sheet_xml, input, _)|
+      a = first.xslt(sheet_xml).apply_to_string(first.parse(input))
+      b = second.xslt(sheet_xml).apply_to_string(second.parse(input))
+      expect(Moxml::C14n.equivalent?(a, b))
+        .to(be(true), "#{label}: engines disagree\n a=#{a.inspect}\n b=#{b.inspect}")
+    end
+  end
+end

data/spec/moxml/adapter/leptris_spec.rb

@@ -509,7 +509,16 @@ RSpec.describe Moxml::Adapter::Leptris do
       # The binding retains a constant one-document wrapper set of
       # its own; moxml must not retain beyond a couple of dropped
       # documents' worth (was: all 20 pinned under the strong map).
-      expect(count.call - before).to be < 2 * 51
+      if Moxml::Context::WEAK_WRAPPERS
+        expect(count.call - before).to be < 2 * 51
+      else
+        # MRI < 3.4 strong registry (moxml#303): entries are bounded
+        # by the to_binding valve instead of weakly released — no
+        # unbounded pinning, but dropped documents stay until the
+        # clear. Assert the bound, not weak-release semantics.
+        cap = Moxml::Adapter::Leptris::BINDING_OF_CAP
+        expect(count.call - before).to be <= cap
+      end
     end
 
     it "keeps wrapper identity while a document is alive" do

data/spec/moxml/xslt/stylesheet_spec.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+# The Moxml::XSLT contract: compile once, apply many. Only engines
+# with an XSLT processor implement it (nokogiri/libxslt; leptris
+# covering XSLT 1.0-3.0). leptris does not thread top-level params
+# yet (leptris-ruby#360) — non-empty params raise Moxml::XsltError.
+SHEET_COUNT = <<~XSL
+  <xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform" version="1.0">
+    <xsl:template match="/"><out><xsl:value-of select="count(//i)"/></out></xsl:template>
+  </xsl:stylesheet>
+XSL
+
+RSpec.describe "Moxml::XSLT" do
+  let(:ctx) { Moxml.new(adapter_name) }
+  let(:doc) { ctx.parse("<r><i>1</i><i>2</i></r>") }
+
+  context "with the nokogiri adapter" do
+    let(:adapter_name) { :nokogiri }
+
+    it "compiles and applies to a document" do
+      sheet = ctx.xslt(SHEET_COUNT)
+      expect(sheet.apply_to(doc).root.name).to eq("out")
+      expect(sheet.apply_to(doc).root.text).to eq("2")
+    end
+
+    it "returns engine-serialized output as a string" do
+      sheet = ctx.xslt(SHEET_COUNT)
+      expect(sheet.apply_to_string(doc)).to include("<out>2</out>")
+    end
+
+    it "threads top-level params" do
+      sheet = ctx.xslt(<<~XSL)
+        <xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform" version="1.0">
+          <xsl:param name="n" select="'0'"/>
+          <xsl:template match="/"><out><xsl:value-of select="$n"/></out></xsl:template>
+        </xsl:stylesheet>
+      XSL
+      expect(sheet.apply_to_string(doc, params: { "n" => "7" })).to include("7")
+    end
+
+    it "raises XsltError on a malformed stylesheet" do
+      expect { ctx.xslt("<not-a-stylesheet/>") }
+        .to raise_error(Moxml::XsltError, /compile failed/)
+    end
+
+    it "raises XsltError on a broken transform" do
+      sheet = ctx.xslt(<<~XSL)
+        <xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform" version="1.0">
+          <xsl:template match="/"><out><xsl:value-of select="$undefined"/></out></xsl:template>
+        </xsl:stylesheet>
+      XSL
+      expect { sheet.apply_to(doc) }.to raise_error(Moxml::XsltError)
+    end
+
+    it "reports support" do
+      expect(Moxml::XSLT.supported?(ctx)).to be(true)
+    end
+  end
+
+  context "with the leptris adapter" do
+    let(:adapter_name) { :leptris }
+
+    it "compiles and applies to a document" do
+      sheet = ctx.xslt(SHEET_COUNT)
+      expect(sheet.apply_to(doc).root.name).to eq("out")
+      expect(sheet.apply_to(doc).root.text).to eq("2")
+    end
+
+    it "preserves fragments through the string face" do
+      sheet = ctx.xslt(<<~XSL)
+        <xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform" version="1.0">
+          <xsl:template match="/">plain text result</xsl:template>
+        </xsl:stylesheet>
+      XSL
+      expect(sheet.apply_to_string(doc)).to include("plain text result")
+    end
+
+    it "raises XsltError on non-empty params (leptris-ruby#360)" do
+      sheet = ctx.xslt(SHEET_COUNT)
+      expect { sheet.apply_to(doc, params: { "n" => "7" }) }
+        .to raise_error(Moxml::XsltError, /params.*#360/)
+    end
+
+    it "reports support" do
+      expect(Moxml::XSLT.supported?(ctx)).to be(true)
+    end
+  end
+
+  context "with an adapter without an engine" do
+    let(:ctx) { Moxml.new(:rexml) }
+
+    it "raises NotImplementedError at compile" do
+      expect { ctx.xslt(SHEET_COUNT) }
+        .to raise_error(Moxml::NotImplementedError, /nokogiri, leptris/)
+    end
+
+    it "answers supported? false" do
+      expect(Moxml::XSLT.supported?(ctx)).to be(false)
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: moxml
 version: !ruby/object:Gem::Version
-  version: 0.5.97
+  version: 0.5.98
 platform: ruby
 authors:
 - Ribose Inc.
@@ -293,6 +293,8 @@ files:
 - lib/moxml/xpath/parser.rb
 - lib/moxml/xpath/ruby/generator.rb
 - lib/moxml/xpath/ruby/node.rb
+- lib/moxml/xslt.rb
+- lib/moxml/xslt/stylesheet.rb
 - moxml.gemspec
 - old-specs/moxml/adapter/customized_libxml/.gitkeep
 - reference-docs/w3c-xmldsig-bestpractices.md
@@ -304,6 +306,7 @@ files:
 - spec/consistency/adapter_parity_spec.rb
 - spec/consistency/eol_normalization_spec.rb
 - spec/consistency/round_trip_spec.rb
+- spec/consistency/xslt_spec.rb
 - spec/examples/README.md
 - spec/examples/attribute_examples_spec.rb
 - spec/examples/basic_usage_spec.rb
@@ -555,6 +558,7 @@ files:
 - spec/moxml/xpath/ruby/node_spec.rb
 - spec/moxml/xpath_capabilities_spec.rb
 - spec/moxml/xpath_spec.rb
+- spec/moxml/xslt/stylesheet_spec.rb
 - spec/performance/README.md
 - spec/performance/benchmark_spec.rb
 - spec/performance/memory_usage_spec.rb