leptris 1.0.0

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,202 @@
+# 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 weak-ref cache for Node wrappers, keyed on c_ptr
+    # address. Eliminates re-allocation when the same node is accessed
+    # repeatedly (e.g. via children, siblings, multiple xpath calls).
+    # Dies with the Document — no stale entries pointing at freed memory.
+    @wrapper_cache = ObjectSpace::WeakMap.new
+  end
+
+  def self.parse(xml_or_io)
+    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
+    status_ptr = ::FFI::MemoryPointer.new(:int)
+    raw = Leptris::XML::FFI.leptris_parse_string(xml, xml.bytesize, status_ptr)
+    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 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::Element.new(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::Element.new(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::Text.new(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::Comment.new(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::CDATA.new(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::ProcessingInstruction.new(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?
+    opts, enc_ptr = build_serialize_options(indent: indent, no_decl: no_decl, encoding: encoding)
+    str_ptr = Leptris::XML::FFI.leptris_document_serialize(@c_ptr, opts.pointer)
+    return "" if str_ptr.null?
+    str_ptr.read_string.tap { |s| Leptris::XML::FFI.leptris_free_string(str_ptr) }
+  end
+  alias_method :to_s, :to_xml
+  alias_method :serialize, :to_xml
+
+  def save(path, **opts)
+    opts_struct, enc_ptr = build_serialize_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)
+    raise Leptris::XML::Error,
+      Leptris::XML::FFI.leptris_status_string(status) unless status == Leptris::XML::FFI::LEPTRIS_OK
+    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)
+    ns_ptr, _anchor = Leptris::XML.c14n_build_ns_pointer(inclusive_namespaces)
+    flags = with_comments ? 1 : 0
+    str_ptr = Leptris::XML::FFI.leptris_c14n_canonicalize_ex(
+      @c_ptr, version, resolved_mode, ns_ptr, flags)
+    return "" if str_ptr.null?
+    str_ptr.read_string.tap { Leptris::XML::FFI.leptris_free_string(str_ptr) }
+  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
+  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
+
+  private
+
+  def build_serialize_options(indent:, no_decl:, encoding:)
+    opts = Leptris::XML::FFI::SerializeOptions.new
+    opts[:indent] = indent.to_i
+    opts[:xml_declaration] = no_decl ? 0 : 1
+    enc_ptr = nil
+    if encoding
+      enc_ptr = ::FFI::MemoryPointer.from_string(encoding.to_s)
+      opts[:encoding] = enc_ptr
+    end
+    [opts, enc_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,278 @@
+# 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)
+    status = Leptris::XML::FFI.leptris_element_set_name(@c_ptr, new_name)
+    raise Leptris::XML::Error,
+      Leptris::XML::FFI.leptris_status_string(status) unless status == Leptris::XML::FFI::LEPTRIS_OK
+    new_name
+  end
+  alias_method :node_name=, :name=
+
+  def content
+    Leptris::XML::FFI.leptris_element_text(@c_ptr)
+  end
+
+  def content=(new_content)
+    status = Leptris::XML::FFI.leptris_element_set_text(@c_ptr, new_content.to_s)
+    raise Leptris::XML::Error,
+      Leptris::XML::FFI.leptris_status_string(status) unless status == Leptris::XML::FFI::LEPTRIS_OK
+    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)
+    status = Leptris::XML::FFI.leptris_element_set_attribute(@c_ptr, key.to_s, value.to_s)
+    raise Leptris::XML::Error,
+      Leptris::XML::FFI.leptris_status_string(status) unless status == Leptris::XML::FFI::LEPTRIS_OK
+    value
+  end
+  alias_method :set_attribute, :[]=
+
+  def key?(name)
+    !Leptris::XML::FFI.leptris_element_attribute(@c_ptr, name.to_s).nil?
+  end
+  alias_method :has_attribute?, :key?
+
+  def remove_attribute(name)
+    status = Leptris::XML::FFI.leptris_element_remove_attribute(@c_ptr, name.to_s)
+    raise Leptris::XML::Error,
+      Leptris::XML::FFI.leptris_status_string(status) unless status == Leptris::XML::FFI::LEPTRIS_OK
+    self
+  end
+  alias_method :delete, :remove_attribute
+
+  def keys
+    count = Leptris::XML::FFI.leptris_element_attribute_count(@c_ptr)
+    count.times.map { |i| Leptris::XML::FFI.leptris_element_attribute_name_at(@c_ptr, i) }
+  end
+
+  def values
+    count = Leptris::XML::FFI.leptris_element_attribute_count(@c_ptr)
+    count.times.map { |i| Leptris::XML::FFI.leptris_element_attribute_value_at(@c_ptr, i) }
+  end
+
+  def attributes
+    count = Leptris::XML::FFI.leptris_element_attribute_count(@c_ptr)
+    result = {}
+    count.times do |i|
+      name = Leptris::XML::FFI.leptris_element_attribute_name_at(@c_ptr, i)
+      value = Leptris::XML::FFI.leptris_element_attribute_value_at(@c_ptr, i)
+      result[name] = Leptris::XML::Attr.new(name, value, self)
+    end
+    result
+  end
+
+  def attribute_nodes
+    count = Leptris::XML::FFI.leptris_element_attribute_count(@c_ptr)
+    count.times.map do |i|
+      name = Leptris::XML::FFI.leptris_element_attribute_name_at(@c_ptr, i)
+      value = Leptris::XML::FFI.leptris_element_attribute_value_at(@c_ptr, i)
+      Leptris::XML::Attr.new(name, value, self)
+    end
+  end
+
+  def add_child(node)
+    status = Leptris::XML::FFI.leptris_element_append_child(@c_ptr, node.c_ptr)
+    raise Leptris::XML::Error,
+      Leptris::XML::FFI.leptris_status_string(status) unless status == Leptris::XML::FFI::LEPTRIS_OK
+    node
+  end
+  alias_method :<<, :add_child
+
+  def prepend_child(node)
+    status = Leptris::XML::FFI.leptris_element_prepend_child(@c_ptr, node.c_ptr)
+    raise Leptris::XML::Error,
+      Leptris::XML::FFI.leptris_status_string(status) unless status == Leptris::XML::FFI::LEPTRIS_OK
+    node
+  end
+
+  def add_next_sibling(node)
+    status = Leptris::XML::FFI.leptris_element_insert_after(@c_ptr, node.c_ptr)
+    raise Leptris::XML::Error,
+      Leptris::XML::FFI.leptris_status_string(status) unless status == Leptris::XML::FFI::LEPTRIS_OK
+    node
+  end
+
+  def add_previous_sibling(node)
+    status = Leptris::XML::FFI.leptris_element_insert_before(@c_ptr, node.c_ptr)
+    raise Leptris::XML::Error,
+      Leptris::XML::FFI.leptris_status_string(status) unless status == Leptris::XML::FFI::LEPTRIS_OK
+    node
+  end
+
+  def remove_child(node)
+    status = Leptris::XML::FFI.leptris_element_remove_child(@c_ptr, node.c_ptr)
+    raise Leptris::XML::Error,
+      Leptris::XML::FFI.leptris_status_string(status) unless status == Leptris::XML::FFI::LEPTRIS_OK
+    node
+  end
+
+  def children=(node_or_nodes)
+    # Remove existing children, then attach the new ones in source order.
+    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::Element.new(copy_ptr, @document)
+  end
+  alias_method :clone, :dup
+
+  def add_child(node_or_markup)
+    case node_or_markup
+    when Leptris::XML::Node
+      status = Leptris::XML::FFI.leptris_element_append_child(@c_ptr, node_or_markup.c_ptr)
+      raise Leptris::XML::Error,
+        Leptris::XML::FFI.leptris_status_string(status) unless status == Leptris::XML::FFI::LEPTRIS_OK
+      node_or_markup
+    when String
+      frag = Leptris::XML::DocumentFragment.parse(node_or_markup, @document)
+      added = []
+      frag.children.each do |n|
+        status = Leptris::XML::FFI.leptris_element_append_child(@c_ptr, n.c_ptr)
+        raise Leptris::XML::Error,
+          Leptris::XML::FFI.leptris_status_string(status) unless status == Leptris::XML::FFI::LEPTRIS_OK
+        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
+
+  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)
+    opts = Leptris::XML::FFI::SerializeOptions.new
+    opts[:indent] = indent.to_i
+    opts[:xml_declaration] = no_decl ? 0 : 1
+    enc_ptr = nil
+    if encoding
+      enc_ptr = ::FFI::MemoryPointer.from_string(encoding.to_s)
+      opts[:encoding] = enc_ptr
+    end
+    str_ptr = Leptris::XML::FFI.leptris_element_serialize(@c_ptr, opts.pointer)
+    return "" if str_ptr.null?
+    str_ptr.read_string.tap { Leptris::XML::FFI.leptris_free_string(str_ptr) }
+  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)
+    ns_ptr, _anchor = Leptris::XML.c14n_build_ns_pointer(inclusive_namespaces)
+    flags = with_comments ? 1 : 0
+    str_ptr = Leptris::XML::FFI.leptris_c14n_canonicalize_subtree_ex(
+      @c_ptr, version, resolved_mode, ns_ptr, flags)
+    return "" if str_ptr.null?
+    str_ptr.read_string.tap { Leptris::XML::FFI.leptris_free_string(str_ptr) }
+  end
+  alias_method :c14n, :canonicalize
+
+  def add_namespace_definition(prefix, href)
+    status = Leptris::XML::FFI.leptris_element_add_namespace_definition(
+      @c_ptr, prefix.to_s, href.to_s)
+    raise Leptris::XML::Error,
+      Leptris::XML::FFI.leptris_status_string(status) unless status == Leptris::XML::FFI::LEPTRIS_OK
+    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)
+    status = Leptris::XML::FFI.leptris_element_set_default_namespace(@c_ptr, href.to_s)
+    raise Leptris::XML::Error,
+      Leptris::XML::FFI.leptris_status_string(status) unless status == Leptris::XML::FFI::LEPTRIS_OK
+    href
+  end
+
+  def remove_namespace_definition(prefix)
+    status = Leptris::XML::FFI.leptris_element_remove_namespace_definition(@c_ptr, prefix.to_s)
+    raise Leptris::XML::Error,
+      Leptris::XML::FFI.leptris_status_string(status) unless status == Leptris::XML::FFI::LEPTRIS_OK
+    self
+  end
+end