video_chat_get 0.1.4 → 0.1.5

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

@@ -0,0 +1,122 @@
+module Nokogiri
+  module XML
+    module SAX
+      ###
+      # This parser is a SAX style parser that reads it's input as it
+      # deems necessary.  The parser takes a Nokogiri::XML::SAX::Document,
+      # an optional encoding, then given an XML input, sends messages to
+      # the Nokogiri::XML::SAX::Document.
+      #
+      # Here is an example of using this parser:
+      #
+      #   # Create a subclass of Nokogiri::XML::SAX::Document and implement
+      #   # the events we care about:
+      #   class MyDoc < Nokogiri::XML::SAX::Document
+      #     def start_element name, attrs = []
+      #       puts "starting: #{name}"
+      #     end
+      #
+      #     def end_element name
+      #       puts "ending: #{name}"
+      #     end
+      #   end
+      #
+      #   # Create our parser
+      #   parser = Nokogiri::XML::SAX::Parser.new(MyDoc.new)
+      #
+      #   # Send some XML to the parser
+      #   parser.parse(File.open(ARGV[0]))
+      #
+      # For more information about SAX parsers, see Nokogiri::XML::SAX.  Also
+      # see Nokogiri::XML::SAX::Document for the available events.
+      class Parser
+        class Attribute < Struct.new(:localname, :prefix, :uri, :value)
+        end
+
+        # Encodinds this parser supports
+        ENCODINGS = {
+          'NONE'        => 0, # No char encoding detected
+          'UTF-8'       => 1, # UTF-8
+          'UTF16LE'     => 2, # UTF-16 little endian
+          'UTF16BE'     => 3, # UTF-16 big endian
+          'UCS4LE'      => 4, # UCS-4 little endian
+          'UCS4BE'      => 5, # UCS-4 big endian
+          'EBCDIC'      => 6, # EBCDIC uh!
+          'UCS4-2143'   => 7, # UCS-4 unusual ordering
+          'UCS4-3412'   => 8, # UCS-4 unusual ordering
+          'UCS2'        => 9, # UCS-2
+          'ISO-8859-1'  => 10, # ISO-8859-1 ISO Latin 1
+          'ISO-8859-2'  => 11, # ISO-8859-2 ISO Latin 2
+          'ISO-8859-3'  => 12, # ISO-8859-3
+          'ISO-8859-4'  => 13, # ISO-8859-4
+          'ISO-8859-5'  => 14, # ISO-8859-5
+          'ISO-8859-6'  => 15, # ISO-8859-6
+          'ISO-8859-7'  => 16, # ISO-8859-7
+          'ISO-8859-8'  => 17, # ISO-8859-8
+          'ISO-8859-9'  => 18, # ISO-8859-9
+          'ISO-2022-JP' => 19, # ISO-2022-JP
+          'SHIFT-JIS'   => 20, # Shift_JIS
+          'EUC-JP'      => 21, # EUC-JP
+          'ASCII'       => 22, # pure ASCII
+        }
+
+        # The Nokogiri::XML::SAX::Document where events will be sent.
+        attr_accessor :document
+
+        # The encoding beings used for this document.
+        attr_accessor :encoding
+
+        # Create a new Parser with +doc+ and +encoding+
+        def initialize doc = Nokogiri::XML::SAX::Document.new, encoding = 'UTF-8'
+          @encoding = check_encoding(encoding)
+          @document = doc
+          @warned   = false
+        end
+
+        ###
+        # Parse given +thing+ which may be a string containing xml, or an
+        # IO object.
+        def parse thing, &block
+          if thing.respond_to?(:read) && thing.respond_to?(:close)
+            parse_io(thing, &block)
+          else
+            parse_memory(thing, &block)
+          end
+        end
+
+        ###
+        # Parse given +io+
+        def parse_io io, encoding = 'ASCII'
+          @encoding = check_encoding(encoding)
+          ctx = ParserContext.io(io, ENCODINGS[@encoding])
+          yield ctx if block_given?
+          ctx.parse_with self
+        end
+
+        ###
+        # Parse a file with +filename+
+        def parse_file filename
+          raise ArgumentError unless filename
+          raise Errno::ENOENT unless File.exist?(filename)
+          raise Errno::EISDIR if File.directory?(filename)
+          ctx = ParserContext.file filename
+          yield ctx if block_given?
+          ctx.parse_with self
+        end
+
+        def parse_memory data
+          ctx = ParserContext.memory data
+          yield ctx if block_given?
+          ctx.parse_with self
+        end
+
+        private
+        def check_encoding(encoding)
+          encoding.upcase.tap do |enc|
+            raise ArgumentError.new("'#{enc}' is not a valid encoding") unless ENCODINGS[enc]
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+module Nokogiri
+  module XML
+    module SAX
+      ###
+      # Context for XML SAX parsers.  This class is usually not instantiated
+      # by the user.  Instead, you should be looking at
+      # Nokogiri::XML::SAX::Parser
+      class ParserContext
+        def self.new thing, encoding = 'UTF-8'
+          [:read, :close].all? { |x| thing.respond_to?(x) } ?
+            io(thing, Parser::ENCODINGS[encoding]) : memory(thing)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+module Nokogiri
+  module XML
+    module SAX
+      ###
+      # Context for XML SAX parsers.  This class is usually not instantiated
+      # by the user.  Instead, you should be looking at
+      # Nokogiri::XML::SAX::Parser
+      class ParserContext
+        def self.new thing, encoding = 'UTF-8'
+          [:read, :close].all? { |x| thing.respond_to?(x) } ?
+            io(thing, Parser::ENCODINGS[encoding]) : memory(thing)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,60 @@
+module Nokogiri
+  module XML
+    module SAX
+      ###
+      # PushParser can parse a document that is fed to it manually.  It
+      # must be given a SAX::Document object which will be called with
+      # SAX events as the document is being parsed.
+      #
+      # Calling PushParser#<< writes XML to the parser, calling any SAX
+      # callbacks it can.
+      #
+      # PushParser#finish tells the parser that the document is finished
+      # and calls the end_document SAX method.
+      #
+      # Example:
+      #
+      #   parser = PushParser.new(Class.new(XML::SAX::Document) {
+      #     def start_document
+      #       puts "start document called"
+      #     end
+      #   }.new)
+      #   parser << "<div>hello<"
+      #   parser << "/div>"
+      #   parser.finish
+      class PushParser
+
+        # The Nokogiri::XML::SAX::Document on which the PushParser will be
+        # operating
+        attr_accessor :document
+
+        ###
+        # Create a new PushParser with +doc+ as the SAX Document, providing
+        # an optional +file_name+ and +encoding+
+        def initialize(doc = XML::SAX::Document.new, file_name = nil, encoding = 'UTF-8')
+          @document = doc
+          @encoding = encoding
+          @sax_parser = XML::SAX::Parser.new(doc)
+
+          ## Create our push parser context
+          initialize_native(@sax_parser, file_name)
+        end
+
+        ###
+        # Write a +chunk+ of XML to the PushParser.  Any callback methods
+        # that can be called will be called immediately.
+        def write chunk, last_chunk = false
+          native_write(chunk, last_chunk)
+        end
+        alias :<< :write
+
+        ###
+        # Finish the parsing.  This method is only necessary for
+        # Nokogiri::XML::SAX::Document#end_document to be called.
+        def finish
+          write '', true
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,60 @@
+module Nokogiri
+  module XML
+    module SAX
+      ###
+      # PushParser can parse a document that is fed to it manually.  It
+      # must be given a SAX::Document object which will be called with
+      # SAX events as the document is being parsed.
+      #
+      # Calling PushParser#<< writes XML to the parser, calling any SAX
+      # callbacks it can.
+      #
+      # PushParser#finish tells the parser that the document is finished
+      # and calls the end_document SAX method.
+      #
+      # Example:
+      #
+      #   parser = PushParser.new(Class.new(XML::SAX::Document) {
+      #     def start_document
+      #       puts "start document called"
+      #     end
+      #   }.new)
+      #   parser << "<div>hello<"
+      #   parser << "/div>"
+      #   parser.finish
+      class PushParser
+
+        # The Nokogiri::XML::SAX::Document on which the PushParser will be
+        # operating
+        attr_accessor :document
+
+        ###
+        # Create a new PushParser with +doc+ as the SAX Document, providing
+        # an optional +file_name+ and +encoding+
+        def initialize(doc = XML::SAX::Document.new, file_name = nil, encoding = 'UTF-8')
+          @document = doc
+          @encoding = encoding
+          @sax_parser = XML::SAX::Parser.new(doc)
+
+          ## Create our push parser context
+          initialize_native(@sax_parser, file_name)
+        end
+
+        ###
+        # Write a +chunk+ of XML to the PushParser.  Any callback methods
+        # that can be called will be called immediately.
+        def write chunk, last_chunk = false
+          native_write(chunk, last_chunk)
+        end
+        alias :<< :write
+
+        ###
+        # Finish the parsing.  This method is only necessary for
+        # Nokogiri::XML::SAX::Document#end_document to be called.
+        def finish
+          write '', true
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,63 @@
+module Nokogiri
+  module XML
+    class << self
+      ###
+      # Create a new Nokogiri::XML::Schema object using a +string_or_io+
+      # object.
+      def Schema string_or_io
+        Schema.new(string_or_io)
+      end
+    end
+
+    ###
+    # Nokogiri::XML::Schema is used for validating XML against a schema
+    # (usually from an xsd file).
+    #
+    # == Synopsis
+    #
+    # Validate an XML document against a Schema.  Loop over the errors that
+    # are returned and print them out:
+    #
+    #   xsd = Nokogiri::XML::Schema(File.read(PO_SCHEMA_FILE))
+    #   doc = Nokogiri::XML(File.read(PO_XML_FILE))
+    #
+    #   xsd.validate(doc).each do |error|
+    #     puts error.message
+    #   end
+    #
+    # The list of errors are Nokogiri::XML::SyntaxError objects.
+    class Schema
+      # Errors while parsing the schema file
+      attr_accessor :errors
+
+      ###
+      # Create a new Nokogiri::XML::Schema object using a +string_or_io+
+      # object.
+      def self.new string_or_io
+        from_document Nokogiri::XML(string_or_io)
+      end
+
+      ###
+      # Validate +thing+ against this schema.  +thing+ can be a
+      # Nokogiri::XML::Document object, or a filename.  An Array of
+      # Nokogiri::XML::SyntaxError objects found while validating the
+      # +thing+ is returned.
+      def validate thing
+        if thing.is_a?(Nokogiri::XML::Document) 
+          validate_document(thing) 
+        elsif File.file?(thing)
+          validate_file(thing)
+        else
+          raise ArgumentError, "Must provide Nokogiri::Xml::Document or the name of an existing file"
+        end
+      end
+
+      ###
+      # Returns true if +thing+ is a valid Nokogiri::XML::Document or
+      # file.
+      def valid? thing
+        validate(thing).length == 0
+      end
+    end
+  end
+end

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

@@ -0,0 +1,63 @@
+module Nokogiri
+  module XML
+    class << self
+      ###
+      # Create a new Nokogiri::XML::Schema object using a +string_or_io+
+      # object.
+      def Schema string_or_io
+        Schema.new(string_or_io)
+      end
+    end
+
+    ###
+    # Nokogiri::XML::Schema is used for validating XML against a schema
+    # (usually from an xsd file).
+    #
+    # == Synopsis
+    #
+    # Validate an XML document against a Schema.  Loop over the errors that
+    # are returned and print them out:
+    #
+    #   xsd = Nokogiri::XML::Schema(File.read(PO_SCHEMA_FILE))
+    #   doc = Nokogiri::XML(File.read(PO_XML_FILE))
+    #
+    #   xsd.validate(doc).each do |error|
+    #     puts error.message
+    #   end
+    #
+    # The list of errors are Nokogiri::XML::SyntaxError objects.
+    class Schema
+      # Errors while parsing the schema file
+      attr_accessor :errors
+
+      ###
+      # Create a new Nokogiri::XML::Schema object using a +string_or_io+
+      # object.
+      def self.new string_or_io
+        from_document Nokogiri::XML(string_or_io)
+      end
+
+      ###
+      # Validate +thing+ against this schema.  +thing+ can be a
+      # Nokogiri::XML::Document object, or a filename.  An Array of
+      # Nokogiri::XML::SyntaxError objects found while validating the
+      # +thing+ is returned.
+      def validate thing
+        if thing.is_a?(Nokogiri::XML::Document) 
+          validate_document(thing) 
+        elsif File.file?(thing)
+          validate_file(thing)
+        else
+          raise ArgumentError, "Must provide Nokogiri::Xml::Document or the name of an existing file"
+        end
+      end
+
+      ###
+      # Returns true if +thing+ is a valid Nokogiri::XML::Document or
+      # file.
+      def valid? thing
+        validate(thing).length == 0
+      end
+    end
+  end
+end

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

@@ -0,0 +1,230 @@
+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