video_chat_get 0.1.3 → 0.2.0

data/vendor/bundle/ruby/2.5.0/gems/rspec-support-3.9.3/lib/rspec/support/ruby_features.rb

@@ -1,190 +0,0 @@
-require 'rbconfig'
-RSpec::Support.require_rspec_support "comparable_version"
-
-module RSpec
-  module Support
-    # @api private
-    #
-    # Provides query methods for different OS or OS features.
-    module OS
-      module_function
-
-      def windows?
-        !!(RbConfig::CONFIG['host_os'] =~ /cygwin|mswin|mingw|bccwin|wince|emx/)
-      end
-
-      def windows_file_path?
-        ::File::ALT_SEPARATOR == '\\'
-      end
-    end
-
-    # @api private
-    #
-    # Provides query methods for different rubies
-    module Ruby
-      module_function
-
-      def jruby?
-        RUBY_PLATFORM == 'java'
-      end
-
-      def jruby_version
-        @jruby_version ||= ComparableVersion.new(JRUBY_VERSION)
-      end
-
-      def jruby_9000?
-        jruby? && JRUBY_VERSION >= '9.0.0.0'
-      end
-
-      def rbx?
-        defined?(RUBY_ENGINE) && RUBY_ENGINE == 'rbx'
-      end
-
-      def non_mri?
-        !mri?
-      end
-
-      def mri?
-        !defined?(RUBY_ENGINE) || RUBY_ENGINE == 'ruby'
-      end
-
-      def truffleruby?
-        defined?(RUBY_ENGINE) && RUBY_ENGINE == 'truffleruby'
-      end
-    end
-
-    # @api private
-    #
-    # Provides query methods for ruby features that differ among
-    # implementations.
-    module RubyFeatures
-      module_function
-
-      if Ruby.jruby?
-        # On JRuby 1.7 `--1.8` mode, `Process.respond_to?(:fork)` returns true,
-        # but when you try to fork, it raises an error:
-        #   NotImplementedError: fork is not available on this platform
-        #
-        # When we drop support for JRuby 1.7 and/or Ruby 1.8, we can drop
-        # this special case.
-        def fork_supported?
-          false
-        end
-      else
-        def fork_supported?
-          Process.respond_to?(:fork)
-        end
-      end
-
-      def optional_and_splat_args_supported?
-        Method.method_defined?(:parameters)
-      end
-
-      def caller_locations_supported?
-        respond_to?(:caller_locations, true)
-      end
-
-      if Exception.method_defined?(:cause)
-        def supports_exception_cause?
-          true
-        end
-      else
-        def supports_exception_cause?
-          false
-        end
-      end
-
-      if RUBY_VERSION.to_f >= 2.7
-        def supports_taint?
-          false
-        end
-      else
-        def supports_taint?
-          true
-        end
-      end
-      ripper_requirements = [ComparableVersion.new(RUBY_VERSION) >= '1.9.2']
-
-      ripper_requirements.push(false) if Ruby.rbx? || Ruby.truffleruby?
-
-      if Ruby.jruby?
-        ripper_requirements.push(Ruby.jruby_version >= '1.7.5')
-        # Ripper on JRuby 9.0.0.0.rc1 - 9.1.8.0 reports wrong line number
-        # or cannot parse source including `:if`.
-        # Ripper on JRuby 9.x.x.x < 9.2.1.0 can't handle keyword arguments.
-        ripper_requirements.push(!Ruby.jruby_version.between?('9.0.0.0.rc1', '9.2.0.0'))
-      end
-
-      if ripper_requirements.all?
-        def ripper_supported?
-          true
-        end
-      else
-        def ripper_supported?
-          false
-        end
-      end
-
-      if Ruby.mri?
-        def kw_args_supported?
-          RUBY_VERSION >= '2.0.0'
-        end
-
-        def required_kw_args_supported?
-          RUBY_VERSION >= '2.1.0'
-        end
-
-        def supports_rebinding_module_methods?
-          RUBY_VERSION.to_i >= 2
-        end
-      else
-        # RBX / JRuby et al support is unknown for keyword arguments
-        begin
-          eval("o = Object.new; def o.m(a: 1); end;"\
-               " raise SyntaxError unless o.method(:m).parameters.include?([:key, :a])")
-
-          def kw_args_supported?
-            true
-          end
-        rescue SyntaxError
-          def kw_args_supported?
-            false
-          end
-        end
-
-        begin
-          eval("o = Object.new; def o.m(a: ); end;"\
-               "raise SyntaxError unless o.method(:m).parameters.include?([:keyreq, :a])")
-
-          def required_kw_args_supported?
-            true
-          end
-        rescue SyntaxError
-          def required_kw_args_supported?
-            false
-          end
-        end
-
-        begin
-          Module.new { def foo; end }.instance_method(:foo).bind(Object.new)
-
-          def supports_rebinding_module_methods?
-            true
-          end
-        rescue TypeError
-          def supports_rebinding_module_methods?
-            false
-          end
-        end
-      end
-
-      def module_refinement_supported?
-        Module.method_defined?(:refine) || Module.private_method_defined?(:refine)
-      end
-
-      def module_prepends_supported?
-        Module.method_defined?(:prepend) || Module.private_method_defined?(:prepend)
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.5.0/gems/rspec-support-3.9.3/lib/rspec/support/source.rb

@@ -1,75 +0,0 @@
-RSpec::Support.require_rspec_support 'encoded_string'
-RSpec::Support.require_rspec_support 'ruby_features'
-
-module RSpec
-  module Support
-    # @private
-    # Represents a Ruby source file and provides access to AST and tokens.
-    class Source
-      attr_reader :source, :path
-
-      def self.from_file(path)
-        source = File.read(path)
-        new(source, path)
-      end
-
-      if String.method_defined?(:encoding)
-        def initialize(source_string, path=nil)
-          @source = RSpec::Support::EncodedString.new(source_string, Encoding.default_external)
-          @path = path ? File.expand_path(path) : '(string)'
-        end
-      else # for 1.8.7
-        # :nocov:
-        def initialize(source_string, path=nil)
-          @source = RSpec::Support::EncodedString.new(source_string)
-          @path = path ? File.expand_path(path) : '(string)'
-        end
-        # :nocov:
-      end
-
-      def lines
-        @lines ||= source.split("\n")
-      end
-
-      def inspect
-        "#<#{self.class} #{path}>"
-      end
-
-      if RSpec::Support::RubyFeatures.ripper_supported?
-        RSpec::Support.require_rspec_support 'source/node'
-        RSpec::Support.require_rspec_support 'source/token'
-
-        def ast
-          @ast ||= begin
-            require 'ripper'
-            sexp = Ripper.sexp(source)
-            raise SyntaxError unless sexp
-            Node.new(sexp)
-          end
-        end
-
-        def tokens
-          @tokens ||= begin
-            require 'ripper'
-            tokens = Ripper.lex(source)
-            Token.tokens_from_ripper_tokens(tokens)
-          end
-        end
-
-        def nodes_by_line_number
-          @nodes_by_line_number ||= begin
-            nodes_by_line_number = ast.select(&:location).group_by { |node| node.location.line }
-            Hash.new { |hash, key| hash[key] = [] }.merge(nodes_by_line_number)
-          end
-        end
-
-        def tokens_by_line_number
-          @tokens_by_line_number ||= begin
-            nodes_by_line_number = tokens.group_by { |token| token.location.line }
-            Hash.new { |hash, key| hash[key] = [] }.merge(nodes_by_line_number)
-          end
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.5.0/gems/rspec-support-3.9.3/lib/rspec/support/source/location.rb

@@ -1,21 +0,0 @@
-module RSpec
-  module Support
-    class Source
-      # @private
-      # Represents a source location of node or token.
-      Location = Struct.new(:line, :column) do
-        include Comparable
-
-        def self.location?(array)
-          array.is_a?(Array) && array.size == 2 && array.all? { |e| e.is_a?(Integer) }
-        end
-
-        def <=>(other)
-          line_comparison = (line <=> other.line)
-          return line_comparison unless line_comparison == 0
-          column <=> other.column
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.5.0/gems/rspec-support-3.9.3/lib/rspec/support/source/node.rb

@@ -1,110 +0,0 @@
-RSpec::Support.require_rspec_support 'source/location'
-
-module RSpec
-  module Support
-    class Source
-      # @private
-      # A wrapper for Ripper AST node which is generated with `Ripper.sexp`.
-      class Node
-        include Enumerable
-
-        attr_reader :sexp, :parent
-
-        def self.sexp?(array)
-          array.is_a?(Array) && array.first.is_a?(Symbol)
-        end
-
-        def initialize(ripper_sexp, parent=nil)
-          @sexp = ripper_sexp.freeze
-          @parent = parent
-        end
-
-        def type
-          sexp[0]
-        end
-
-        def args
-          @args ||= raw_args.map do |raw_arg|
-            if Node.sexp?(raw_arg)
-              Node.new(raw_arg, self)
-            elsif Location.location?(raw_arg)
-              Location.new(*raw_arg)
-            elsif raw_arg.is_a?(Array)
-              ExpressionSequenceNode.new(raw_arg, self)
-            else
-              raw_arg
-            end
-          end.freeze
-        end
-
-        def children
-          @children ||= args.select { |arg| arg.is_a?(Node) }.freeze
-        end
-
-        def location
-          @location ||= args.find { |arg| arg.is_a?(Location) }
-        end
-
-        # We use a loop here (instead of recursion) to prevent SystemStackError
-        def each
-          return to_enum(__method__) unless block_given?
-
-          node_queue = []
-          node_queue << self
-
-          while (current_node = node_queue.shift)
-            yield current_node
-            node_queue.concat(current_node.children)
-          end
-        end
-
-        def each_ancestor
-          return to_enum(__method__) unless block_given?
-
-          current_node = self
-
-          while (current_node = current_node.parent)
-            yield current_node
-          end
-        end
-
-        def inspect
-          "#<#{self.class} #{type}>"
-        end
-
-      private
-
-        def raw_args
-          sexp[1..-1] || []
-        end
-      end
-
-      # @private
-      # Basically `Ripper.sexp` generates arrays whose first element is a symbol (type of sexp),
-      # but it exceptionally generates typeless arrays for expression sequence:
-      #
-      # Ripper.sexp('foo; bar')
-      # => [
-      #      :program,
-      #      [ # Typeless array
-      #        [:vcall, [:@ident, "foo", [1, 0]]],
-      #        [:vcall, [:@ident, "bar", [1, 5]]]
-      #      ]
-      #    ]
-      #
-      # We wrap typeless arrays in this pseudo type node
-      # so that it can be handled in the same way as other type node.
-      class ExpressionSequenceNode < Node
-        def type
-          :_expression_sequence
-        end
-
-      private
-
-        def raw_args
-          sexp
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.5.0/gems/rspec-support-3.9.3/lib/rspec/support/source/token.rb

@@ -1,87 +0,0 @@
-RSpec::Support.require_rspec_support 'source/location'
-
-module RSpec
-  module Support
-    class Source
-      # @private
-      # A wrapper for Ripper token which is generated with `Ripper.lex`.
-      class Token
-        CLOSING_TYPES_BY_OPENING_TYPE = {
-          :on_lbracket    => :on_rbracket,
-          :on_lparen      => :on_rparen,
-          :on_lbrace      => :on_rbrace,
-          :on_heredoc_beg => :on_heredoc_end
-        }.freeze
-
-        CLOSING_KEYWORDS_BY_OPENING_KEYWORD = {
-          'def' => 'end',
-          'do'  => 'end',
-        }.freeze
-
-        attr_reader :token
-
-        def self.tokens_from_ripper_tokens(ripper_tokens)
-          ripper_tokens.map { |ripper_token| new(ripper_token) }.freeze
-        end
-
-        def initialize(ripper_token)
-          @token = ripper_token.freeze
-        end
-
-        def location
-          @location ||= Location.new(*token[0])
-        end
-
-        def type
-          token[1]
-        end
-
-        def string
-          token[2]
-        end
-
-        def ==(other)
-          token == other.token
-        end
-
-        alias_method :eql?, :==
-
-        def inspect
-          "#<#{self.class} #{type} #{string.inspect}>"
-        end
-
-        def keyword?
-          type == :on_kw
-        end
-
-        def opening?
-          opening_delimiter? || opening_keyword?
-        end
-
-        def closed_by?(other)
-          closed_by_delimiter?(other) || closed_by_keyword?(other)
-        end
-
-      private
-
-        def opening_delimiter?
-          CLOSING_TYPES_BY_OPENING_TYPE.key?(type)
-        end
-
-        def opening_keyword?
-          return false unless keyword?
-          CLOSING_KEYWORDS_BY_OPENING_KEYWORD.key?(string)
-        end
-
-        def closed_by_delimiter?(other)
-          other.type == CLOSING_TYPES_BY_OPENING_TYPE[type]
-        end
-
-        def closed_by_keyword?(other)
-          return false unless other.keyword?
-          other.string == CLOSING_KEYWORDS_BY_OPENING_KEYWORD[string]
-        end
-      end
-    end
-  end
-end