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

nokolexbor 0.3.0-x64-mingw-ucrt

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: []