RubyGems - nokolexbor - Versions diffs - 0.3.0-x64-mingw-ucrt - Mend

nokolexbor 0.3.0-x64-mingw-ucrt

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 (11) hide show

checksums.yaml +7 -0
data/lib/nokolexbor/3.1/nokolexbor.so +0 -0
data/lib/nokolexbor/attribute.rb +18 -0
data/lib/nokolexbor/document.rb +97 -0
data/lib/nokolexbor/node.rb +348 -0
data/lib/nokolexbor/node_set.rb +131 -0
data/lib/nokolexbor/version.rb +5 -0
data/lib/nokolexbor/xpath.rb +69 -0
data/lib/nokolexbor/xpath_context.rb +14 -0
data/lib/nokolexbor.rb +38 -0
metadata +83 -0

checksums.yaml ADDED Viewed

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 75ac569a01b9281d1392eb495d5358eef2ce76fe420c4b2fd768d46df47904c1
+  data.tar.gz: b4d46dff993b2b8bc73b63356bb6abd2ca9721297226887d56d5e5f453406b58
+SHA512:
+  metadata.gz: 8b4db936db5a609ad470033f1946cbaf495ed399d84b6a994ad51e86fd2a163e9c879103e5b2e5c51d23afc04ef5154896b68d2cc97e15b12c460b6c81588f2b
+  data.tar.gz: ec47117ce93ffe34e622df54cc981b0a52d2b8d344f17a730093becc46309d1650966872c222d00d076a13a014285dd2ace63ac996c67be75441ff47393e5ddd

data/lib/nokolexbor/3.1/nokolexbor.so ADDED Viewed

Binary file

data/lib/nokolexbor/attribute.rb ADDED Viewed

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+module Nokolexbor
+  class Attribute
+    attr_accessor :name
+    attr_accessor :value
+    def initialize(name, value)
+      @name = name
+      @value = value
+    end
+    alias_method :text, :value
+    alias_method :content, :value
+    alias_method :to_s, :value
+    alias_method :to_str, :value
+  end
+end

data/lib/nokolexbor/document.rb ADDED Viewed

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+module Nokolexbor
+  class Document < Nokolexbor::Node
+    def create_element(name, *contents_or_attrs, &block)
+      elm = Nokolexbor::Element.new(name, self, &block)
+      contents_or_attrs.each do |arg|
+        case arg
+        when Hash
+          arg.each do |k, v|
+            elm[k.to_s] = v.to_s
+          end
+        else
+          elm.content = arg
+        end
+      end
+      elm
+    end
+    # Create a Text Node with +string+
+    def create_text_node(string, &block)
+      Nokolexbor::Text.new(string.to_s, self, &block)
+    end
+    # Create a CDATA Node containing +string+
+    def create_cdata(string, &block)
+      Nokolexbor::CDATA.new(string.to_s, self, &block)
+    end
+    # Create a Comment Node containing +string+
+    def create_comment(string, &block)
+      Nokolexbor::Comment.new(string.to_s, self, &block)
+    end
+    # A reference to +self+
+    def document
+      self
+    end
+    def meta_encoding
+      if (meta = at_css("meta[charset]"))
+        meta[:charset]
+      elsif (meta = meta_content_type)
+        meta["content"][/charset\s*=\s*([\w-]+)/i, 1]
+      end
+    end
+    def meta_encoding=(encoding)
+      if (meta = meta_content_type)
+        meta["content"] = format("text/html; charset=%s", encoding)
+        encoding
+      elsif (meta = at_css("meta[charset]"))
+        meta["charset"] = encoding
+      else
+        meta = Nokolexbor::Node.new("meta", self)
+        meta["charset"] = encoding
+        if (head = at_css("head"))
+          head.prepend_child(meta)
+        else
+          set_metadata_element(meta)
+        end
+        encoding
+      end
+    end
+    def meta_content_type
+      xpath("//meta[@http-equiv and boolean(@content)]").find do |node|
+        node["http-equiv"] =~ /\AContent-Type\z/i
+      end
+    end
+    private :meta_content_type
+    def set_metadata_element(element)
+      if (head = at_css("head"))
+        head << element
+      elsif (html = at_css("html"))
+        head = html.prepend_child(Nokolexbor::Node.new("head", self))
+        head.prepend_child(element)
+      elsif (first = children.find do |node|
+               case node
+               when Nokolexbor::Node
+                 true
+               end
+             end)
+        # We reach here only if the underlying document model
+        # allows <html>/<head> elements to be omitted and does not
+        # automatically supply them.
+        first.add_previous_sibling(element)
+      else
+        html = add_child(Nokolexbor::Node.new("html", self))
+        head = html.add_child(Nokolexbor::Node.new("head", self))
+        head.prepend_child(element)
+      end
+    end
+  end
+end

data/lib/nokolexbor/node.rb ADDED Viewed

@@ -0,0 +1,348 @@
+# frozen_string_literal: true
+module Nokolexbor
+  class Node
+    include Enumerable
+    ELEMENT_NODE = 1
+    ATTRIBUTE_NODE = 2
+    TEXT_NODE = 3
+    CDATA_SECTION_NODE = 4
+    ENTITY_REF_NODE = 5
+    ENTITY_NODE = 6
+    PI_NODE = 7
+    COMMENT_NODE = 8
+    DOCUMENT_NODE = 9
+    DOCUMENT_TYPE_NODE = 10
+    DOCUMENT_FRAG_NODE = 11
+    NOTATION_NODE = 12
+    attr_reader :document
+    LOOKS_LIKE_XPATH = %r{^(\./|/|\.\.|\.$)}
+    def comment?
+      type == COMMENT_NODE
+    end
+    def cdata?
+      type == CDATA_SECTION_NODE
+    end
+    def processing_instruction?
+      type == PI_NODE
+    end
+    def text?
+      type == TEXT_NODE
+    end
+    def fragment?
+      type == DOCUMENT_FRAG_NODE
+    end
+    def element?
+      type == ELEMENT_NODE
+    end
+    def document?
+      is_a?(Nokolexbor::Document)
+    end
+    def ancestors(selector = nil)
+      return NodeSet.new(@document) unless respond_to?(:parent)
+      return NodeSet.new(@document) unless parent
+      parents = [parent]
+      while parents.last.respond_to?(:parent)
+        break unless (ctx_parent = parents.last.parent)
+        parents << ctx_parent
+      end
+      return NodeSet.new(@document, parents) unless selector
+      root = parents.last
+      search_results = root.search(selector)
+      NodeSet.new(@document, parents.find_all do |parent|
+        search_results.include?(parent)
+      end)
+    end
+    def wrap(node)
+      case node
+      when String
+        new_parent = fragment(node).child
+      when Node
+        new_parent = node.dup
+      else
+        raise ArgumentError, "Requires a String or Node argument, and cannot accept a #{node.class}"
+      end
+      if parent
+        add_sibling(:next, new_parent)
+      else
+        new_parent.remove
+      end
+      new_parent.add_child(self)
+      self
+    end
+    def add_previous_sibling(node_or_tags)
+      raise ArgumentError,
+        "A document may not have multiple root nodes." if parent&.document? && !(node_or_tags.comment? || node_or_tags.processing_instruction?)
+      add_sibling(:previous, node_or_tags)
+    end
+    def add_next_sibling(node_or_tags)
+      raise ArgumentError,
+        "A document may not have multiple root nodes." if parent&.document? && !(node_or_tags.comment? || node_or_tags.processing_instruction?)
+      add_sibling(:next, node_or_tags)
+    end
+    def before(node_or_tags)
+      add_previous_sibling(node_or_tags)
+      self
+    end
+    def after(node_or_tags)
+      add_next_sibling(node_or_tags)
+      self
+    end
+    alias_method :next_sibling, :next
+    alias_method :previous_sibling, :previous
+    alias_method :next=, :add_next_sibling
+    alias_method :previous=, :add_previous_sibling
+    def <<(node_or_tags)
+      add_child(node_or_tags)
+      self
+    end
+    def prepend_child(node)
+      if (first = children.first)
+        # Mimic the error add_child would raise.
+        raise "Document already has a root node" if document? && !(node.comment? || node.processing_instruction?)
+        first.add_sibling(:previous, node)
+      else
+        add_child(node)
+      end
+    end
+    def traverse(&block)
+      children.each { |j| j.traverse(&block) }
+      yield(self)
+    end
+    def matches?(selector)
+      ancestors.last.css(selector).any? { |node| node == self }
+    end
+    def attribute(name)
+      return nil unless key?(name)
+      Attribute.new(name, attr(name))
+    end
+    def attributes
+      attrs.map { |k, v| [k, Attribute.new(k, v)] }.to_h
+    end
+    def replace(node)
+      if node.is_a?(NodeSet)
+        node.each { |n| add_sibling(:previous, n) }
+      else
+        add_sibling(:previous, node)
+      end
+      remove
+    end
+    def children=(node)
+      children.remove
+      if node.is_a?(NodeSet)
+        node.each { |n| add_child(n) }
+      else
+        add_child(node)
+      end
+    end
+    def parent=(parent_node)
+      parent_node.add_child(self)
+    end
+    def each
+      attributes.each do |name, node|
+        yield [name, node.value]
+      end
+    end
+    alias_method :inner_html=, :children=
+    def css(*args)
+      css_impl(args.join(', '))
+    end
+    def at_css(*args)
+      at_css_impl(args.join(', '))
+    end
+    def xpath(*args)
+      paths, handler, ns, binds = extract_params(args)
+      xpath_internal(self, paths, handler, ns, binds)
+    end
+    def at_xpath(*args)
+      xpath(*args).first
+    end
+    def search(*args)
+      paths, handler, ns, binds = extract_params(args)
+      if paths.size == 1 && !LOOKS_LIKE_XPATH.match?(paths.first)
+        return css(paths.first)
+      end
+      xpath(*(paths + [ns, handler, binds].compact))
+    end
+    alias_method :/, :search
+    def at(*args)
+      paths, handler, ns, binds = extract_params(args)
+      if paths.size == 1 && !LOOKS_LIKE_XPATH.match?(paths.first)
+        return at_css(paths.first)
+      end
+      at_xpath(*(paths + [ns, handler, binds].compact))
+    end
+    alias_method :%, :at
+    def classes
+      kwattr_values("class")
+    end
+    def add_class(names)
+      kwattr_add("class", names)
+    end
+    def append_class(names)
+      kwattr_append("class", names)
+    end
+    def remove_class(names = nil)
+      kwattr_remove("class", names)
+    end
+    def kwattr_values(attribute_name)
+      keywordify(attr(attribute_name) || [])
+    end
+    def kwattr_add(attribute_name, keywords)
+      keywords = keywordify(keywords)
+      current_kws = kwattr_values(attribute_name)
+      new_kws = (current_kws + (keywords - current_kws)).join(" ")
+      set_attr(attribute_name, new_kws)
+      self
+    end
+    def kwattr_append(attribute_name, keywords)
+      keywords = keywordify(keywords)
+      current_kws = kwattr_values(attribute_name)
+      new_kws = (current_kws + keywords).join(" ")
+      set_attr(attribute_name, new_kws)
+      self
+    end
+    def kwattr_remove(attribute_name, keywords)
+      if keywords.nil?
+        remove_attr(attribute_name)
+        return self
+      end
+      keywords = keywordify(keywords)
+      current_kws = kwattr_values(attribute_name)
+      new_kws = current_kws - keywords
+      if new_kws.empty?
+        remove_attr(attribute_name)
+      else
+        set_attr(attribute_name, new_kws.join(" "))
+      end
+      self
+    end
+    def keywordify(keywords)
+      case keywords
+      when Enumerable
+        keywords
+      when String
+        keywords.scan(/\S+/)
+      else
+        raise ArgumentError,
+          "Keyword attributes must be passed as either a String or an Enumerable, but received #{keywords.class}"
+      end
+    end
+    def write_to(io, *options)
+      io.write(to_html(*options))
+    end
+    alias_method :write_html_to, :write_to
+    private
+    def xpath_internal(node, paths, handler, ns, binds)
+      # document = node.document
+      # return NodeSet.new(document) unless document
+      if paths.length == 1
+        return xpath_impl(node, paths.first, handler, ns, binds)
+      end
+      NodeSet.new(@document) do |combined|
+        paths.each do |path|
+          xpath_impl(node, path, handler, ns, binds).each { |set| combined << set }
+        end
+      end
+    end
+    def xpath_impl(node, path, handler, ns, binds)
+      ctx = XPathContext.new(node)
+      ctx.register_namespaces(ns)
+      # path = path.gsub(/xmlns:/, " :") unless Nokogiri.uses_libxml?
+      binds&.each do |key, value|
+        ctx.register_variable(key.to_s, value)
+      end
+      ctx.evaluate(path, handler)
+    end
+    def extract_params(params)
+      handler = params.find do |param|
+        ![Hash, String, Symbol].include?(param.class)
+      end
+      params -= [handler] if handler
+      hashes = []
+      while Hash === params.last || params.last.nil?
+        hashes << params.pop
+        break if params.empty?
+      end
+      ns, binds = hashes.reverse
+      # ns ||= (document.root&.namespaces || {})
+      ns ||= {}
+      [params, handler, ns, binds]
+    end
+  end
+end

data/lib/nokolexbor/node_set.rb ADDED Viewed

@@ -0,0 +1,131 @@
+# frozen_string_literal: true
+module Nokolexbor
+  class NodeSet < Nokolexbor::Node
+    include Enumerable
+    def self.new(document, list = [])
+      obj = allocate
+      obj.instance_variable_set(:@document, document)
+      list.each { |x| obj << x }
+      yield obj if block_given?
+      obj
+    end
+    def each
+      return to_enum unless block_given?
+      0.upto(length - 1) do |x|
+        yield self[x]
+      end
+      self
+    end
+    def first(n = nil)
+      return self[0] unless n
+      list = []
+      [n, length].min.times { |i| list << self[i] }
+      list
+    end
+    def last
+      self[-1]
+    end
+    def empty?
+      length == 0
+    end
+    def index(node = nil)
+      if node
+        each_with_index { |member, j| return j if member == node }
+      elsif block_given?
+        each_with_index { |member, j| return j if yield(member) }
+      end
+      nil
+    end
+    def content
+      self.map(&:content).join
+    end
+    alias_method :text, :content
+    alias_method :inner_text, :content
+    alias_method :to_str, :content
+    def inner_html(*args)
+      self.map { |n| n.inner_html(*args) }.join
+    end
+    def outer_html(*args)
+      self.map { |n| n.outer_html(*args) }.join
+    end
+    alias_method :to_s, :outer_html
+    alias_method :to_html, :outer_html
+    alias_method :serialize, :outer_html
+    def remove
+      self.each(&:remove)
+    end
+    alias_method :unlink, :remove
+    alias_method :to_ary, :to_a
+    def destroy
+      self.each(&:destroy)
+    end
+    def pop
+      return nil if length == 0
+      delete(last)
+    end
+    def shift
+      return nil if length == 0
+      delete(first)
+    end
+    def ==(other)
+      return false unless other.is_a?(NodeSet)
+      return false unless length == other.length
+      each_with_index do |node, i|
+        return false unless node == other[i]
+      end
+      true
+    end
+    def children
+      node_set = NodeSet.new(@document)
+      each do |node|
+        node.children.each { |n| node_set.push(n) }
+      end
+      node_set
+    end
+    def reverse
+      node_set = NodeSet.new(@document)
+      (length - 1).downto(0) do |x|
+        node_set.push(self[x])
+      end
+      node_set
+    end
+    def xpath(*args)
+      paths, handler, ns, binds = extract_params(args)
+      NodeSet.new(@document) do |set|
+        each do |node|
+          node.send(:xpath_internal, node, paths, handler, ns, binds).each do |inner_node|
+            set << inner_node
+          end
+        end
+      end
+    end
+  end
+end

data/lib/nokolexbor/version.rb ADDED Viewed

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+module Nokolexbor
+  VERSION = '0.3.0'
+end

data/lib/nokolexbor/xpath.rb ADDED Viewed

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+module Nokolexbor
+  module XPath
+    class SyntaxError < StandardError
+      attr_reader :domain
+      attr_reader :code
+      attr_reader :level
+      attr_reader :file
+      attr_reader :line
+      attr_reader :str1
+      attr_reader :str2
+      attr_reader :str3
+      attr_reader :int1
+      attr_reader :column
+      ###
+      # return true if this is a non error
+      def none?
+        level == 0
+      end
+      ###
+      # return true if this is a warning
+      def warning?
+        level == 1
+      end
+      ###
+      # return true if this is an error
+      def error?
+        level == 2
+      end
+      ###
+      # return true if this error is fatal
+      def fatal?
+        level == 3
+      end
+      def to_s
+        message = super.chomp
+        [location_to_s, level_to_s, message]
+          .compact.join(": ")
+          .force_encoding(message.encoding)
+      end
+      private
+      def level_to_s
+        case level
+        when 3 then "FATAL"
+        when 2 then "ERROR"
+        when 1 then "WARNING"
+        end
+      end
+      def nil_or_zero?(attribute)
+        attribute.nil? || attribute.zero?
+      end
+      def location_to_s
+        return nil if nil_or_zero?(line) && nil_or_zero?(column)
+        "#{line}:#{column}"
+      end
+    end
+  end
+end

data/lib/nokolexbor/xpath_context.rb ADDED Viewed

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+module Nokolexbor
+  class XPathContext
+    ###
+    # Register namespaces in +namespaces+
+    def register_namespaces(namespaces)
+      namespaces.each do |k, v|
+        k = k.to_s.gsub(/.*:/, "") # strip off 'xmlns:' or 'xml:'
+        register_ns(k, v)
+      end
+    end
+  end
+end

data/lib/nokolexbor.rb ADDED Viewed

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+begin
+  # pre-compiled extension by rake-compiler is located inside lib/nokolexbor/<ruby_version>/
+  RUBY_VERSION =~ /(\d+\.\d+)/
+  require "nokolexbor/#{Regexp.last_match(1)}/nokolexbor"
+rescue LoadError => e
+  if /GLIBC/.match?(e.message)
+    warn(<<~EOM)
+      ERROR: It looks like you're trying to use Nokolexbor as a precompiled native gem on a system
+             with an unsupported version of glibc.
+        #{e.message}
+        If that's the case, then please install Nokolexbor via the `ruby` platform gem:
+            gem install nokolexbor --platform=ruby
+        or:
+            bundle config set force_ruby_platform true
+    EOM
+    raise e
+  end
+  require 'nokolexbor/nokolexbor'
+end
+require 'nokolexbor/version'
+require 'nokolexbor/node'
+require 'nokolexbor/document'
+require 'nokolexbor/node_set'
+require 'nokolexbor/attribute'
+require 'nokolexbor/xpath'
+require 'nokolexbor/xpath_context'
+module Nokolexbor
+  class << self
+    def HTML(*args)
+      Document.parse(*args)
+    end
+  end
+end

metadata ADDED Viewed

@@ -0,0 +1,83 @@
+--- !ruby/object:Gem::Specification
+name: nokolexbor
+version: !ruby/object:Gem::Version
+  version: 0.3.0
+platform: x64-mingw-ucrt
+authors:
+- Yicheng Zhou
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2022-12-31 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake-compiler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+description: Nokolexbor is a high-performance HTML5 parser, with support for both
+  CSS selectors and XPath. It's API is designed to be compatible with Nokogiri.
+email: zyc9012@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/nokolexbor.rb
+- lib/nokolexbor/3.1/nokolexbor.so
+- lib/nokolexbor/attribute.rb
+- lib/nokolexbor/document.rb
+- lib/nokolexbor/node.rb
+- lib/nokolexbor/node_set.rb
+- lib/nokolexbor/version.rb
+- lib/nokolexbor/xpath.rb
+- lib/nokolexbor/xpath_context.rb
+homepage: https://github.com/serpapi/nokolexbor
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.1'
+  - - "<"
+    - !ruby/object:Gem::Version
+      version: 3.2.dev
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.3.4
+signing_key:
+specification_version: 4
+summary: High-performance HTML5 parser, with support for both CSS selectors and XPath.
+test_files: []