video_chat_get 0.1.6 → 0.2.2

data/vendor/bundle/ruby/2.5.0/gems/nokogiri-1.10.9/lib/nokogiri/xml/searchable.rb

@@ -1,230 +0,0 @@
-module Nokogiri
-  module XML
-    #
-    #  The Searchable module declares the interface used for searching your DOM.
-    #
-    #  It implements the public methods `search`, `css`, and `xpath`,
-    #  as well as allowing specific implementations to specialize some
-    #  of the important behaviors.
-    #
-    module Searchable
-      # Regular expression used by Searchable#search to determine if a query
-      # string is CSS or XPath
-      LOOKS_LIKE_XPATH = /^(\.\/|\/|\.\.|\.$)/
-      
-      ###
-      # call-seq: search *paths, [namespace-bindings, xpath-variable-bindings, custom-handler-class]
-      #
-      # Search this object for +paths+. +paths+ must be one or more XPath or CSS queries:
-      #
-      #   node.search("div.employee", ".//title")
-      #
-      # A hash of namespace bindings may be appended:
-      #
-      #   node.search('.//bike:tire', {'bike' => 'http://schwinn.com/'})
-      #   node.search('bike|tire', {'bike' => 'http://schwinn.com/'})
-      #
-      # For XPath queries, a hash of variable bindings may also be
-      # appended to the namespace bindings. For example:
-      #
-      #   node.search('.//address[@domestic=$value]', nil, {:value => 'Yes'})
-      #
-      # Custom XPath functions and CSS pseudo-selectors may also be
-      # defined. To define custom functions create a class and
-      # implement the function you want to define.  The first argument
-      # to the method will be the current matching NodeSet.  Any other
-      # arguments are ones that you pass in.  Note that this class may
-      # appear anywhere in the argument list.  For example:
-      #
-      #   node.search('.//title[regex(., "\w+")]', 'div.employee:regex("[0-9]+")'
-      #     Class.new {
-      #       def regex node_set, regex
-      #         node_set.find_all { |node| node['some_attribute'] =~ /#{regex}/ }
-      #       end
-      #     }.new
-      #   )
-      #
-      # See Searchable#xpath and Searchable#css for further usage help.
-      def search *args
-        paths, handler, ns, binds = extract_params(args)
-
-        xpaths = paths.map(&:to_s).map do |path|
-          (path =~ LOOKS_LIKE_XPATH) ? path : xpath_query_from_css_rule(path, ns)
-        end.flatten.uniq
-
-        xpath(*(xpaths + [ns, handler, binds].compact))
-      end
-      alias :/ :search
-
-      ###
-      # call-seq: search *paths, [namespace-bindings, xpath-variable-bindings, custom-handler-class]
-      #
-      # Search this object for +paths+, and return only the first
-      # result. +paths+ must be one or more XPath or CSS queries.
-      #
-      # See Searchable#search for more information.
-      def at *args
-        search(*args).first
-      end
-      alias :% :at
-
-      ###
-      # call-seq: css *rules, [namespace-bindings, custom-pseudo-class]
-      #
-      # Search this object for CSS +rules+. +rules+ must be one or more CSS
-      # selectors. For example:
-      #
-      #   node.css('title')
-      #   node.css('body h1.bold')
-      #   node.css('div + p.green', 'div#one')
-      #
-      # A hash of namespace bindings may be appended. For example:
-      #
-      #   node.css('bike|tire', {'bike' => 'http://schwinn.com/'})
-      #
-      # Custom CSS pseudo classes may also be defined.  To define
-      # custom pseudo classes, create a class and implement the custom
-      # pseudo class you want defined.  The first argument to the
-      # method will be the current matching NodeSet.  Any other
-      # arguments are ones that you pass in.  For example:
-      #
-      #   node.css('title:regex("\w+")', Class.new {
-      #     def regex node_set, regex
-      #       node_set.find_all { |node| node['some_attribute'] =~ /#{regex}/ }
-      #     end
-      #   }.new)
-      #
-      # Note that the CSS query string is case-sensitive with regards
-      # to your document type. That is, if you're looking for "H1" in
-      # an HTML document, you'll never find anything, since HTML tags
-      # will match only lowercase CSS queries. However, "H1" might be
-      # found in an XML document, where tags names are case-sensitive
-      # (e.g., "H1" is distinct from "h1").
-      #
-      def css *args
-        rules, handler, ns, _ = extract_params(args)
-
-        css_internal self, rules, handler, ns
-      end
-
-      ##
-      # call-seq: css *rules, [namespace-bindings, custom-pseudo-class]
-      #
-      # Search this object for CSS +rules+, and return only the first
-      # match. +rules+ must be one or more CSS selectors.
-      #
-      # See Searchable#css for more information.
-      def at_css *args
-        css(*args).first
-      end
-
-      ###
-      # call-seq: xpath *paths, [namespace-bindings, variable-bindings, custom-handler-class]
-      #
-      # Search this node for XPath +paths+. +paths+ must be one or more XPath
-      # queries.
-      #
-      #   node.xpath('.//title')
-      #
-      # A hash of namespace bindings may be appended. For example:
-      #
-      #   node.xpath('.//foo:name', {'foo' => 'http://example.org/'})
-      #   node.xpath('.//xmlns:name', node.root.namespaces)
-      #
-      # A hash of variable bindings may also be appended to the namespace bindings. For example:
-      #
-      #   node.xpath('.//address[@domestic=$value]', nil, {:value => 'Yes'})
-      #
-      # Custom XPath functions may also be defined.  To define custom
-      # functions create a class and implement the function you want
-      # to define.  The first argument to the method will be the
-      # current matching NodeSet.  Any other arguments are ones that
-      # you pass in.  Note that this class may appear anywhere in the
-      # argument list.  For example:
-      #
-      #   node.xpath('.//title[regex(., "\w+")]', Class.new {
-      #     def regex node_set, regex
-      #       node_set.find_all { |node| node['some_attribute'] =~ /#{regex}/ }
-      #     end
-      #   }.new)
-      #
-      def xpath *args
-        paths, handler, ns, binds = extract_params(args)
-
-        xpath_internal self, paths, handler, ns, binds
-      end
-
-      ##
-      # call-seq: xpath *paths, [namespace-bindings, variable-bindings, custom-handler-class]
-      #
-      # Search this node for XPath +paths+, and return only the first
-      # match. +paths+ must be one or more XPath queries.
-      #
-      # See Searchable#xpath for more information.
-      def at_xpath *args
-        xpath(*args).first
-      end
-
-      private
-
-      def css_internal node, rules, handler, ns
-        xpath_internal node, css_rules_to_xpath(rules, ns), handler, ns, nil
-      end
-
-      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 if binds
-
-        ctx.evaluate(path, handler)
-      end
-
-      def css_rules_to_xpath(rules, ns)
-        rules.map { |rule| xpath_query_from_css_rule(rule, ns) }
-      end
-
-      def xpath_query_from_css_rule rule, ns
-        self.class::IMPLIED_XPATH_CONTEXTS.map do |implied_xpath_context|
-          CSS.xpath_for(rule.to_s, :prefix => implied_xpath_context, :ns => ns)
-        end.join(' | ')
-      end
-
-      def extract_params params # :nodoc:
-        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 ? document.root.namespaces : {}
-
-        [params, handler, ns, binds]
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.5.0/gems/nokogiri-1.10.9/lib/nokogiri/xml/syntax_error.rb

@@ -1,70 +0,0 @@
-module Nokogiri
-  module XML
-    ###
-    # This class provides information about XML SyntaxErrors.  These
-    # exceptions are typically stored on Nokogiri::XML::Document#errors.
-    class SyntaxError < ::Nokogiri::SyntaxError
-      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"
-        else nil
-        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/vendor/bundle/ruby/2.5.0/gems/nokogiri-1.10.9/lib/nokogiri/xml/text.rb

@@ -1,9 +0,0 @@
-module Nokogiri
-  module XML
-    class Text < Nokogiri::XML::CharacterData
-      def content=(string)
-        self.native_content = string.to_s
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.5.0/gems/nokogiri-1.10.9/lib/nokogiri/xml/xpath/syntax_error.rb

@@ -1,11 +0,0 @@
-module Nokogiri
-  module XML
-    class XPath
-      class SyntaxError < XML::SyntaxError
-        def to_s
-          [super.chomp, str1].compact.join(': ')
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.5.0/gems/nokogiri-1.10.9/lib/nokogiri/xml/xpath.rb

@@ -1,10 +0,0 @@
-require 'nokogiri/xml/xpath/syntax_error'
-
-module Nokogiri
-  module XML
-    class XPath
-      # The Nokogiri::XML::Document tied to this XPath instance
-      attr_accessor :document
-    end
-  end
-end

data/vendor/bundle/ruby/2.5.0/gems/nokogiri-1.10.9/lib/nokogiri/xml/xpath_context.rb

@@ -1,16 +0,0 @@
-module Nokogiri
-  module XML
-    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
-end

data/vendor/bundle/ruby/2.5.0/gems/nokogiri-1.10.9/lib/nokogiri/xml.rb

@@ -1,75 +0,0 @@
-require 'nokogiri/xml/pp'
-require 'nokogiri/xml/parse_options'
-require 'nokogiri/xml/sax'
-require 'nokogiri/xml/searchable'
-require 'nokogiri/xml/node'
-require 'nokogiri/xml/attribute_decl'
-require 'nokogiri/xml/element_decl'
-require 'nokogiri/xml/element_content'
-require 'nokogiri/xml/character_data'
-require 'nokogiri/xml/namespace'
-require 'nokogiri/xml/attr'
-require 'nokogiri/xml/dtd'
-require 'nokogiri/xml/cdata'
-require 'nokogiri/xml/text'
-require 'nokogiri/xml/document'
-require 'nokogiri/xml/document_fragment'
-require 'nokogiri/xml/processing_instruction'
-require 'nokogiri/xml/node_set'
-require 'nokogiri/xml/syntax_error'
-require 'nokogiri/xml/xpath'
-require 'nokogiri/xml/xpath_context'
-require 'nokogiri/xml/builder'
-require 'nokogiri/xml/reader'
-require 'nokogiri/xml/notation'
-require 'nokogiri/xml/entity_decl'
-require 'nokogiri/xml/entity_reference'
-require 'nokogiri/xml/schema'
-require 'nokogiri/xml/relax_ng'
-
-module Nokogiri
-  class << self
-    ###
-    # Parse XML.  Convenience method for Nokogiri::XML::Document.parse
-    def XML thing, url = nil, encoding = nil, options = XML::ParseOptions::DEFAULT_XML, &block
-      Nokogiri::XML::Document.parse(thing, url, encoding, options, &block)
-    end
-  end
-
-  module XML
-    # Original C14N 1.0 spec canonicalization
-    XML_C14N_1_0 =       0
-    # Exclusive C14N 1.0 spec canonicalization
-    XML_C14N_EXCLUSIVE_1_0 =     1
-    # C14N 1.1 spec canonicalization
-    XML_C14N_1_1 = 2
-    class << self
-      ###
-      # Parse an XML document using the Nokogiri::XML::Reader API.  See
-      # Nokogiri::XML::Reader for mor information
-      def Reader string_or_io, url = nil, encoding = nil, options = ParseOptions::STRICT
-
-        options = Nokogiri::XML::ParseOptions.new(options) if Integer === options
-        # Give the options to the user
-        yield options if block_given?
-
-        if string_or_io.respond_to? :read
-          return Reader.from_io(string_or_io, url, encoding, options.to_i)
-        end
-        Reader.from_memory(string_or_io, url, encoding, options.to_i)
-      end
-
-      ###
-      # Parse XML.  Convenience method for Nokogiri::XML::Document.parse
-      def parse thing, url = nil, encoding = nil, options = ParseOptions::DEFAULT_XML, &block
-        Document.parse(thing, url, encoding, options, &block)
-      end
-
-      ####
-      # Parse a fragment from +string+ in to a NodeSet.
-      def fragment string
-        XML::DocumentFragment.parse(string)
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.5.0/gems/nokogiri-1.10.9/lib/nokogiri/xslt/stylesheet.rb

@@ -1,25 +0,0 @@
-module Nokogiri
-  module XSLT
-    ###
-    # A Stylesheet represents an XSLT Stylesheet object.  Stylesheet creation
-    # is done through Nokogiri.XSLT.  Here is an example of transforming
-    # an XML::Document with a Stylesheet:
-    #
-    #   doc   = Nokogiri::XML(File.read('some_file.xml'))
-    #   xslt  = Nokogiri::XSLT(File.read('some_transformer.xslt'))
-    #
-    #   puts xslt.transform(doc)
-    #
-    # See Nokogiri::XSLT::Stylesheet#transform for more transformation
-    # information.
-    class Stylesheet
-      ###
-      # Apply an XSLT stylesheet to an XML::Document.
-      # +params+ is an array of strings used as XSLT parameters.
-      # returns serialized document
-      def apply_to document, params = []
-        serialize(transform(document, params))
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.5.0/gems/nokogiri-1.10.9/lib/nokogiri/xslt.rb

@@ -1,56 +0,0 @@
-require 'nokogiri/xslt/stylesheet'
-
-module Nokogiri
-  class << self
-    ###
-    # Create a Nokogiri::XSLT::Stylesheet with +stylesheet+.
-    #
-    # Example:
-    #
-    #   xslt = Nokogiri::XSLT(File.read(ARGV[0]))
-    #
-    def XSLT stylesheet, modules = {}
-      XSLT.parse(stylesheet, modules)
-    end
-  end
-
-  ###
-  # See Nokogiri::XSLT::Stylesheet for creating and manipulating
-  # Stylesheet object.
-  module XSLT
-    class << self
-      ###
-      # Parse the stylesheet in +string+, register any +modules+
-      def parse string, modules = {}
-        modules.each do |url, klass|
-          XSLT.register url, klass
-        end
-
-        if Nokogiri.jruby?
-          Stylesheet.parse_stylesheet_doc(XML.parse(string), string)
-        else
-          Stylesheet.parse_stylesheet_doc(XML.parse(string))
-        end
-      end
-
-      ###
-      # Quote parameters in +params+ for stylesheet safety
-      def quote_params params
-        parray = (params.instance_of?(Hash) ? params.to_a.flatten : params).dup
-        parray.each_with_index do |v,i|
-          if i % 2 > 0
-            parray[i]=
-              if v =~ /'/
-                "concat('#{ v.gsub(/'/, %q{', "'", '}) }')"
-              else
-                "'#{v}'";
-              end
-          else
-            parray[i] = v.to_s
-          end
-        end
-        parray.flatten
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.5.0/gems/nokogiri-1.10.9/lib/nokogiri.rb

@@ -1,144 +0,0 @@
-# -*- coding: utf-8 -*-
-# Modify the PATH on windows so that the external DLLs will get loaded.
-
-require 'rbconfig'
-
-if defined?(RUBY_ENGINE) && RUBY_ENGINE == "jruby"
-  # The line below caused a problem on non-GAE rack environment.
-  # unless defined?(JRuby::Rack::VERSION) || defined?(AppEngine::ApiProxy)
-  #
-  # However, simply cutting defined?(JRuby::Rack::VERSION) off resulted in
-  # an unable-to-load-nokogiri problem. Thus, now, Nokogiri checks the presense
-  # of appengine-rack.jar in $LOAD_PATH. If Nokogiri is on GAE, Nokogiri
-  # should skip loading xml jars. This is because those are in WEB-INF/lib and
-  # already set in the classpath.
-  unless $LOAD_PATH.to_s.include?("appengine-rack")
-    require 'stringio'
-    require 'isorelax.jar'
-    require 'jing.jar'
-    require 'nekohtml.jar'
-    require 'nekodtd.jar'
-    require 'xercesImpl.jar'
-    require 'serializer.jar'
-    require 'xalan.jar'
-    require 'xml-apis.jar'
-  end
-end
-
-begin
-  RUBY_VERSION =~ /(\d+\.\d+)/
-  require "nokogiri/#{$1}/nokogiri"
-rescue LoadError
-  require 'nokogiri/nokogiri'
-end
-require 'nokogiri/version'
-require 'nokogiri/syntax_error'
-require 'nokogiri/xml'
-require 'nokogiri/xslt'
-require 'nokogiri/html'
-require 'nokogiri/decorators/slop'
-require 'nokogiri/css'
-require 'nokogiri/html/builder'
-
-# Nokogiri parses and searches XML/HTML very quickly, and also has
-# correctly implemented CSS3 selector support as well as XPath 1.0
-# support.
-#
-# Parsing a document returns either a Nokogiri::XML::Document, or a
-# Nokogiri::HTML::Document depending on the kind of document you parse.
-#
-# Here is an example:
-#
-#   require 'nokogiri'
-#   require 'open-uri'
-#
-#   # Get a Nokogiri::HTML:Document for the page we’re interested in...
-#
-#   doc = Nokogiri::HTML(open('http://www.google.com/search?q=tenderlove'))
-#
-#   # Do funky things with it using Nokogiri::XML::Node methods...
-#
-#   ####
-#   # Search for nodes by css
-#   doc.css('h3.r a.l').each do |link|
-#     puts link.content
-#   end
-#
-# See Nokogiri::XML::Searchable#css for more information about CSS searching.
-# See Nokogiri::XML::Searchable#xpath for more information about XPath searching.
-module Nokogiri
-  class << self
-    ###
-    # Parse an HTML or XML document.  +string+ contains the document.
-    def parse string, url = nil, encoding = nil, options = nil
-      if string.respond_to?(:read) ||
-          /^\s*<(?:!DOCTYPE\s+)?html[\s>]/i === string[0, 512]
-        # Expect an HTML indicator to appear within the first 512
-        # characters of a document. (<?xml ?> + <?xml-stylesheet ?>
-        # shouldn't be that long)
-        Nokogiri.HTML(string, url, encoding,
-          options || XML::ParseOptions::DEFAULT_HTML)
-      else
-        Nokogiri.XML(string, url, encoding,
-          options || XML::ParseOptions::DEFAULT_XML)
-      end.tap { |doc|
-        yield doc if block_given?
-      }
-    end
-
-    ###
-    # Create a new Nokogiri::XML::DocumentFragment
-    def make input = nil, opts = {}, &blk
-      if input
-        Nokogiri::HTML.fragment(input).children.first
-      else
-        Nokogiri(&blk)
-      end
-    end
-
-    ###
-    # Parse a document and add the Slop decorator.  The Slop decorator
-    # implements method_missing such that methods may be used instead of CSS
-    # or XPath.  For example:
-    #
-    #   doc = Nokogiri::Slop(<<-eohtml)
-    #     <html>
-    #       <body>
-    #         <p>first</p>
-    #         <p>second</p>
-    #       </body>
-    #     </html>
-    #   eohtml
-    #   assert_equal('second', doc.html.body.p[1].text)
-    #
-    def Slop(*args, &block)
-      Nokogiri(*args, &block).slop!
-    end
-
-    def install_default_aliases
-      # Make sure to support some popular encoding aliases not known by
-      # all iconv implementations.
-      {
-        'Windows-31J' => 'CP932',	# Windows-31J is the IANA registered name of CP932.
-      }.each { |alias_name, name|
-        EncodingHandler.alias(name, alias_name) if EncodingHandler[alias_name].nil?
-      }
-    end
-  end
-
-  Nokogiri.install_default_aliases
-end
-
-###
-# Parser a document contained in +args+.  Nokogiri will try to guess what
-# type of document you are attempting to parse.  For more information, see
-# Nokogiri.parse
-#
-# To specify the type of document, use Nokogiri.XML or Nokogiri.HTML.
-def Nokogiri(*args, &block)
-  if block_given?
-    Nokogiri::HTML::Builder.new(&block).doc.root
-  else
-    Nokogiri.parse(*args)
-  end
-end