video_chat_get 0.1.3 → 0.2.0

data/vendor/bundle/ruby/2.5.0/gems/rspec-core-3.9.2/lib/rspec/core/configuration_options.rb

@@ -1,233 +0,0 @@
-require 'erb'
-require 'shellwords'
-
-module RSpec
-  module Core
-    # Responsible for utilizing externally provided configuration options,
-    # whether via the command line, `.rspec`, `~/.rspec`,
-    # `$XDG_CONFIG_HOME/rspec/options`, `.rspec-local` or a custom options
-    # file.
-    class ConfigurationOptions
-      # @param args [Array<String>] command line arguments
-      def initialize(args)
-        @args = args.dup
-        organize_options
-      end
-
-      # Updates the provided {Configuration} instance based on the provided
-      # external configuration options.
-      #
-      # @param config [Configuration] the configuration instance to update
-      def configure(config)
-        process_options_into config
-        configure_filter_manager config.filter_manager
-        load_formatters_into config
-      end
-
-      # @api private
-      # Updates the provided {FilterManager} based on the filter options.
-      # @param filter_manager [FilterManager] instance to update
-      def configure_filter_manager(filter_manager)
-        @filter_manager_options.each do |command, value|
-          filter_manager.__send__ command, value
-        end
-      end
-
-      # @return [Hash] the final merged options, drawn from all external sources
-      attr_reader :options
-
-      # @return [Array<String>] the original command-line arguments
-      attr_reader :args
-
-    private
-
-      def organize_options
-        @filter_manager_options = []
-
-        @options = (file_options << command_line_options << env_options).each do |opts|
-          @filter_manager_options << [:include, opts.delete(:inclusion_filter)] if opts.key?(:inclusion_filter)
-          @filter_manager_options << [:exclude, opts.delete(:exclusion_filter)] if opts.key?(:exclusion_filter)
-        end
-
-        @options = @options.inject(:libs => [], :requires => []) do |hash, opts|
-          hash.merge(opts) do |key, oldval, newval|
-            [:libs, :requires].include?(key) ? oldval + newval : newval
-          end
-        end
-      end
-
-      UNFORCED_OPTIONS = Set.new([
-        :requires, :profile, :drb, :libs, :files_or_directories_to_run,
-        :full_description, :full_backtrace, :tty
-      ])
-
-      UNPROCESSABLE_OPTIONS = Set.new([:formatters])
-
-      def force?(key)
-        !UNFORCED_OPTIONS.include?(key)
-      end
-
-      def order(keys)
-        OPTIONS_ORDER.reverse_each do |key|
-          keys.unshift(key) if keys.delete(key)
-        end
-        keys
-      end
-
-      OPTIONS_ORDER = [
-        # It's important to set this before anything that might issue a
-        # deprecation (or otherwise access the reporter).
-        :deprecation_stream,
-
-        # load paths depend on nothing, but must be set before `requires`
-        # to support load-path-relative requires.
-        :libs,
-
-        # `files_or_directories_to_run` uses `default_path` so it must be
-        # set before it.
-        :default_path, :only_failures,
-
-        # These must be set before `requires` to support checking
-        # `config.files_to_run` from within `spec_helper.rb` when a
-        # `-rspec_helper` option is used.
-        :files_or_directories_to_run, :pattern, :exclude_pattern,
-
-        # Necessary so that the `--seed` option is applied before requires,
-        # in case required files do something with the provided seed.
-        # (such as seed global randomization with it).
-        :order,
-
-        # In general, we want to require the specified files as early as
-        # possible. The `--require` option is specifically intended to allow
-        # early requires. For later requires, they can just put the require in
-        # their spec files, but `--require` provides a unique opportunity for
-        # users to instruct RSpec to load an extension file early for maximum
-        # flexibility.
-        :requires
-      ]
-
-      def process_options_into(config)
-        opts = options.reject { |k, _| UNPROCESSABLE_OPTIONS.include? k }
-
-        order(opts.keys).each do |key|
-          force?(key) ? config.force(key => opts[key]) : config.__send__("#{key}=", opts[key])
-        end
-      end
-
-      def load_formatters_into(config)
-        options[:formatters].each { |pair| config.add_formatter(*pair) } if options[:formatters]
-      end
-
-      def file_options
-        if custom_options_file
-          [custom_options]
-        else
-          [global_options, project_options, local_options]
-        end
-      end
-
-      def env_options
-        return {} unless ENV['SPEC_OPTS']
-
-        parse_args_ignoring_files_or_dirs_to_run(
-          Shellwords.split(ENV["SPEC_OPTS"]),
-          "ENV['SPEC_OPTS']"
-        )
-      end
-
-      def command_line_options
-        @command_line_options ||= Parser.parse(@args)
-      end
-
-      def custom_options
-        options_from(custom_options_file)
-      end
-
-      def local_options
-        @local_options ||= options_from(local_options_file)
-      end
-
-      def project_options
-        @project_options ||= options_from(project_options_file)
-      end
-
-      def global_options
-        @global_options ||= options_from(global_options_file)
-      end
-
-      def options_from(path)
-        args = args_from_options_file(path)
-        parse_args_ignoring_files_or_dirs_to_run(args, path)
-      end
-
-      def parse_args_ignoring_files_or_dirs_to_run(args, source)
-        options = Parser.parse(args, source)
-        options.delete(:files_or_directories_to_run)
-        options
-      end
-
-      def args_from_options_file(path)
-        return [] unless path && File.exist?(path)
-        config_string = options_file_as_erb_string(path)
-        FlatMap.flat_map(config_string.split(/\n+/), &:shellsplit)
-      end
-
-      def options_file_as_erb_string(path)
-        if RUBY_VERSION >= '2.6'
-          ERB.new(File.read(path), :trim_mode => '-').result(binding)
-        else
-          ERB.new(File.read(path), nil, '-').result(binding)
-        end
-      end
-
-      def custom_options_file
-        command_line_options[:custom_options_file]
-      end
-
-      def project_options_file
-        "./.rspec"
-      end
-
-      def local_options_file
-        "./.rspec-local"
-      end
-
-      def global_options_file
-        xdg_options_file_if_exists || home_options_file_path
-      end
-
-      def xdg_options_file_if_exists
-        path = xdg_options_file_path
-        if path && File.exist?(path)
-          path
-        end
-      end
-
-      def home_options_file_path
-        File.join(File.expand_path("~"), ".rspec")
-      rescue ArgumentError
-        # :nocov:
-        RSpec.warning "Unable to find ~/.rspec because the HOME environment variable is not set"
-        nil
-        # :nocov:
-      end
-
-      def xdg_options_file_path
-        xdg_config_home = resolve_xdg_config_home
-        if xdg_config_home
-          File.join(xdg_config_home, "rspec", "options")
-        end
-      end
-
-      def resolve_xdg_config_home
-        File.expand_path(ENV.fetch("XDG_CONFIG_HOME", "~/.config"))
-      rescue ArgumentError
-        # :nocov:
-        # On Ruby 2.4, `File.expand("~")` works even if `ENV['HOME']` is not set.
-        # But on earlier versions, it fails.
-        nil
-        # :nocov:
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.5.0/gems/rspec-core-3.9.2/lib/rspec/core/did_you_mean.rb

@@ -1,46 +0,0 @@
-module RSpec
-  module Core
-    # @private
-    # Wrapper around Ruby's `DidYouMean::SpellChecker` when available to provide file name suggestions.
-    class DidYouMean
-      attr_reader :relative_file_name
-
-      def initialize(relative_file_name)
-        @relative_file_name = relative_file_name
-      end
-
-      if defined?(::DidYouMean::SpellChecker)
-        # provide probable suggestions
-        def call
-          checker = ::DidYouMean::SpellChecker.new(:dictionary => Dir["spec/**/*.rb"])
-          probables = checker.correct(relative_file_name.sub('./', ''))[0..2]
-          return '' unless probables.any?
-
-          formats probables
-        end
-      else
-        # return a hint if API for ::DidYouMean::SpellChecker not supported
-        def call
-          "\nHint: Install the `did_you_mean` gem in order to provide suggestions for similarly named files."
-        end
-      end
-
-      private
-
-      def formats(probables)
-        rspec_format = probables.map { |s, _| "rspec ./#{s}" }
-        red_font(top_and_tail rspec_format)
-      end
-
-      def top_and_tail(rspec_format)
-        spaces = ' ' * 20
-        rspec_format.insert(0, ' - Did you mean?').join("\n#{spaces}") + "\n"
-      end
-
-      def red_font(mytext)
-        colorizer = ::RSpec::Core::Formatters::ConsoleCodes
-        colorizer.wrap mytext, :failure
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.5.0/gems/rspec-core-3.9.2/lib/rspec/core/drb.rb

@@ -1,113 +0,0 @@
-require 'drb/drb'
-
-module RSpec
-  module Core
-    # @private
-    class DRbRunner
-      def initialize(options, configuration=RSpec.configuration)
-        @options       = options
-        @configuration = configuration
-      end
-
-      def drb_port
-        @options.options[:drb_port] || ENV['RSPEC_DRB'] || 8989
-      end
-
-      def run(err, out)
-        begin
-          DRb.start_service("druby://localhost:0")
-        rescue SocketError, Errno::EADDRNOTAVAIL
-          DRb.start_service("druby://:0")
-        end
-        spec_server = DRbObject.new_with_uri("druby://127.0.0.1:#{drb_port}")
-        spec_server.run(drb_argv, err, out)
-      end
-
-      def drb_argv
-        @drb_argv ||= begin
-          @options.configure_filter_manager(@configuration.filter_manager)
-          DRbOptions.new(@options.options, @configuration.filter_manager).options
-        end
-      end
-    end
-
-    # @private
-    class DRbOptions
-      def initialize(submitted_options, filter_manager)
-        @submitted_options = submitted_options
-        @filter_manager = filter_manager
-      end
-
-      def options
-        argv = []
-        argv << "--color"        if @submitted_options[:color]
-        argv << "--force-color"  if @submitted_options[:color_mode] == :on
-        argv << "--no-color"     if @submitted_options[:color_mode] == :off
-        argv << "--profile"      if @submitted_options[:profile_examples]
-        argv << "--backtrace"    if @submitted_options[:full_backtrace]
-        argv << "--tty"          if @submitted_options[:tty]
-        argv << "--fail-fast"    if @submitted_options[:fail_fast]
-        argv << "--options"      << @submitted_options[:custom_options_file] if @submitted_options[:custom_options_file]
-        argv << "--order"        << @submitted_options[:order]               if @submitted_options[:order]
-
-        add_failure_exit_code(argv)
-        add_full_description(argv)
-        add_filter(argv, :inclusion, @filter_manager.inclusions)
-        add_filter(argv, :exclusion, @filter_manager.exclusions)
-        add_formatters(argv)
-        add_libs(argv)
-        add_requires(argv)
-
-        argv + @submitted_options[:files_or_directories_to_run]
-      end
-
-      def add_failure_exit_code(argv)
-        return unless @submitted_options[:failure_exit_code]
-
-        argv << "--failure-exit-code" << @submitted_options[:failure_exit_code].to_s
-      end
-
-      def add_full_description(argv)
-        return unless @submitted_options[:full_description]
-
-        # The argument to --example is regexp-escaped before being stuffed
-        # into a regexp when received for the first time (see OptionParser).
-        # Hence, merely grabbing the source of this regexp will retain the
-        # backslashes, so we must remove them.
-        @submitted_options[:full_description].each do |description|
-          argv << "--example" << description.source.delete('\\')
-        end
-      end
-
-      CONDITIONAL_FILTERS = [:if, :unless]
-
-      def add_filter(argv, name, hash)
-        hash.each_pair do |k, v|
-          next if CONDITIONAL_FILTERS.include?(k)
-          tag = name == :inclusion ? k.to_s : "~#{k}".dup
-          tag << ":#{v}" if v.is_a?(String)
-          argv << "--tag" << tag
-        end unless hash.empty?
-      end
-
-      def add_formatters(argv)
-        @submitted_options[:formatters].each do |pair|
-          argv << "--format" << pair[0]
-          argv << "--out" << pair[1] if pair[1]
-        end if @submitted_options[:formatters]
-      end
-
-      def add_libs(argv)
-        @submitted_options[:libs].each do |path|
-          argv << "-I" << path
-        end if @submitted_options[:libs]
-      end
-
-      def add_requires(argv)
-        @submitted_options[:requires].each do |path|
-          argv << "--require" << path
-        end if @submitted_options[:requires]
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.5.0/gems/rspec-core-3.9.2/lib/rspec/core/dsl.rb

@@ -1,98 +0,0 @@
-module RSpec
-  module Core
-    # DSL defines methods to group examples, most notably `describe`,
-    # and exposes them as class methods of {RSpec}. They can also be
-    # exposed globally (on `main` and instances of `Module`) through
-    # the {Configuration} option `expose_dsl_globally`.
-    #
-    # By default the methods `describe`, `context` and `example_group`
-    # are exposed. These methods define a named context for one or
-    # more examples. The given block is evaluated in the context of
-    # a generated subclass of {RSpec::Core::ExampleGroup}.
-    #
-    # ## Examples:
-    #
-    #     RSpec.describe "something" do
-    #       context "when something is a certain way" do
-    #         it "does something" do
-    #           # example code goes here
-    #         end
-    #       end
-    #     end
-    #
-    # @see ExampleGroup
-    # @see ExampleGroup.example_group
-    module DSL
-      # @private
-      def self.example_group_aliases
-        @example_group_aliases ||= []
-      end
-
-      # @private
-      def self.exposed_globally?
-        @exposed_globally ||= false
-      end
-
-      # @private
-      def self.expose_example_group_alias(name)
-        return if example_group_aliases.include?(name)
-
-        example_group_aliases << name
-
-        (class << RSpec; self; end).__send__(:define_method, name) do |*args, &example_group_block|
-          group = RSpec::Core::ExampleGroup.__send__(name, *args, &example_group_block)
-          RSpec.world.record(group)
-          group
-        end
-
-        expose_example_group_alias_globally(name) if exposed_globally?
-      end
-
-      class << self
-        # @private
-        attr_accessor :top_level
-      end
-
-      # Adds the describe method to Module and the top level binding.
-      # @api private
-      def self.expose_globally!
-        return if exposed_globally?
-
-        example_group_aliases.each do |method_name|
-          expose_example_group_alias_globally(method_name)
-        end
-
-        @exposed_globally = true
-      end
-
-      # Removes the describe method from Module and the top level binding.
-      # @api private
-      def self.remove_globally!
-        return unless exposed_globally?
-
-        example_group_aliases.each do |method_name|
-          change_global_dsl { undef_method method_name }
-        end
-
-        @exposed_globally = false
-      end
-
-      # @private
-      def self.expose_example_group_alias_globally(method_name)
-        change_global_dsl do
-          remove_method(method_name) if method_defined?(method_name)
-          define_method(method_name) { |*a, &b| ::RSpec.__send__(method_name, *a, &b) }
-        end
-      end
-
-      # @private
-      def self.change_global_dsl(&changes)
-        (class << top_level; self; end).class_exec(&changes)
-        Module.class_exec(&changes)
-      end
-    end
-  end
-end
-
-# Capture main without an eval.
-::RSpec::Core::DSL.top_level = self