leptris 1.9.197.2-arm-linux

data/leptris.gemspec

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require_relative "lib/leptris/version"
+
+Gem::Specification.new do |spec|
+  spec.name = "leptris"
+  spec.version = Leptris::VERSION
+  spec.authors = ["Ribose Inc."]
+  spec.email = ["open.source@ribose.com"]
+
+  spec.summary = "Nokogiri-compatible Ruby binding for libleptris (XML 1.0, XPath 1.0, SAX)"
+  spec.description = <<~DESC
+    Leptris is a Nokogiri-compatible Ruby binding for libleptris, a pure-C99 XML
+    1.0 parser with full XPath 1.0 and SAX support. The C DOM is the single
+    source of truth; Ruby objects are thin FFI wrappers (one Ruby method =
+    one FFI call).
+  DESC
+  spec.homepage = "https://github.com/leptris/leptris-ruby"
+  spec.license = "MIT"
+  spec.required_ruby_version = ">= 3.0.0"
+
+  spec.metadata = {
+    "homepage_uri" => spec.homepage,
+    "source_code_uri" => "https://github.com/leptris/leptris-ruby",
+    "changelog_uri" => "https://github.com/leptris/leptris-ruby/blob/main/CHANGELOG.md",
+  }
+
+  spec.files = Dir.chdir(__dir__) do
+    `git ls-files -z`.split("\x0").reject do |f|
+      (File.expand_path(f) == __FILE__) ||
+        f.start_with?(*%w[bin/ test/ spec/ features/ benchmark/ .git .github
+                         appveyor Gemfile .rspec .rubocop.yml])
+    end
+  end
+  spec.bindir = "bin"
+  spec.executables = []
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "ffi", "~> 1.15"
+
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec"
+end

data/lib/leptris/version.rb

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

data/lib/leptris/xml/attr.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+# 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
+
+  # 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)
+    @element[@name] = new_value
+    @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
+    i = @name.index(":")
+    i ? @name[0, i] : 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
+    namespace_uri
+  end
+
+  def remove
+    @element.remove_attribute(@name)
+  end
+
+  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 — single pass, no chained gsubs.
+  ESCAPE_TABLE = {
+    "&" => "&amp;", "<" => "&lt;", ">" => "&gt;",
+    '"' => "&quot;", "'" => "&apos;",
+  }.freeze
+  private_constant :ESCAPE_TABLE
+
+  def to_xml
+    "#{@name}=\"#{@value.to_s.gsub(/[&<>"']/, ESCAPE_TABLE)}\""
+  end
+
+  def ==(other)
+    other.is_a?(Leptris::XML::Attr) &&
+      @name == other.name && @value == other.value &&
+      @element == other.element
+  end
+
+  def inspect
+    "#<#{self.class.name} name=#{@name.inspect} value=#{@value.inspect}>"
+  end
+end

data/lib/leptris/xml/c_string_array.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+# Adapter for libleptris's NULL-terminated char** wire format. Both
+# directions of the conversion live here so the pointer arithmetic has
+# one home (previously c14n built the array by hand and SAX walked it
+# by hand).
+module Leptris::XML::CStringArray
+  # Ruby strings -> NULL-terminated char**. Returns [buffer, anchors];
+  # the caller must keep both referenced for the duration of the FFI
+  # call (e.g. via local variables).
+  def self.to_c(strings)
+    strs = Array(strings).map(&:to_s)
+    return [nil, nil] if strs.empty?
+
+    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
+
+  # NULL-terminated char** -> Ruby strings. Stops at the first NULL
+  # entry. Returns [] for a NULL pointer.
+  def self.to_ruby(ptr)
+    return [] if ptr.nil? || ptr.null?
+
+    ptr_size = ::FFI::type_size(:pointer)
+    result = []
+    offset = 0
+    while (entry = ptr.get_pointer(offset)) && !entry.null?
+      result << entry.read_string.force_encoding(Encoding::UTF_8)
+      offset += ptr_size
+    end
+    result
+  end
+end

data/lib/leptris/xml/cdata.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+class Leptris::XML::CDATA < Leptris::XML::Text
+  def name; "#cdata-section"; end
+
+  def content
+    return @content if memo_hit?(@content_version)
+    ensure_alive!
+    result = if @addr_reads_fast
+               Leptris::XML::Native.fast_cdata_content(@c_address)
+             else
+               Leptris::XML::FFI.leptris_cdata_node_get_content(c_ptr)
+             end
+    if @document
+      @content = result
+      @content_version = @document.version
+    end
+    result
+  end
+
+  def content=(new_content)
+    ensure_writable!
+    Leptris::XML::FFI.check_status(
+      Leptris::XML::FFI.leptris_cdata_node_set_content(c_ptr, new_content.to_s))
+    new_content
+  end
+end

data/lib/leptris/xml/comment.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+class Leptris::XML::Comment < Leptris::XML::Node
+  def name; "comment"; end
+
+  def content
+    return @content if memo_hit?(@content_version)
+    ensure_alive!
+    result = if @addr_reads_fast
+               Leptris::XML::Native.fast_comment_content(@c_address)
+             else
+               Leptris::XML::FFI.leptris_comment_node_get_content(c_ptr)
+             end
+    if @document
+      @content = result
+      @content_version = @document.version
+    end
+    result
+  end
+
+  def content=(new_content)
+    ensure_writable!
+    Leptris::XML::FFI.check_status(
+      Leptris::XML::FFI.leptris_comment_node_set_content(c_ptr, new_content.to_s))
+    new_content
+  end
+end

data/lib/leptris/xml/css_to_xpath.rb

@@ -0,0 +1,192 @@
+# frozen_string_literal: true
+
+module Leptris
+  module XML
+    # Minimal CSS-to-XPath translator covering the common Nokogiri subset:
+    #
+    #   tag                    → //tag
+    #   *                      → //*
+    #   .class                 → //*[contains(concat(' ',@class,' '),' class ')]
+    #   #id                    → //*[@id='id']
+    #   [attr]                 → //*[@attr]
+    #   [attr=val]             → //*[@attr='val']
+    #   tag[attr]              → //tag[@attr]
+    #   tag[attr=val]          → //tag[@attr='val']
+    #   parent > child         → //parent/child
+    #   ancestor descendant    → //ancestor//descendant
+    #   a, b                   → //a | //b
+    #   tag:first-child        → //tag[position()=1]
+    #   tag:last-child         → //tag[position()=last()]
+    #   tag:not(simple)        → //tag[not(self::simple)]
+    #
+    # For anything beyond this subset, raise ArgumentError. Callers can fall
+    # back to writing XPath directly via #xpath/#at_xpath.
+    module CssToXPath
+      COMMA_SPLIT = /\s*,\s*/.freeze
+      private_constant :COMMA_SPLIT
+
+      # Token types in a single simple selector.
+      # tag (optional), then zero or more of: .class, #id, [attr...], :pseudo
+      TAG_RE        = /\A(\*|[\w-]+)/.freeze
+      DOT_CLASS_RE  = /\A\.([\w-]+)/.freeze
+      HASH_ID_RE    = /\A#([\w-]+)/.freeze
+      BRACKET_RE    = /\A\[([^\]]+)\]/.freeze
+      PSEUDO_RE     = /\A:([\w-]+(?:\([^)]*\))?)/.freeze
+
+      module_function
+
+      # Translation is a pure function of the rule string AND the
+      # context prefix, and real workloads repeat a small selector
+      # vocabulary in loops — memoize. Failed translations raise
+      # before caching. +prefix+ scopes the result: "//" for
+      # document receivers, ".//" for elements and fragments
+      # (Nokogiri receiver-relative semantics).
+      CACHE = {}
+      private_constant :CACHE
+
+      def convert(rule, prefix: "//")
+        key = "#{prefix}\t#{rule}"
+        CACHE.fetch(key) { CACHE[key] = convert_rule(rule, prefix) }
+      end
+
+      def convert_rule(rule, prefix)
+        rule.split(COMMA_SPLIT)
+          .map { |r| convert_one(r.strip, prefix) }.join(" | ")
+      end
+
+      def convert_one(rule, prefix)
+        return "#{prefix}*" if rule == "*"
+
+        # Tokenize chain first (handles > and whitespace)
+        if rule =~ /\s/ || rule.include?(">")
+          return convert_chain(rule, prefix)
+        end
+
+        convert_simple(rule, prefix: prefix)
+      end
+
+      # Parse a single simple selector into (tag, predicates) where
+      # predicates is an array of XPath fragments to be joined via [p1][p2]...
+      def parse_simple(part)
+        tag = "*"
+        preds = []
+
+        s = part.strip
+        if s =~ TAG_RE
+          tag = $1
+          s = $'
+        end
+
+        until s.empty?
+          case s
+          when DOT_CLASS_RE
+            preds << "contains(concat(' ',normalize-space(@class),' '),' #{$1} ')"
+            s = $'
+          when HASH_ID_RE
+            preds << "@id='#{$1}'"
+            s = $'
+          when BRACKET_RE
+            preds << convert_attrs($1)
+            s = $'
+          when PSEUDO_RE
+            preds << convert_pseudo($1)
+            s = $'
+          else
+            raise ArgumentError,
+              "unsupported CSS selector at #{s.inspect} (in #{part.inspect})"
+          end
+        end
+
+        [tag, preds]
+      end
+
+      def convert_simple(part, prefix:)
+        tag, preds = parse_simple(part)
+        "#{prefix}#{tag}#{preds.map { |p| "[#{p}]" }.join}"
+      end
+      private_class_method :convert_simple
+
+      def convert_attrs(clause)
+        case clause.strip
+        when /\A(\w+)\z/
+          "@#{$1}"
+        when /\A(\w+)=['"]?([^'"\]]+)['"]?\z/
+          "@#{$1}='#{$2}'"
+        when /\A(\w+)~=['"]?([^'"\]]+)['"]?\z/
+          "contains(concat(' ',normalize-space(@#{$1}),' '),' #{$2} ')"
+        when /\A(\w+)\^=['"]?([^'"\]]+)['"]?\z/
+          "starts-with(@#{$1}, '#{$2}')"
+        when /\A(\w+)\$=['"]?([^'"\]]+)['"]?\z/
+          "substring(@#{$1}, string-length(@#{$1}) - string-length('#{$2}') + 1) = '#{$2}'"
+        when /\A(\w+)\*=['"]?([^'"\]]+)['"]?\z/
+          "contains(@#{$1}, '#{$2}')"
+        else
+          raise ArgumentError, "unsupported attribute selector: [#{clause}]"
+        end
+      end
+      private_class_method :convert_attrs
+
+      def convert_pseudo(pseudo)
+        case pseudo
+        when "first-child"     then "not(preceding-sibling::*)"
+        when "last-child"      then "not(following-sibling::*)"
+        when "only-child"      then "not(preceding-sibling::* or following-sibling::*)"
+        when "empty"           then "not(node())"
+        when "root"            then "not(parent::*)"
+        when /\Anot\((.+)\)\z/
+          inner_tag, _ = parse_simple($1)
+          "not(self::#{inner_tag})"
+        else
+          raise ArgumentError, "unsupported pseudo-class: :#{pseudo}"
+        end
+      end
+      private_class_method :convert_pseudo
+
+      # Tokenize chain into [sel, op, sel, op, sel, ...] where op is :child or
+      # :descendant. Then build XPath.
+      def convert_chain(rule, prefix)
+        tokens = tokenize_chain(rule)
+        build_chain_xpath(tokens, prefix)
+      end
+      private_class_method :convert_chain
+
+      def tokenize_chain(rule)
+        tokens = []
+        s = rule.strip
+        until s.empty?
+          if s.sub!(/\A\s*>\s*/, "")
+            tokens << :child
+          elsif s.sub!(/\A\s+/, "")
+            # whitespace descendant only counts if previous token is a string
+            tokens << :descendant if tokens.last.is_a?(String)
+          else
+            # Read one simple selector — keep going until whitespace or > or end
+            m = s.match(/\A[^>\s]+/)
+            raise ArgumentError, "couldn't parse CSS chain at: #{s.inspect}" unless m
+            tokens << m[0]
+            s = m.post_match
+          end
+        end
+        tokens
+      end
+      private_class_method :tokenize_chain
+
+      def build_chain_xpath(tokens, prefix)
+        first = tokens.shift
+        raise ArgumentError, "empty CSS chain" unless first.is_a?(String)
+
+        xpath = convert_simple(first, prefix: prefix)
+        until tokens.empty?
+          op = tokens.shift
+          sel = tokens.shift
+          raise ArgumentError, "malformed CSS chain" unless sel.is_a?(String)
+          inner_tag, preds = parse_simple(sel)
+          connector = op == :child ? "/" : "//"
+          xpath = "#{xpath}#{connector}#{inner_tag}#{preds.map { |p| "[#{p}]" }.join}"
+        end
+        xpath
+      end
+      private_class_method :build_chain_xpath
+    end
+  end
+end

data/lib/leptris/xml/descriptor.rb

@@ -0,0 +1,214 @@
+# frozen_string_literal: true
+
+require "ffi"
+
+# Tree-shaped schema-descriptor materialization (libleptris 1.9.162,
+# upstream #1039): compile a plan tree once, then materialize a whole
+# subtree against it in ONE native pass — no per-element Ruby calls
+# (#185's class of cost). Children the plan does not describe are
+# skipped; matches within a row keep document order.
+#
+#     descriptor = Leptris::XML::Descriptor.build(
+#       name: "catalog",
+#       attributes: [{ name: "version", kind: :scalar }],
+#       children: [
+#         { name: "item", kind: :nested, plan: {
+#             name: "item",
+#             attributes: [{ name: "id", kind: :scalar }],
+#             children: [
+#               { name: "name", kind: :scalar },
+#               { name: "price", kind: :scalar },
+#             ] } },
+#       ])
+#     descriptor.walk(doc.root).to_ruby
+#
+# Plan rows: :scalar, :collection (repeated matches), :nested (recurse
+# via +plan:+), :raw (serialized subtree), :content (mixed-content
+# text runs), :callback (raw value + byte position + type_tag echo).
+# Namespace binding per plan: +ns:+ is :none (default), :any, or
+# { exact: "urn:..." }; +flags: [:mixed_content, :ordered, :cdata,
+# :ns_lenient].
+class Leptris::XML::Descriptor
+  class Handle < ::FFI::AutoPointer
+    def self.release(ptr)
+      Leptris::XML::FFI.leptris_plan_free(ptr)
+    end
+  end
+
+  class ResultHandle < ::FFI::AutoPointer
+    def self.release(ptr)
+      Leptris::XML::FFI.leptris_plan_result_free(ptr)
+    end
+  end
+
+  KINDS = {
+    scalar: Leptris::XML::FFI::PLAN_KIND_SCALAR,
+    collection: Leptris::XML::FFI::PLAN_KIND_COLLECTION,
+    nested: Leptris::XML::FFI::PLAN_KIND_NESTED,
+    raw: Leptris::XML::FFI::PLAN_KIND_RAW,
+    content: Leptris::XML::FFI::PLAN_KIND_CONTENT,
+    callback: Leptris::XML::FFI::PLAN_KIND_CALLBACK,
+  }.freeze
+  private_constant :KINDS
+
+  FLAGS = {
+    mixed_content: Leptris::XML::FFI::PLAN_FLAG_MIXED_CONTENT,
+    ordered: Leptris::XML::FFI::PLAN_FLAG_ORDERED,
+    cdata: Leptris::XML::FFI::PLAN_FLAG_CDATA,
+    ns_lenient: Leptris::XML::FFI::PLAN_FLAG_NS_LENIENT,
+  }.freeze
+  private_constant :FLAGS
+
+  attr_reader :root
+
+  # +tree+ is the root plan (the hash shape documented on the
+  # class). Returns the compiled, engine-owned descriptor; the
+  # Ruby-side spec memory is transient (the engine deep-copies).
+  def self.build(tree)
+    abi = Leptris::XML::FFI.leptris_plan_abi_version
+    if abi != Leptris::XML::FFI::PLAN_ABI_VERSION
+      raise Leptris::XML::Error,
+        "descriptor ABI v#{abi} != binding v#{Leptris::XML::FFI::PLAN_ABI_VERSION}"
+    end
+    plans = []
+    root_index = flatten_plan(tree, plans)
+    spec, plans_pointer, anchors = pack_plans(plans)
+    spec[:abi_version] = abi
+    spec[:plan_count] = plans.size
+    spec[:plans] = plans_pointer
+    status = ::FFI::MemoryPointer.new(:int)
+    raw = Leptris::XML::FFI.leptris_plan_build(spec.pointer, status)
+    if raw.null?
+      raise Leptris::XML::Error,
+        "plan build failed (status=#{status.read_int})"
+    end
+    new(Handle.new(raw), plans, root_index)
+  end
+
+  # Flattens the nested hash tree into the engine's flat plans
+  # array (child rows reference plans by index). Returns the root
+  # plan's index — always 0 for a single root.
+  def self.flatten_plan(tree, plans)
+    tree = tree.dup
+    plans << tree
+    tree_index = plans.size - 1
+    tree[:children] = (tree[:children] || []).map do |row|
+      if row[:kind] == :nested
+        row.merge(child_plan_index: flatten_plan(row.fetch(:plan), plans))
+      else
+        row
+      end
+    end
+    tree_index
+  end
+  private_class_method :flatten_plan
+
+  # Packs the flattened plans into FFI memory: one ElementPlan per
+  # plan plus one AttrPlan/ChildPlan row per attribute/child. Every
+  # C string and row array is anchored in Ruby until the build call
+  # returns (the engine deep-copies).
+  def self.pack_plans(plans)
+    anchors = [nil]
+    plan_memory = ::FFI::MemoryPointer.new(
+      Leptris::XML::FFI::ElementPlan, plans.size)
+    anchors[0] = plan_memory
+    plans.each_with_index do |plan, i|
+      ep = Leptris::XML::FFI::ElementPlan.new(plan_memory[i])
+      ep[:element_name] = anchor_string(anchors, plan.fetch(:name))
+      ns = plan[:ns]
+      ns_form, ns_uri =
+        case ns
+        when nil, :none then [Leptris::XML::FFI::PLAN_NS_NONE, nil]
+        when :any then [Leptris::XML::FFI::PLAN_NS_ANY, nil]
+        when Hash
+          [Leptris::XML::FFI::PLAN_NS_EXACT,
+           anchor_string(anchors, ns.fetch(:exact))]
+        else
+          raise ArgumentError, "ns must be :none, :any, or {exact: uri}"
+        end
+      ep[:ns_form] = ns_form
+      ep[:ns_uri] = ns_uri
+      attrs = plan[:attributes] || []
+      attr_memory = attrs.empty? ? nil :
+        ::FFI::MemoryPointer.new(Leptris::XML::FFI::AttrPlan, attrs.size)
+      anchors << attr_memory
+      attrs.each_with_index do |row, j|
+        ap = Leptris::XML::FFI::AttrPlan.new(attr_memory[j])
+        ap[:wire_name] = anchor_string(anchors, row.fetch(:name))
+        ap[:kind] = kind_code(row[:kind] || :scalar)
+        ap[:type_tag] = row[:type_tag] || 0
+      end
+      ep[:attribute_count] = attrs.size
+      ep[:attribute_plans] = attr_memory
+      children = plan[:children] || []
+      child_memory = children.empty? ? nil :
+        ::FFI::MemoryPointer.new(Leptris::XML::FFI::ChildPlan, children.size)
+      anchors << child_memory
+      children.each_with_index do |row, j|
+        cp = Leptris::XML::FFI::ChildPlan.new(child_memory[j])
+        cp[:wire_name] = anchor_string(anchors, row.fetch(:name))
+        cp[:kind] = kind_code(row[:kind] || :scalar)
+        cp[:type_tag] = row[:type_tag] || 0
+        cp[:child_plan_index] = row[:child_plan_index] || -1
+        # Rule-level ns form (libleptris 1.9.178, #1115): siblings
+        # under one parent can require different URIs when set;
+        # defaults to NONE for backward compatibility.
+        cp[:ns_form] =
+          case row[:ns]
+          when :any then Leptris::XML::FFI::PLAN_NS_ANY
+          when Hash  then Leptris::XML::FFI::PLAN_NS_EXACT
+          else         Leptris::XML::FFI::PLAN_NS_NONE
+          end
+        cp[:ns_uri] =
+          row[:ns].is_a?(Hash) ?
+            anchor_string(anchors, row[:ns].fetch(:exact)) : nil
+      end
+      ep[:child_count] = children.size
+      ep[:child_plans] = child_memory
+      ep[:flags] = (plan[:flags] || []).map { |f| FLAGS.fetch(f) }.sum
+    end
+    [Leptris::XML::FFI::PlanSpec.new, plan_memory, anchors]
+  end
+  private_class_method :pack_plans
+
+  # Anchors the NUL-terminated copy in +anchors+ — the engine
+  # deep-copies at build, but the source bytes must live until the
+  # leptris_plan_build call returns.
+  def self.anchor_string(anchors, ruby_string)
+    ptr = ::FFI::MemoryPointer.from_string(ruby_string.to_s)
+    anchors << ptr
+    ptr
+  end
+  private_class_method :anchor_string
+
+  def self.kind_code(kind)
+    KINDS.fetch(kind) do
+      raise ArgumentError,
+        "kind must be one of #{KINDS.keys.inspect}, got #{kind.inspect}"
+    end
+  end
+  private_class_method :kind_code
+
+  def initialize(handle, plans, root_index)
+    @handle = handle
+    @plans = plans
+    @root_index = root_index
+  end
+
+  # Materializes the subtree rooted at +element_or_document+ (the
+  # root plan applies to the context node itself) in one native
+  # pass. Returns the lazy PlanValue tree — a standalone result
+  # that outlives the document.
+  def walk(element_or_document)
+    context = Leptris::XML::EvaluationContext.of(element_or_document)
+    status = ::FFI::MemoryPointer.new(:int)
+    raw = Leptris::XML::FFI.leptris_plan_walk(
+      context.document.c_ptr, context.context_node_ptr, @handle, status)
+    if raw.null?
+      raise Leptris::XML::Error,
+        "plan walk failed (status=#{status.read_int})"
+    end
+    Leptris::XML::PlanValue.new(ResultHandle.new(raw),
+                                owner: true, plans: @plans, plan: @plans[0])
+  end
+end