RubyGems - makiri - Versions diffs - 0.1.0-aarch64-linux - Mend

makiri 0.1.0-aarch64-linux

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (36) hide show

checksums.yaml +7 -0
data/.github/workflows/ci.yml +73 -0
data/.github/workflows/conformance.yml +94 -0
data/.github/workflows/release.yml +223 -0
data/.github/workflows/security.yml +95 -0
data/.gitmodules +3 -0
data/CHANGELOG.md +102 -0
data/LICENSE +176 -0
data/NOTICE +12 -0
data/README.md +134 -0
data/Rakefile +150 -0
data/lib/makiri/3.2/makiri.so +0 -0
data/lib/makiri/3.3/makiri.so +0 -0
data/lib/makiri/3.4/makiri.so +0 -0
data/lib/makiri/4.0/makiri.so +0 -0
data/lib/makiri/attribute.rb +13 -0
data/lib/makiri/cdata.rb +6 -0
data/lib/makiri/comment.rb +6 -0
data/lib/makiri/css.rb +11 -0
data/lib/makiri/document.rb +82 -0
data/lib/makiri/document_fragment.rb +21 -0
data/lib/makiri/document_type.rb +14 -0
data/lib/makiri/element.rb +17 -0
data/lib/makiri/node.rb +221 -0
data/lib/makiri/node_set.rb +105 -0
data/lib/makiri/processing_instruction.rb +8 -0
data/lib/makiri/text.rb +16 -0
data/lib/makiri/version.rb +5 -0
data/lib/makiri/xpath.rb +14 -0
data/lib/makiri/xpath_context.rb +41 -0
data/lib/makiri.rb +47 -0
data/script/build_native_gem.rb +50 -0
data/script/check_c_safety.rb +238 -0
data/script/check_c_safety_allowlist.yml +12 -0
data/sig/makiri.rbs +4 -0
metadata +127 -0

data/lib/makiri/node.rb ADDED Viewed

@@ -0,0 +1,221 @@
+# frozen_string_literal: true
+module Makiri
+  # Base class for every DOM node (element, attribute, text, comment, ...).
+  # The bulk of the API lives in the C extension; this file defines the
+  # Ruby-only conveniences.
+  class Node
+    # Identity is by wrapped node pointer; defined in C.
+    # @return [Boolean]
+    def element?
+      is_a?(Element)
+    end
+    # @return [Boolean]
+    def text?
+      is_a?(Text)
+    end
+    # @return [Boolean]
+    def comment?
+      is_a?(Comment)
+    end
+    # @return [Boolean]
+    def attribute?
+      is_a?(Attribute)
+    end
+    # @return [Boolean]
+    def document?
+      is_a?(Document)
+    end
+    # @return [Boolean]
+    def processing_instruction?
+      is_a?(ProcessingInstruction)
+    end
+    # @return [Boolean]
+    def document_fragment?
+      is_a?(DocumentFragment)
+    end
+    # @return [Boolean] true for a blank/whitespace-only text or CDATA node.
+    def blank?
+      (text? || is_a?(CData)) && content.strip.empty?
+    end
+    # --- Nokogiri-compatible aliases over the core API ---
+    # Attribute value by name (alias for {#[]}). Use {#attribute} for the node.
+    alias_method :attr, :[]
+    alias_method :get_attribute, :[]
+    alias_method :has_attribute?, :key?
+    alias_method :remove_attribute, :delete
+    alias_method :node_name, :name
+    alias_method :node_name=, :name=
+    alias_method :type, :node_type
+    alias_method :elem?, :element?
+    alias_method :fragment?, :document_fragment?
+    # Set an attribute (alias for {#[]=}). @return [String]
+    def set_attribute(name, value)
+      self[name] = value
+    end
+    # The Attribute node named +name+, or nil (cf. {#[]}, which returns the value).
+    # @return [Makiri::Attribute, nil]
+    def attribute(name)
+      attributes[name.to_s]
+    end
+    # --- CSS class helpers (operate on the `class` attribute) ---
+    # @return [Array<String>] the element's class names.
+    def classes
+      self["class"].to_s.split(/\s+/).reject(&:empty?)
+    end
+    # Add each class in +names+ (space-separated) that is not already present.
+    # @return [self]
+    def add_class(names)
+      have = classes
+      have.concat(names.to_s.split(/\s+/).reject { |c| c.empty? || have.include?(c) })
+      self["class"] = have.join(" ")
+      self
+    end
+    # Append each class in +names+ unconditionally (duplicates allowed).
+    # @return [self]
+    def append_class(names)
+      self["class"] = (classes + names.to_s.split(/\s+/).reject(&:empty?)).join(" ")
+      self
+    end
+    # Remove each class in +names+ (or every class when +names+ is nil); drops
+    # the `class` attribute entirely when none remain.
+    # @return [self]
+    def remove_class(names = nil)
+      if names.nil?
+        delete("class")
+      else
+        remaining = classes - names.to_s.split(/\s+/)
+        remaining.empty? ? delete("class") : (self["class"] = remaining.join(" "))
+      end
+      self
+    end
+    # Yield this node and every descendant, depth-first, children before self
+    # (post-order, matching Nokogiri).
+    # @return [self]
+    def traverse(&block)
+      children.each { |child| child.traverse(&block) }
+      block.call(self)
+      self
+    end
+    # The root element of the owning document (e.g. <html>).
+    # @return [Makiri::Element, nil]
+    def root
+      document.root
+    end
+    # Attributes as a name => Attribute Hash (empty for non-elements).
+    # @return [Hash{String => Makiri::Attribute}]
+    def attributes
+      attribute_nodes.each_with_object({}) { |attr, h| h[attr.name] = attr }
+    end
+    # Attributes as a plain name => value Hash (empty for non-elements).
+    # @return [Hash{String => String}]
+    def to_h
+      attribute_nodes.each_with_object({}) { |attr, h| h[attr.name] = attr.value }
+    end
+    # Query with CSS or XPath, auto-detecting which from the string shape.
+    # Strings that look like a location path (start with "/", "./", "..", ".//",
+    # "(", "@" or contain "::") are treated as XPath; everything else as CSS.
+    # @return [Makiri::NodeSet, String, Float, Boolean]
+    def search(path)
+      xpath?(path) ? xpath(path) : css(path)
+    end
+    # First result of {#search}: the first node for a node-set, else the value.
+    def at(path)
+      result = search(path)
+      result.is_a?(NodeSet) ? result.first : result
+    end
+    # An absolute XPath that locates this node, e.g. "/html/body/p[2]".
+    # Element/text/comment steps carry a 1-based position among same-kind
+    # siblings (omitted when unique); attributes use "@name". Round-trips
+    # through {#at_xpath}.
+    # @return [String]
+    def path
+      return "/" if document?
+      segments = []
+      node = self
+      until node.nil? || node.document?
+        segments.unshift(node.send(:path_segment))
+        node = node.parent
+      end
+      "/#{segments.join("/")}"
+    end
+    # Inspect representation. Avoids dumping the whole subtree.
+    def inspect
+      "#<#{self.class.name} name=#{name.inspect}>"
+    rescue NoMethodError
+      "#<#{self.class.name}>"
+    end
+    private
+    # Heuristic used by {#search}: does +path+ look like an XPath location path
+    # rather than a CSS selector?
+    def xpath?(path)
+      s = path.to_s.strip
+      s.start_with?("/", "./", "../", ".//", "(", "@") || s.include?("::")
+    end
+    # One "/"-separated step of {#path} for this node.
+    def path_segment
+      return "@#{name}" if attribute?
+      parent_node = parent
+      return step_name unless parent_node
+      siblings = parent_node.children.select { |c| same_step_kind?(c) }
+      return step_name if siblings.length <= 1
+      "#{step_name}[#{siblings.index(self) + 1}]"
+    end
+    # The node-test portion of a path step (without any position predicate).
+    def step_name
+      if text?
+        "text()"
+      elsif comment?
+        "comment()"
+      else
+        name
+      end
+    end
+    # Whether +other+ shares this node's path-step kind (for position counting).
+    def same_step_kind?(other)
+      if element?
+        other.element? && other.name == name
+      elsif text?
+        other.text?
+      elsif comment?
+        other.comment?
+      else
+        false
+      end
+    end
+  end
+end

data/lib/makiri/node_set.rb ADDED Viewed

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+module Makiri
+  # An ordered collection of nodes, returned by xpath/css queries.
+  class NodeSet
+    include Enumerable
+    # @return [Integer]
+    def size
+      length
+    end
+    # @return [Boolean]
+    def empty?
+      length.zero?
+    end
+    # @return [Makiri::Node, nil]
+    def first
+      self[0]
+    end
+    # @return [Makiri::Node, nil]
+    def last
+      self[length - 1]
+    end
+    # Index access; alias for #[].
+    # @return [Makiri::Node, nil]
+    def at(index)
+      self[index]
+    end
+    # Concatenated outer HTML of every node in the set.
+    # @return [String]
+    def to_html
+      map(&:to_html).join
+    end
+    alias to_s to_html
+    # Concatenated text content of every node in the set.
+    # @return [String]
+    def text
+      map(&:text).join
+    end
+    alias inner_text text
+    # Run a CSS selector against every node and return the unioned matches.
+    # @return [Makiri::NodeSet]
+    def css(selector)
+      return self if empty?
+      map { |node| node.css(selector) }.reduce(:|)
+    end
+    # Run an XPath expression against every node and union the node-set results.
+    # @return [Makiri::NodeSet]
+    def xpath(expr)
+      return self if empty?
+      map { |node| node.xpath(expr) }.reduce(:|)
+    end
+    # First node matching the CSS selector across the set, or nil.
+    # @return [Makiri::Node, nil]
+    def at_css(selector)
+      css(selector).first
+    end
+    # First node matching the XPath expression across the set (or the scalar
+    # value for a non-node-set result).
+    def at_xpath(expr)
+      result = xpath(expr)
+      result.is_a?(NodeSet) ? result.first : result
+    end
+    # CSS- or XPath-detecting query against every node (see {Node#search}).
+    # @return [Makiri::NodeSet]
+    def search(path)
+      return self if empty?
+      map { |node| node.search(path) }.reduce(:|)
+    end
+    # Remove the named attribute from every node in the set.
+    # @return [self]
+    def remove_attr(name)
+      each { |node| node.delete(name) }
+      self
+    end
+    alias remove_attribute remove_attr
+    # Detach every node in the set from its tree.
+    # @return [self]
+    def remove
+      to_a.each(&:remove)
+      self
+    end
+    alias unlink remove
+    def inspect
+      "#<#{self.class.name} length=#{length}>"
+    end
+  end
+end

data/lib/makiri/processing_instruction.rb ADDED Viewed

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+module Makiri
+  # An XML/HTML processing-instruction node. Rare in HTML5 (the parser usually
+  # treats "<?...>" as a bogus comment), present mainly for completeness.
+  class ProcessingInstruction < Node
+  end
+end

data/lib/makiri/text.rb ADDED Viewed

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+module Makiri
+  # A text node.
+  class Text < Node
+    # Create a detached text node with +content+ owned by +document+
+    # (Nokogiri-style constructor; delegates to {Document#create_text_node}).
+    #
+    # @param content [String]
+    # @param document [Makiri::Document]
+    # @return [Makiri::Text]
+    def self.new(content, document)
+      document.create_text_node(content)
+    end
+  end
+end

data/lib/makiri/version.rb ADDED Viewed

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

data/lib/makiri/xpath.rb ADDED Viewed

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+module Makiri
+  module XPath
+    # Raised when an XPath expression fails to parse, or when an
+    # evaluation limit (operation count, recursion depth, node-set
+    # cap) is exceeded.
+    class SyntaxError < ::Makiri::Error; end
+    # Raised when an evaluation budget is exhausted. Subclasses
+    # SyntaxError for Nokogiri-shaped error compatibility.
+    class LimitExceeded < SyntaxError; end
+  end
+end

data/lib/makiri/xpath_context.rb ADDED Viewed

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+module Makiri
+  # Per-query XPath evaluation context. Holds the context node, namespace
+  # bindings, and variable bindings, and evaluates expressions against them.
+  #
+  #   ctx = Makiri::XPathContext.new(doc)
+  #   ctx.register_namespace("svg", "http://www.w3.org/2000/svg")
+  #   ctx.evaluate("//svg:circle")            # => Makiri::NodeSet
+  #
+  # +evaluate+ returns a NodeSet for node-set expressions, and a String,
+  # Float, or boolean for the corresponding scalar XPath types.
+  #
+  # The bulk of the implementation lives in C (see
+  # ext/makiri/glue/ruby_xpath.c and ext/makiri/xpath/).
+  class XPathContext
+    # +#evaluate+ is defined in C. It evaluates under the GVL (XPath never
+    # releases it), so concurrent +evaluate+ / +register_*+ / +node=+ on the
+    # same context — and any tree mutation of the document being queried — are
+    # serialised by the GVL and cannot corrupt memory.
+    # Nokogiri-compatible name for {#register_namespace}.
+    alias register_ns register_namespace
+    # Register several prefix => URI namespace bindings at once.
+    # @param bindings [Hash{String => String}]
+    # @return [self]
+    def register_namespaces(bindings)
+      bindings.each { |prefix, uri| register_namespace(prefix.to_s, uri.to_s) }
+      self
+    end
+    # Register several name => value variable bindings at once.
+    # @param bindings [Hash{String => Object}]
+    # @return [self]
+    def register_variables(bindings)
+      bindings.each { |name, value| register_variable(name.to_s, value) }
+      self
+    end
+  end
+end

data/lib/makiri.rb ADDED Viewed

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+require_relative "makiri/version"
+# Native C extension. Located at lib/makiri/<ruby_abi>/makiri.{so,bundle}
+# (created by rake-compiler). Loading is gated so the gem can be required
+# in environments where the binary is not yet built (the require error
+# is then surfaced clearly).
+begin
+  RUBY_VERSION =~ /(\d+\.\d+)/
+  require_relative "makiri/#{Regexp.last_match(1)}/makiri"
+rescue LoadError
+  require_relative "makiri/makiri"
+end
+require_relative "makiri/node"
+require_relative "makiri/document"
+require_relative "makiri/element"
+require_relative "makiri/attribute"
+require_relative "makiri/text"
+require_relative "makiri/comment"
+require_relative "makiri/cdata"
+require_relative "makiri/processing_instruction"
+require_relative "makiri/document_type"
+require_relative "makiri/document_fragment"
+require_relative "makiri/node_set"
+require_relative "makiri/xpath_context"
+require_relative "makiri/xpath"
+require_relative "makiri/css"
+module Makiri
+  # Base exception class for Makiri-specific errors.
+  class Error < StandardError; end
+  # Convenience constructor mirroring Nokogiri.
+  #
+  # @param source [String] HTML source (UTF-8).
+  # @return [Makiri::Document]
+  def self.HTML(source) # rubocop:disable Naming/MethodName
+    Document.parse(source)
+  end
+  # Alias for {.HTML}.
+  def self.parse(source)
+    Document.parse(source)
+  end
+end

data/script/build_native_gem.rb ADDED Viewed

@@ -0,0 +1,50 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+# Assemble a precompiled ("native" / fat) gem for one platform from the
+# per-Ruby-ABI extension binaries already staged under
+#   lib/makiri/<ruby_minor>/makiri.{so,bundle}
+#
+# Usage: ruby script/build_native_gem.rb <gem-platform>
+#   e.g. ruby script/build_native_gem.rb arm64-darwin
+#
+# Run by .github/workflows/release.yml after downloading the compile artifacts.
+# The resulting gem ships the compiled binaries (one per Ruby minor version) and
+# declares no C extension, so `gem install` does NOT recompile or need cmake /
+# the Lexbor submodule. lib/makiri.rb already selects lib/makiri/<minor>/makiri
+# at require time.
+require "rubygems"
+require "rubygems/package"
+platform = ARGV[0]
+abort "usage: build_native_gem.rb <gem-platform>" if platform.nil? || platform.empty?
+root = File.expand_path("..", __dir__)
+spec = Gem::Specification.load(File.join(root, "makiri.gemspec"))
+libs = Dir[File.join(root, "lib", "makiri", "*", "makiri.{so,bundle}")].sort
+abort "no precompiled libraries found under lib/makiri/*/ — stage them first" if libs.empty?
+# Native gem: ship binaries, not the C sources or the vendored Lexbor tree, and
+# declare no extension so install never tries to compile.
+spec.platform   = platform
+spec.extensions = []
+spec.files = spec.files.reject { |f| f.start_with?("ext/", "vendor/") }
+spec.files += libs.map { |p| p.sub("#{root}/", "") }
+spec.files.uniq!
+# Bound the Ruby versions this binary gem serves — one subdir per ABI minor.
+abis = libs.map { |p| File.basename(File.dirname(p)) }.sort_by { |v| v.split(".").map(&:to_i) }
+lo_major, lo_minor = abis.first.split(".").map(&:to_i)
+hi_major, hi_minor = abis.last.split(".").map(&:to_i)
+spec.required_ruby_version = [">= #{lo_major}.#{lo_minor}.0", "< #{hi_major}.#{hi_minor + 1}.dev"]
+puts "Building native gem for #{platform}"
+puts "  ABIs:    #{abis.join(', ')}"
+puts "  ruby:    #{spec.required_ruby_version}"
+puts "  binaries:"
+libs.each { |p| puts "    #{p.sub("#{root}/", '')}" }
+gem = Gem::Package.build(spec)
+puts "Built #{gem}"