leptris 1.1.2-aarch64-linux

data/lib/leptris/xml/doc_type.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+class Leptris::XML::DocType
+  attr_reader :c_ptr, :document
+
+  def initialize(c_ptr, document)
+    @c_ptr = c_ptr
+    @document = document
+  end
+
+  def name
+    Leptris::XML::FFI.leptris_doctype_get_name(@c_ptr)
+  end
+  alias_method :node_name, :name
+
+  def root_name
+    Leptris::XML::FFI.leptris_doctype_get_root_name(@c_ptr)
+  end
+
+  def public_id
+    Leptris::XML::FFI.leptris_doctype_get_public_id(@c_ptr)
+  end
+
+  def system_id
+    Leptris::XML::FFI.leptris_doctype_get_system_id(@c_ptr)
+  end
+
+  def internal_subset
+    Leptris::XML::FFI.leptris_doctype_get_internal_subset(@c_ptr)
+  end
+
+  def external_id
+    pub = public_id
+    sys = system_id
+    return nil if pub.nil? && sys.nil?
+    parts = []
+    parts << "PUBLIC \"#{pub}\"" if pub
+    parts << "SYSTEM \"#{sys}\"" if sys && pub.nil?
+    parts << "\"#{sys}\"" if pub && sys
+    parts.join(" ")
+  end
+
+  def to_s
+    inner = internal_subset
+    parts = ["<!DOCTYPE #{name}"]
+    parts << external_id if external_id
+    parts << "[#{inner}]" if inner && !inner.empty?
+    parts.join(" ") + ">"
+  end
+
+  def inspect
+    "#<#{self.class.name} name=#{name.inspect} public=#{public_id.inspect} system=#{system_id.inspect}>"
+  end
+end

data/lib/leptris/xml/document.rb

@@ -0,0 +1,212 @@
+# frozen_string_literal: true
+
+require "ffi"
+
+class Leptris::XML::Document
+  attr_reader :c_ptr, :wrapper_cache
+
+  # @api private
+  # Internal flag container shared between the Document instance and its
+  # GC finalizer. Using a one-element Array because Procs close over
+  # variables by reference — mutating freed[0] is visible from both
+  # the explicit `free` path and the finalizer. This eliminates the
+  # double-free that FFI::AutoPointer's release proc caused when
+  # `Document#free` was called explicitly and then GC ran.
+  Freed = Struct.new(:state)  # state: :alive | :freed
+
+  def initialize(c_ptr = nil, freed = Freed.new(:alive))
+    @c_ptr = c_ptr
+    @freed = freed
+    # Per-document STRONG cache for Node wrappers, keyed on c_ptr
+    # address. Every wrapper is created through Node.wrap, which is the
+    # single construction path, so the same C node always yields the
+    # same Ruby object. Cleared when the Document is freed — no stale
+    # entries.
+    #
+    # Deliberately NOT ObjectSpace::WeakMap: a weak cache makes wrapper
+    # identity a GC race. `doc.root.equal?(doc.root)` failed on the
+    # Windows CI matrix (188 examples, the 4 identity specs) because
+    # between the two calls the first wrapper was referenced only by
+    # the weak map — any GC sweep evicted it and the second call built
+    # a fresh object. A strong cache costs at most one wrapper per node
+    # actually visited, held until the document dies.
+    @wrapper_cache = {}
+  end
+
+  def self.parse(xml_or_io, options: nil)
+    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)
+    status_ptr = ::FFI::MemoryPointer.new(:int)
+    raw =
+      if flags.zero?
+        Leptris::XML::FFI.leptris_parse_string(xml, xml.bytesize, status_ptr)
+      else
+        Leptris::XML::FFI.leptris_parse_string_flags(
+          xml, xml.bytesize, flags, status_ptr)
+      end
+    if raw.null?
+      status = status_ptr.read_int
+      raise Leptris::XML::ParseError,
+        "leptris_parse_string failed (status=#{status})"
+    end
+    wrap(raw)
+  end
+
+  def self.parse_file(path)
+    status_ptr = ::FFI::MemoryPointer.new(:int)
+    raw = Leptris::XML::FFI.leptris_parse_file(path, status_ptr)
+    if raw.null?
+      status = status_ptr.read_int
+      raise Leptris::XML::ParseError,
+        "leptris_parse_file failed (status=#{status})"
+    end
+    wrap(raw)
+  end
+
+  # Convert a raw LeptrisDocument pointer into a Ruby Document with safe
+  # GC lifetime management. The finalizer captures the raw address
+  # integer (not the Document or Pointer object — those would prevent
+  # GC) and shares a one-shot flag with the instance so explicit
+  # `#free` and the GC finalizer can never both call
+  # `leptris_document_free` on the same address.
+  def self.wrap(raw_address)
+    addr = raw_address.is_a?(::FFI::Pointer) ? raw_address.address : raw_address
+    ptr = ::FFI::Pointer.new(addr)
+    freed = Freed.new(:alive)
+    doc = new(ptr, freed)
+    ObjectSpace.define_finalizer(doc, finalizer(addr, freed))
+    doc
+  end
+
+  def self.finalizer(address, freed)
+    proc do
+      next if freed.state == :freed
+      freed.state = :freed
+      Leptris::XML::FFI.leptris_document_free(::FFI::Pointer.new(address))
+    end
+  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?
+    ptr = Leptris::XML::FFI.leptris_document_root(@c_ptr)
+    return nil if ptr.null?
+    Leptris::XML::Node.wrap(ptr, self)
+  end
+
+  def create_element(name)
+    ptr = Leptris::XML::FFI.leptris_element_create(@c_ptr, name)
+    raise Leptris::XML::Error, "leptris_element_create failed" if ptr.null?
+    Leptris::XML::Node.wrap(ptr, self)
+  end
+
+  def create_text_node(content)
+    ptr = Leptris::XML::FFI.leptris_text_node_create(@c_ptr, content.to_s)
+    raise Leptris::XML::Error, "leptris_text_node_create failed" if ptr.null?
+    Leptris::XML::Node.wrap(ptr, self)
+  end
+
+  def create_comment(content)
+    ptr = Leptris::XML::FFI.leptris_comment_node_create(@c_ptr, content.to_s)
+    raise Leptris::XML::Error, "leptris_comment_node_create failed" if ptr.null?
+    Leptris::XML::Node.wrap(ptr, self)
+  end
+
+  def create_cdata(content)
+    ptr = Leptris::XML::FFI.leptris_cdata_node_create(@c_ptr, content.to_s)
+    raise Leptris::XML::Error, "leptris_cdata_node_create failed" if ptr.null?
+    Leptris::XML::Node.wrap(ptr, self)
+  end
+
+  def create_processing_instruction(target, data = "")
+    ptr = Leptris::XML::FFI.leptris_pi_node_create(@c_ptr, target.to_s, data.to_s)
+    raise Leptris::XML::Error, "leptris_pi_node_create failed" if ptr.null?
+    Leptris::XML::Node.wrap(ptr, self)
+  end
+
+  def fragment(markup)
+    Leptris::XML::DocumentFragment.parse(markup, self)
+  end
+
+  def dup
+    raw = Leptris::XML::FFI.leptris_document_copy(@c_ptr)
+    raise Leptris::XML::Error, "leptris_document_copy failed" if raw.null?
+    self.class.wrap(raw)
+  end
+  alias_method :clone, :dup
+
+  def doctype
+    ptr = Leptris::XML::FFI.leptris_document_internal_subset(@c_ptr)
+    return nil if ptr.null?
+    Leptris::XML::DocType.new(ptr, self)
+  end
+  alias_method :internal_subset, :doctype
+
+  def to_xml(indent: 0, no_decl: false, encoding: nil)
+    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,
+      indent: indent, no_decl: no_decl, encoding: encoding)
+  end
+  alias_method :to_s, :to_xml
+  alias_method :serialize, :to_xml
+
+  def save(path, **opts)
+    opts_struct, _encoding_anchor = Leptris::XML::Serialization.build_options(
+      indent: opts.fetch(:indent, 0),
+      no_decl: opts.fetch(:no_decl, false),
+      encoding: opts[:encoding])
+    status = Leptris::XML::FFI.leptris_document_save_file(
+      @c_ptr, path, opts_struct.pointer)
+    Leptris::XML::FFI.check_status(status)
+    self
+  end
+
+  def canonicalize(version = Leptris::XML::FFI::C14N_1_0,
+                   inclusive_namespaces = nil,
+                   with_comments: false,
+                   exclusive: false,
+                   mode: nil)
+    raise Leptris::XML::UseAfterFreeError if @freed.state == :freed
+    return "" if @c_ptr.nil?
+    resolved_mode = mode || (exclusive ? Leptris::XML::FFI::C14N_MODE_EXCLUSIVE
+                                       : Leptris::XML::FFI::C14N_MODE_CANONICAL)
+    Leptris::XML::Serialization.canonicalize(
+      Leptris::XML::FFI.method(:leptris_c14n_canonicalize_ex), @c_ptr,
+      version: version, mode: resolved_mode,
+      inclusive_namespaces: inclusive_namespaces,
+      with_comments: with_comments)
+  end
+  alias_method :c14n, :canonicalize
+
+  def free
+    return if @freed.state == :freed
+    @freed.state = :freed
+    Leptris::XML::FFI.leptris_document_free(@c_ptr) unless @c_ptr.nil?
+    @c_ptr = nil
+    @wrapper_cache.clear
+  end
+
+  def name; "document"; end
+  def document; self; end
+  def encoding
+    return nil if @c_ptr.nil?
+    Leptris::XML::FFI.leptris_document_encoding(@c_ptr)
+  end
+
+  include Leptris::XML::Searchable
+end

data/lib/leptris/xml/document_fragment.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require "ffi"
+
+# Wraps the synthetic "#document-fragment" element returned by
+# leptris_parse_fragment. Children of this fragment are the parsed nodes;
+# the fragment itself isn't part of any document tree but borrows its
+# document's lifetime.
+class Leptris::XML::DocumentFragment
+  attr_reader :document, :c_ptr
+
+  def initialize(document, c_ptr)
+    @document = document
+    @c_ptr = c_ptr
+  end
+
+  def self.parse(xml, document)
+    status_ptr = ::FFI::MemoryPointer.new(:int)
+    raw = Leptris::XML::FFI.leptris_parse_fragment(
+      xml.to_s, xml.to_s.bytesize, document.c_ptr, status_ptr)
+    if raw.null?
+      raise Leptris::XML::ParseError,
+        "leptris_parse_fragment failed (status=#{status_ptr.read_int})"
+    end
+    new(document, raw)
+  end
+
+  def children
+    count = Leptris::XML::FFI.leptris_element_child_count(@c_ptr)
+    nodes = []
+    ptr = Leptris::XML::FFI.leptris_node_first_child(@c_ptr)
+    until ptr.nil? || ptr.null?
+      nodes << Leptris::XML::Node.wrap(ptr, @document)
+      ptr = Leptris::XML::FFI.leptris_node_next_sibling(ptr)
+    end
+    Leptris::XML::NodeSet.new(@document, nodes)
+  end
+
+  def name
+    "#document-fragment"
+  end
+end

data/lib/leptris/xml/element.rb

@@ -0,0 +1,259 @@
+# frozen_string_literal: true
+
+class Leptris::XML::Element < Leptris::XML::Node
+  def name
+    Leptris::XML::FFI.leptris_element_name(@c_ptr)
+  end
+  alias_method :node_name, :name
+
+  def name=(new_name)
+    Leptris::XML::FFI.check_status(
+      Leptris::XML::FFI.leptris_element_set_name(@c_ptr, new_name))
+    new_name
+  end
+  alias_method :node_name=, :name=
+
+  def content
+    Leptris::XML::FFI.leptris_element_text(@c_ptr)
+  end
+
+  def content=(new_content)
+    Leptris::XML::FFI.check_status(
+      Leptris::XML::FFI.leptris_element_set_text(@c_ptr, new_content.to_s))
+    new_content
+  end
+
+  def [](key)
+    Leptris::XML::FFI.leptris_element_attribute(@c_ptr, key.to_s)
+  end
+  alias_method :attr, :[]
+  alias_method :get_attribute, :[]
+
+  def []=(key, value)
+    Leptris::XML::FFI.check_status(
+      Leptris::XML::FFI.leptris_element_set_attribute(@c_ptr, key.to_s, value.to_s))
+    value
+  end
+  alias_method :set_attribute, :[]=
+
+  def key?(name)
+    Leptris::XML::FFI.leptris_element_has_attribute(@c_ptr, name.to_s) != 0
+  end
+  alias_method :has_attribute?, :key?
+
+  def remove_attribute(name)
+    Leptris::XML::FFI.check_status(
+      Leptris::XML::FFI.leptris_element_remove_attribute(@c_ptr, name.to_s))
+    self
+  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
+    each_attribute.to_a.map(&:name)
+  end
+
+  def values
+    each_attribute.to_a.map(&:value)
+  end
+
+  def attributes
+    result = {}
+    each_attribute { |attr| result[attr.name] = attr }
+    result
+  end
+
+  def attribute_nodes
+    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)
+    Leptris::XML::FFI.check_status(
+      Leptris::XML::FFI.leptris_element_prepend_child(@c_ptr, node.c_ptr))
+    node
+  end
+
+  def add_next_sibling(node)
+    Leptris::XML::FFI.check_status(
+      Leptris::XML::FFI.leptris_element_insert_after(@c_ptr, node.c_ptr))
+    node
+  end
+
+  def add_previous_sibling(node)
+    Leptris::XML::FFI.check_status(
+      Leptris::XML::FFI.leptris_element_insert_before(@c_ptr, node.c_ptr))
+    node
+  end
+
+  def remove_child(node)
+    Leptris::XML::FFI.check_status(
+      Leptris::XML::FFI.leptris_element_remove_child(@c_ptr, node.c_ptr))
+    node
+  end
+
+  def children=(node_or_nodes)
+    # Remove existing children, then attach the new ones in source order.
+    Leptris::XML::FFI.check_status(
+      Leptris::XML::FFI.leptris_element_remove_children(@c_ptr))
+    Array(node_or_nodes).each { |n| add_child(n) }
+  end
+
+  # Replace this element with +new_node+ in the parent's child list.
+  # +new_node+ must belong to the same document. Returns +new_node+.
+  def replace(new_node)
+    parent = self.parent
+    raise Leptris::XML::Error, "cannot replace a node with no parent" unless parent
+    add_next_sibling(new_node)
+    parent.remove_child(self)
+    new_node
+  end
+
+  # Like #replace but returns self for chaining.
+  def swap(new_node)
+    replace(new_node)
+    self
+  end
+
+  # Wrap this element in a new element parsed from +markup+ or a dup of
+  # +node+. The wrapper takes this element's place in the tree, and this
+  # element becomes its only child. Returns self for chaining.
+  def wrap(node_or_markup)
+    wrapper =
+      case node_or_markup
+      when Leptris::XML::Element then node_or_markup.dup
+      when String
+        frag_doc = Leptris::XML::Document.parse(node_or_markup)
+        frag_doc.root or raise Leptris::XML::Error, "wrap markup has no root element"
+      else
+        raise ArgumentError, "wrap expects a String or Element, got #{node_or_markup.class}"
+      end
+
+    parent = self.parent
+    raise Leptris::XML::Error, "cannot wrap a node with no parent" unless parent
+
+    # Insert wrapper at self's position, then move self into wrapper.
+    # add_child moves self (unlinks from old parent first), so no explicit
+    # remove_child needed — and trying to remove after the move corrupts
+    # the C tree (libleptris silently handles non-child args badly).
+    add_next_sibling(wrapper)
+    wrapper.add_child(self)
+    self
+  end
+
+  def dup
+    copy_ptr = Leptris::XML::FFI.leptris_element_copy(@c_ptr, @document.c_ptr)
+    raise Leptris::XML::Error, "leptris_element_copy failed" if copy_ptr.null?
+    Leptris::XML::Node.wrap(copy_ptr, @document)
+  end
+  alias_method :clone, :dup
+
+  def add_child(node_or_markup)
+    case node_or_markup
+    when Leptris::XML::Node
+      Leptris::XML::FFI.check_status(
+        Leptris::XML::FFI.leptris_element_append_child(@c_ptr, node_or_markup.c_ptr))
+      node_or_markup
+    when String
+      frag = Leptris::XML::DocumentFragment.parse(node_or_markup, @document)
+      added = []
+      frag.children.each do |n|
+        Leptris::XML::FFI.check_status(
+          Leptris::XML::FFI.leptris_element_append_child(@c_ptr, n.c_ptr))
+        added << n
+      end
+      Leptris::XML::NodeSet.new(@document, added)
+    else
+      raise ArgumentError, "add_child expects a Node or String, got #{node_or_markup.class}"
+    end
+  end
+  alias_method :<<, :add_child
+
+  def namespace
+    uri = Leptris::XML::FFI.leptris_element_namespace(@c_ptr)
+    return nil if uri.nil? || uri.empty?
+    Leptris::XML::Namespace.new(self, uri)
+  end
+
+  def namespace_definitions
+    count = Leptris::XML::FFI.leptris_element_namespace_count(@c_ptr)
+    count.times.map do |i|
+      prefix = Leptris::XML::FFI.leptris_element_namespace_decl_prefix(@c_ptr, i)
+      uri = Leptris::XML::FFI.leptris_element_namespace_decl_uri(@c_ptr, i)
+      Leptris::XML::Namespace.new(self, uri, prefix: prefix)
+    end
+  end
+
+  def namespaces
+    scopes = {}
+    node = self
+    while node.is_a?(Leptris::XML::Element)
+      node.namespace_definitions.each do |ns|
+        key = ns.prefix ? "xmlns:#{ns.prefix}" : "xmlns"
+        scopes[key] ||= ns.href
+      end
+      node = node.parent
+    end
+    scopes
+  end
+
+  def to_xml(indent: 0, no_decl: false, encoding: nil)
+    Leptris::XML::Serialization.to_xml(
+      Leptris::XML::FFI.method(:leptris_element_serialize), @c_ptr,
+      indent: indent, no_decl: no_decl, encoding: encoding)
+  end
+
+  def canonicalize(version = Leptris::XML::FFI::C14N_1_0,
+                   inclusive_namespaces = nil,
+                   with_comments: false,
+                   exclusive: false,
+                   mode: nil)
+    resolved_mode = mode || (exclusive ? Leptris::XML::FFI::C14N_MODE_EXCLUSIVE
+                                       : Leptris::XML::FFI::C14N_MODE_CANONICAL)
+    Leptris::XML::Serialization.canonicalize(
+      Leptris::XML::FFI.method(:leptris_c14n_canonicalize_subtree_ex), @c_ptr,
+      version: version, mode: resolved_mode,
+      inclusive_namespaces: inclusive_namespaces,
+      with_comments: with_comments)
+  end
+  alias_method :c14n, :canonicalize
+
+  def add_namespace_definition(prefix, href)
+    Leptris::XML::FFI.check_status(
+      Leptris::XML::FFI.leptris_element_add_namespace_definition(
+        @c_ptr, prefix.to_s, href.to_s))
+    Leptris::XML::Namespace.new(self, href.to_s, prefix: prefix.nil? ? nil : prefix.to_s)
+  end
+  alias_method :add_namespace, :add_namespace_definition
+
+  def default_namespace=(href)
+    Leptris::XML::FFI.check_status(
+      Leptris::XML::FFI.leptris_element_set_default_namespace(@c_ptr, href.to_s))
+    href
+  end
+
+  def remove_namespace_definition(prefix)
+    Leptris::XML::FFI.check_status(
+      Leptris::XML::FFI.leptris_element_remove_namespace_definition(@c_ptr, prefix.to_s))
+    self
+  end
+end