video_chat_get 0.1.6 → 0.2.2

data/vendor/bundle/ruby/2.5.0/gems/nokogiri-1.10.9/lib/nokogiri/css/parser.y

@@ -1,272 +0,0 @@
-class Nokogiri::CSS::Parser
-
-token FUNCTION INCLUDES DASHMATCH LBRACE HASH PLUS GREATER S STRING IDENT
-token COMMA NUMBER PREFIXMATCH SUFFIXMATCH SUBSTRINGMATCH TILDE NOT_EQUAL
-token SLASH DOUBLESLASH NOT EQUAL RPAREN LSQUARE RSQUARE HAS
-
-rule
-  selector
-    : selector COMMA simple_selector_1toN {
-        result = [val.first, val.last].flatten
-      }
-    | prefixless_combinator_selector { result = val.flatten }
-    | optional_S simple_selector_1toN { result = [val.last].flatten }
-    ;
-  combinator
-    : PLUS { result = :DIRECT_ADJACENT_SELECTOR }
-    | GREATER { result = :CHILD_SELECTOR }
-    | TILDE { result = :FOLLOWING_SELECTOR }
-    | DOUBLESLASH { result = :DESCENDANT_SELECTOR }
-    | SLASH { result = :CHILD_SELECTOR }
-    ;
-  simple_selector
-    : element_name hcap_0toN {
-        result =  if val[1].nil?
-                    val.first
-                  else
-                    Node.new(:CONDITIONAL_SELECTOR, [val.first, val[1]])
-                  end
-      }
-    | function
-    | function pseudo {
-        result = Node.new(:CONDITIONAL_SELECTOR, val)
-      }
-    | function attrib {
-        result = Node.new(:CONDITIONAL_SELECTOR, val)
-      }
-    | hcap_1toN {
-        result = Node.new(:CONDITIONAL_SELECTOR,
-          [Node.new(:ELEMENT_NAME, ['*']), val.first]
-        )
-      }
-    ;
-  prefixless_combinator_selector
-    : combinator simple_selector_1toN {
-        result = Node.new(val.first, [nil, val.last])
-      }
-    ;
-  simple_selector_1toN
-    : simple_selector combinator simple_selector_1toN {
-        result = Node.new(val[1], [val.first, val.last])
-      }
-    | simple_selector S simple_selector_1toN {
-        result = Node.new(:DESCENDANT_SELECTOR, [val.first, val.last])
-      }
-    | simple_selector
-    ;
-  class
-    : '.' IDENT { result = Node.new(:CLASS_CONDITION, [unescape_css_identifier(val[1])]) }
-    ;
-  element_name
-    : namespaced_ident
-    | '*' { result = Node.new(:ELEMENT_NAME, val) }
-    ;
-  namespaced_ident
-    : namespace '|' IDENT {
-        result = Node.new(:ELEMENT_NAME,
-          [[val.first, val.last].compact.join(':')]
-        )
-      }
-    | IDENT {
-        name = @namespaces.key?('xmlns') ? "xmlns:#{val.first}" : val.first
-        result = Node.new(:ELEMENT_NAME, [name])
-      }
-    ;
-  namespace
-    : IDENT { result = val[0] }
-    |
-    ;
-  attrib
-    : LSQUARE attrib_name attrib_val_0or1 RSQUARE {
-        result = Node.new(:ATTRIBUTE_CONDITION,
-          [val[1]] + (val[2] || [])
-        )
-      }
-    | LSQUARE function attrib_val_0or1 RSQUARE {
-        result = Node.new(:ATTRIBUTE_CONDITION,
-          [val[1]] + (val[2] || [])
-        )
-      }
-    | LSQUARE NUMBER RSQUARE {
-        # Non standard, but hpricot supports it.
-        result = Node.new(:PSEUDO_CLASS,
-          [Node.new(:FUNCTION, ['nth-child(', val[1]])]
-        )
-      }
-    ;
-  attrib_name
-    : namespace '|' IDENT {
-        result = Node.new(:ELEMENT_NAME,
-          [[val.first, val.last].compact.join(':')]
-        )
-      }
-    | IDENT {
-        # Default namespace is not applied to attributes.
-        # So we don't add prefix "xmlns:" as in namespaced_ident.
-        result = Node.new(:ELEMENT_NAME, [val.first])
-      }
-    ;
-  function
-    : FUNCTION RPAREN {
-        result = Node.new(:FUNCTION, [val.first.strip])
-      }
-    | FUNCTION expr RPAREN {
-        result = Node.new(:FUNCTION, [val.first.strip, val[1]].flatten)
-      }
-    | FUNCTION nth RPAREN {
-        result = Node.new(:FUNCTION, [val.first.strip, val[1]].flatten)
-      }
-    | NOT expr RPAREN {
-        result = Node.new(:FUNCTION, [val.first.strip, val[1]].flatten)
-      }
-    | HAS selector RPAREN {
-        result = Node.new(:FUNCTION, [val.first.strip, val[1]].flatten)
-      }
-    ;
-  expr
-    : NUMBER COMMA expr { result = [val.first, val.last] }
-    | STRING COMMA expr { result = [val.first, val.last] }
-    | IDENT COMMA expr { result = [val.first, val.last] }
-    | NUMBER
-    | STRING
-    | IDENT                             # even, odd
-      {
-        case val[0]
-        when 'even'
-          result = Node.new(:NTH, ['2','n','+','0'])
-        when 'odd'
-          result = Node.new(:NTH, ['2','n','+','1'])
-        when 'n'
-          result = Node.new(:NTH, ['1','n','+','0'])
-        else
-          # This is not CSS standard.  It allows us to support this:
-          # assert_xpath("//a[foo(., @href)]", @parser.parse('a:foo(@href)'))
-          # assert_xpath("//a[foo(., @a, b)]", @parser.parse('a:foo(@a, b)'))
-          # assert_xpath("//a[foo(., a, 10)]", @parser.parse('a:foo(a, 10)'))
-          result = val
-        end
-      }
-    ;
-  nth
-    : NUMBER IDENT PLUS NUMBER          # 5n+3 -5n+3
-      {
-        if val[1] == 'n'
-          result = Node.new(:NTH, val)
-        else
-          raise Racc::ParseError, "parse error on IDENT '#{val[1]}'"
-        end
-      }
-    | IDENT PLUS NUMBER {               # n+3, -n+3
-        if val[0] == 'n'
-          val.unshift("1")
-          result = Node.new(:NTH, val)
-        elsif val[0] == '-n'
-          val[0] = 'n'
-          val.unshift("-1")
-          result = Node.new(:NTH, val)
-        else
-          raise Racc::ParseError, "parse error on IDENT '#{val[1]}'"
-        end
-      }
-    | NUMBER IDENT {                    # 5n, -5n, 10n-1
-        n = val[1]
-        if n[0, 2] == 'n-'
-          val[1] = 'n'
-          val << "-"
-          # b is contained in n as n is the string "n-b"
-          val << n[2, n.size]
-          result = Node.new(:NTH, val)
-        elsif n == 'n'
-          val << "+"
-          val << "0"
-          result = Node.new(:NTH, val)
-        else
-          raise Racc::ParseError, "parse error on IDENT '#{val[1]}'"
-        end
-      }
-    ;
-  pseudo
-    : ':' function {
-        result = Node.new(:PSEUDO_CLASS, [val[1]])
-      }
-    | ':' IDENT { result = Node.new(:PSEUDO_CLASS, [val[1]]) }
-    ;
-  hcap_0toN
-    : hcap_1toN
-    |
-    ;
-  hcap_1toN
-    : attribute_id hcap_1toN {
-        result = Node.new(:COMBINATOR, val)
-      }
-    | class hcap_1toN {
-        result = Node.new(:COMBINATOR, val)
-      }
-    | attrib hcap_1toN {
-        result = Node.new(:COMBINATOR, val)
-      }
-    | pseudo hcap_1toN {
-        result = Node.new(:COMBINATOR, val)
-      }
-    | negation hcap_1toN {
-        result = Node.new(:COMBINATOR, val)
-      }
-    | attribute_id
-    | class
-    | attrib
-    | pseudo
-    | negation
-    ;
-  attribute_id
-    : HASH { result = Node.new(:ID, [unescape_css_identifier(val.first)]) }
-    ;
-  attrib_val_0or1
-    : eql_incl_dash IDENT { result = [val.first, unescape_css_identifier(val[1])] }
-    | eql_incl_dash STRING { result = [val.first, unescape_css_string(val[1])] }
-    | eql_incl_dash NUMBER { result = [val.first, val[1]] }
-    |
-    ;
-  eql_incl_dash
-    : EQUAL           { result = :equal }
-    | PREFIXMATCH     { result = :prefix_match }
-    | SUFFIXMATCH     { result = :suffix_match }
-    | SUBSTRINGMATCH  { result = :substring_match }
-    | NOT_EQUAL       { result = :not_equal }
-    | INCLUDES        { result = :includes }
-    | DASHMATCH       { result = :dash_match }
-    ;
-  negation
-    : NOT negation_arg RPAREN {
-        result = Node.new(:NOT, [val[1]])
-      }
-    ;
-  negation_arg
-    : element_name
-    | element_name hcap_1toN
-    | hcap_1toN
-    ;
-  optional_S
-    : S
-    |
-    ;
-end
-
----- header
-
-require 'nokogiri/css/parser_extras'
-
----- inner
-
-def unescape_css_identifier(identifier)
-  identifier.gsub(/\\(?:([^0-9a-fA-F])|([0-9a-fA-F]{1,6})\s?)/){ |m| $1 || [$2.hex].pack('U') }
-end
-
-def unescape_css_string(str)
-  str.gsub(/\\(?:([^0-9a-fA-F])|([0-9a-fA-F]{1,6})\s?)/) do |m|
-    if $1=="\n"
-      ''
-    else
-      $1 || [$2.hex].pack('U')
-    end
-  end
-end

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

@@ -1,91 +0,0 @@
-require 'thread'
-
-module Nokogiri
-  module CSS
-    class Parser < Racc::Parser
-      @cache_on = true
-      @cache    = {}
-      @mutex    = Mutex.new
-
-      class << self
-        # Turn on CSS parse caching
-        attr_accessor :cache_on
-        alias :cache_on? :cache_on
-        alias :set_cache :cache_on=
-
-        # Get the css selector in +string+ from the cache
-        def [] string
-          return unless @cache_on
-          @mutex.synchronize { @cache[string] }
-        end
-
-        # Set the css selector in +string+ in the cache to +value+
-        def []= string, value
-          return value unless @cache_on
-          @mutex.synchronize { @cache[string] = value }
-        end
-
-        # Clear the cache
-        def clear_cache
-          @mutex.synchronize { @cache = {} }
-        end
-
-        # Execute +block+ without cache
-        def without_cache &block
-          tmp = @cache_on
-          @cache_on = false
-          block.call
-          @cache_on = tmp
-        end
-
-        ###
-        # Parse this CSS selector in +selector+.  Returns an AST.
-        def parse selector
-          @warned ||= false
-          unless @warned
-            $stderr.puts('Nokogiri::CSS::Parser.parse is deprecated, call Nokogiri::CSS.parse(), this will be removed August 1st or version 1.4.0 (whichever is first)')
-            @warned = true
-          end
-          new.parse selector
-        end
-      end
-
-      # Create a new CSS parser with respect to +namespaces+
-      def initialize namespaces = {}
-        @tokenizer  = Tokenizer.new
-        @namespaces = namespaces
-        super()
-      end
-
-      def parse string
-        @tokenizer.scan_setup string
-        do_parse
-      end
-
-      def next_token
-        @tokenizer.next_token
-      end
-
-      # Get the xpath for +string+ using +options+
-      def xpath_for string, options={}
-        key = "#{string}#{options[:ns]}#{options[:prefix]}"
-        v = self.class[key]
-        return v if v
-
-        args = [
-          options[:prefix] || '//',
-          options[:visitor] || XPathVisitor.new
-        ]
-        self.class[key] = parse(string).map { |ast|
-          ast.to_xpath(*args)
-        }
-      end
-
-      # On CSS parser error, raise an exception
-      def on_error error_token_id, error_value, value_stack
-        after = value_stack.compact.last
-        raise SyntaxError.new("unexpected '#{error_value}' after '#{after}'")
-      end
-    end
-  end
-end

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

@@ -1,7 +0,0 @@
-require 'nokogiri/syntax_error'
-module Nokogiri
-  module CSS
-    class SyntaxError < ::Nokogiri::SyntaxError
-    end
-  end
-end

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

@@ -1,153 +0,0 @@
-#--
-# DO NOT MODIFY!!!!
-# This file is automatically generated by rex 1.0.7
-# from lexical definition file "lib/nokogiri/css/tokenizer.rex".
-#++
-
-module Nokogiri
-module CSS
-class Tokenizer # :nodoc:
-      require 'strscan'
-
-      class ScanError < StandardError ; end
-
-      attr_reader   :lineno
-      attr_reader   :filename
-      attr_accessor :state
-
-      def scan_setup(str)
-        @ss = StringScanner.new(str)
-        @lineno =  1
-        @state  = nil
-      end
-
-      def action
-        yield
-      end
-
-      def scan_str(str)
-        scan_setup(str)
-        do_parse
-      end
-      alias :scan :scan_str
-
-      def load_file( filename )
-        @filename = filename
-        File.open(filename, "r") do |f|
-          scan_setup(f.read)
-        end
-      end
-
-      def scan_file( filename )
-        load_file(filename)
-        do_parse
-      end
-
-
-        def next_token
-          return if @ss.eos?
-
-          # skips empty actions
-          until token = _next_token or @ss.eos?; end
-          token
-        end
-
-        def _next_token
-          text = @ss.peek(1)
-          @lineno  +=  1  if text == "\n"
-          token = case @state
-            when nil
-          case
-                  when (text = @ss.scan(/has\([\s]*/))
-                     action { [:HAS, text] }
-
-                  when (text = @ss.scan(/[-@]?([_A-Za-z]|[^\0-\177]|\\[0-9A-Fa-f]{1,6}(\r\n|[\s])?|\\[^\n\r\f0-9A-Fa-f])([_A-Za-z0-9-]|[^\0-\177]|\\[0-9A-Fa-f]{1,6}(\r\n|[\s])?|\\[^\n\r\f0-9A-Fa-f])*\([\s]*/))
-                     action { [:FUNCTION, text] }
-
-                  when (text = @ss.scan(/[-@]?([_A-Za-z]|[^\0-\177]|\\[0-9A-Fa-f]{1,6}(\r\n|[\s])?|\\[^\n\r\f0-9A-Fa-f])([_A-Za-z0-9-]|[^\0-\177]|\\[0-9A-Fa-f]{1,6}(\r\n|[\s])?|\\[^\n\r\f0-9A-Fa-f])*/))
-                     action { [:IDENT, text] }
-
-                  when (text = @ss.scan(/\#([_A-Za-z0-9-]|[^\0-\177]|\\[0-9A-Fa-f]{1,6}(\r\n|[\s])?|\\[^\n\r\f0-9A-Fa-f])+/))
-                     action { [:HASH, text] }
-
-                  when (text = @ss.scan(/[\s]*~=[\s]*/))
-                     action { [:INCLUDES, text] }
-
-                  when (text = @ss.scan(/[\s]*\|=[\s]*/))
-                     action { [:DASHMATCH, text] }
-
-                  when (text = @ss.scan(/[\s]*\^=[\s]*/))
-                     action { [:PREFIXMATCH, text] }
-
-                  when (text = @ss.scan(/[\s]*\$=[\s]*/))
-                     action { [:SUFFIXMATCH, text] }
-
-                  when (text = @ss.scan(/[\s]*\*=[\s]*/))
-                     action { [:SUBSTRINGMATCH, text] }
-
-                  when (text = @ss.scan(/[\s]*!=[\s]*/))
-                     action { [:NOT_EQUAL, text] }
-
-                  when (text = @ss.scan(/[\s]*=[\s]*/))
-                     action { [:EQUAL, text] }
-
-                  when (text = @ss.scan(/[\s]*\)/))
-                     action { [:RPAREN, text] }
-
-                  when (text = @ss.scan(/\[[\s]*/))
-                     action { [:LSQUARE, text] }
-
-                  when (text = @ss.scan(/[\s]*\]/))
-                     action { [:RSQUARE, text] }
-
-                  when (text = @ss.scan(/[\s]*\+[\s]*/))
-                     action { [:PLUS, text] }
-
-                  when (text = @ss.scan(/[\s]*>[\s]*/))
-                     action { [:GREATER, text] }
-
-                  when (text = @ss.scan(/[\s]*,[\s]*/))
-                     action { [:COMMA, text] }
-
-                  when (text = @ss.scan(/[\s]*~[\s]*/))
-                     action { [:TILDE, text] }
-
-                  when (text = @ss.scan(/\:not\([\s]*/))
-                     action { [:NOT, text] }
-
-                  when (text = @ss.scan(/-?([0-9]+|[0-9]*\.[0-9]+)/))
-                     action { [:NUMBER, text] }
-
-                  when (text = @ss.scan(/[\s]*\/\/[\s]*/))
-                     action { [:DOUBLESLASH, text] }
-
-                  when (text = @ss.scan(/[\s]*\/[\s]*/))
-                     action { [:SLASH, text] }
-
-                  when (text = @ss.scan(/U\+[0-9a-f?]{1,6}(-[0-9a-f]{1,6})?/))
-                     action {[:UNICODE_RANGE, text] }
-
-                  when (text = @ss.scan(/[\s]+/))
-                     action { [:S, text] }
-
-                  when (text = @ss.scan(/"([^\n\r\f"]|\n|\r\n|\r|\f|[^\0-\177]|\\[0-9A-Fa-f]{1,6}(\r\n|[\s])?|\\[^\n\r\f0-9A-Fa-f])*(?<!\\)(?:\\{2})*"|'([^\n\r\f']|\n|\r\n|\r|\f|[^\0-\177]|\\[0-9A-Fa-f]{1,6}(\r\n|[\s])?|\\[^\n\r\f0-9A-Fa-f])*(?<!\\)(?:\\{2})*'/))
-                     action { [:STRING, text] }
-
-                  when (text = @ss.scan(/./))
-                     action { [text, text] }
-
-          
-          else
-            text = @ss.string[@ss.pos .. -1]
-            raise  ScanError, "can not match: '" + text + "'"
-          end  # if
-
-        else
-          raise  ScanError, "undefined state: '" + state.to_s + "'"
-        end  # case state
-          token
-        end  # def _next_token
-
-end # class
-end
-end

data/vendor/bundle/ruby/2.5.0/gems/nokogiri-1.10.9/lib/nokogiri/css/tokenizer.rex

@@ -1,55 +0,0 @@
-module Nokogiri
-module CSS
-class Tokenizer # :nodoc:
-
-macro
-  nl        \n|\r\n|\r|\f
-  w         [\s]*
-  nonascii  [^\0-\177]
-  num       -?([0-9]+|[0-9]*\.[0-9]+)
-  unicode   \\[0-9A-Fa-f]{1,6}(\r\n|[\s])?
-
-  escape    {unicode}|\\[^\n\r\f0-9A-Fa-f]
-  nmchar    [_A-Za-z0-9-]|{nonascii}|{escape}
-  nmstart   [_A-Za-z]|{nonascii}|{escape}
-  ident     [-@]?({nmstart})({nmchar})*
-  name      ({nmchar})+
-  string1   "([^\n\r\f"]|{nl}|{nonascii}|{escape})*(?<!\\)(?:\\{2})*"
-  string2   '([^\n\r\f']|{nl}|{nonascii}|{escape})*(?<!\\)(?:\\{2})*'
-  string    {string1}|{string2}
-
-rule
-
-# [:state]  pattern  [actions]
-
-            has\({w}         { [:HAS, text] }
-            {ident}\({w}     { [:FUNCTION, text] }
-            {ident}          { [:IDENT, text] }
-            \#{name}         { [:HASH, text] }
-            {w}~={w}         { [:INCLUDES, text] }
-            {w}\|={w}        { [:DASHMATCH, text] }
-            {w}\^={w}        { [:PREFIXMATCH, text] }
-            {w}\$={w}        { [:SUFFIXMATCH, text] }
-            {w}\*={w}        { [:SUBSTRINGMATCH, text] }
-            {w}!={w}         { [:NOT_EQUAL, text] }
-            {w}={w}          { [:EQUAL, text] }
-            {w}\)            { [:RPAREN, text] }
-            \[{w}            { [:LSQUARE, text] }
-            {w}\]            { [:RSQUARE, text] }
-            {w}\+{w}         { [:PLUS, text] }
-            {w}>{w}          { [:GREATER, text] }
-            {w},{w}          { [:COMMA, text] }
-            {w}~{w}          { [:TILDE, text] }
-            \:not\({w}       { [:NOT, text] }
-            {num}            { [:NUMBER, text] }
-            {w}\/\/{w}       { [:DOUBLESLASH, text] }
-            {w}\/{w}         { [:SLASH, text] }
-
-            U\+[0-9a-f?]{1,6}(-[0-9a-f]{1,6})?  {[:UNICODE_RANGE, text] }
-
-            [\s]+            { [:S, text] }
-            {string}         { [:STRING, text] }
-            .                { [text, text] }
-end
-end
-end