scoot 0.0.4 → 0.0.6

data/.bundle/gems/ruby/2.2.0/gems/rspec-core-3.3.2/lib/rspec/core/backtrace_formatter.rb

@@ -1,64 +0,0 @@
-module RSpec
-  module Core
-    # @private
-    class BacktraceFormatter
-      # @private
-      attr_accessor :exclusion_patterns, :inclusion_patterns
-
-      def initialize
-        @full_backtrace = false
-
-        patterns = %w[ /lib\d*/ruby/ bin/ exe/rspec ]
-        patterns << "org/jruby/" if RUBY_PLATFORM == 'java'
-        patterns.map! { |s| Regexp.new(s.gsub("/", File::SEPARATOR)) }
-
-        @exclusion_patterns = [Regexp.union(RSpec::CallerFilter::IGNORE_REGEX, *patterns)]
-        @inclusion_patterns = []
-
-        return unless matches?(@exclusion_patterns, File.join(Dir.getwd, "lib", "foo.rb:13"))
-        inclusion_patterns << Regexp.new(Dir.getwd)
-      end
-
-      attr_writer :full_backtrace
-
-      def full_backtrace?
-        @full_backtrace || exclusion_patterns.empty?
-      end
-
-      def filter_gem(gem_name)
-        sep = File::SEPARATOR
-        exclusion_patterns << /#{sep}#{gem_name}(-[^#{sep}]+)?#{sep}/
-      end
-
-      def format_backtrace(backtrace, options={})
-        return backtrace if options[:full_backtrace] || backtrace.empty?
-
-        backtrace.map { |l| backtrace_line(l) }.compact.
-          tap do |filtered|
-            if filtered.empty?
-              filtered.concat backtrace
-              filtered << ""
-              filtered << "  Showing full backtrace because every line was filtered out."
-              filtered << "  See docs for RSpec::Configuration#backtrace_exclusion_patterns and"
-              filtered << "  RSpec::Configuration#backtrace_inclusion_patterns for more information."
-            end
-          end
-      end
-
-      def backtrace_line(line)
-        Metadata.relative_path(line) unless exclude?(line)
-      end
-
-      def exclude?(line)
-        return false if @full_backtrace
-        matches?(exclusion_patterns, line) && !matches?(inclusion_patterns, line)
-      end
-
-    private
-
-      def matches?(patterns, line)
-        patterns.any? { |p| line =~ p }
-      end
-    end
-  end
-end

data/.bundle/gems/ruby/2.2.0/gems/rspec-core-3.3.2/lib/rspec/core/bisect/coordinator.rb

@@ -1,66 +0,0 @@
-RSpec::Support.require_rspec_core "bisect/server"
-RSpec::Support.require_rspec_core "bisect/runner"
-RSpec::Support.require_rspec_core "bisect/example_minimizer"
-RSpec::Support.require_rspec_core "formatters/bisect_progress_formatter"
-
-module RSpec
-  module Core
-    module Bisect
-      # @private
-      # The main entry point into the bisect logic. Coordinates among:
-      #   - Bisect::Server: Receives suite results.
-      #   - Bisect::Runner: Runs a set of examples and directs the results
-      #     to the server.
-      #   - Bisect::ExampleMinimizer: Contains the core bisect logic.
-      #   - Formatters::BisectProgressFormatter: provides progress updates
-      #     to the user.
-      class Coordinator
-        def self.bisect_with(original_cli_args, configuration, formatter)
-          new(original_cli_args, configuration, formatter).bisect
-        end
-
-        def initialize(original_cli_args, configuration, formatter)
-          @original_cli_args = original_cli_args
-          @configuration     = configuration
-          @formatter         = formatter
-        end
-
-        def bisect
-          @configuration.add_formatter @formatter
-
-          reporter.close_after do
-            repro = Server.run do |server|
-              runner    = Runner.new(server, @original_cli_args)
-              minimizer = ExampleMinimizer.new(runner, reporter)
-
-              gracefully_abort_on_sigint(minimizer)
-              minimizer.find_minimal_repro
-              minimizer.repro_command_for_currently_needed_ids
-            end
-
-            reporter.publish(:bisect_repro_command, :repro => repro)
-          end
-
-          true
-        rescue BisectFailedError => e
-          reporter.publish(:bisect_failed, :failure_explanation => e.message)
-          false
-        end
-
-      private
-
-        def reporter
-          @configuration.reporter
-        end
-
-        def gracefully_abort_on_sigint(minimizer)
-          trap('INT') do
-            repro = minimizer.repro_command_for_currently_needed_ids
-            reporter.publish(:bisect_aborted, :repro => repro)
-            exit(1)
-          end
-        end
-      end
-    end
-  end
-end

data/.bundle/gems/ruby/2.2.0/gems/rspec-core-3.3.2/lib/rspec/core/bisect/example_minimizer.rb

@@ -1,130 +0,0 @@
-RSpec::Support.require_rspec_core "bisect/subset_enumerator"
-
-module RSpec
-  module Core
-    module Bisect
-      # @private
-      # Contains the core bisect logic. Searches for examples we can ignore by
-      # repeatedly running different subsets of the suite.
-      class ExampleMinimizer
-        attr_reader :runner, :reporter, :all_example_ids, :failed_example_ids
-        attr_accessor :remaining_ids
-
-        def initialize(runner, reporter)
-          @runner   = runner
-          @reporter = reporter
-        end
-
-        def find_minimal_repro
-          prep
-
-          self.remaining_ids = non_failing_example_ids
-
-          each_bisect_round do |subsets|
-            ids_to_ignore = subsets.find do |ids|
-              get_expected_failures_for?(remaining_ids - ids)
-            end
-
-            next :done unless ids_to_ignore
-
-            self.remaining_ids -= ids_to_ignore
-            notify(:bisect_ignoring_ids, :ids_to_ignore => ids_to_ignore, :remaining_ids => remaining_ids)
-          end
-
-          currently_needed_ids
-        end
-
-        def currently_needed_ids
-          remaining_ids + failed_example_ids
-        end
-
-        def repro_command_for_currently_needed_ids
-          return runner.repro_command_from(currently_needed_ids) if remaining_ids
-          "(Not yet enough information to provide any repro command)"
-        end
-
-      private
-
-        def prep
-          notify(:bisect_starting, :original_cli_args => runner.original_cli_args)
-
-          _, duration = track_duration do
-            original_results    = runner.original_results
-            @all_example_ids    = original_results.all_example_ids
-            @failed_example_ids = original_results.failed_example_ids
-          end
-
-          if @failed_example_ids.empty?
-            raise BisectFailedError, "\n\nNo failures found. Bisect only works " \
-                  "in the presence of one or more failing examples."
-          else
-            notify(:bisect_original_run_complete, :failed_example_ids => failed_example_ids,
-                                                  :non_failing_example_ids => non_failing_example_ids,
-                                                  :duration => duration)
-          end
-        end
-
-        def non_failing_example_ids
-          @non_failing_example_ids ||= all_example_ids - failed_example_ids
-        end
-
-        def get_expected_failures_for?(ids)
-          ids_to_run = ids + failed_example_ids
-          notify(:bisect_individual_run_start, :command => runner.repro_command_from(ids_to_run))
-
-          results, duration = track_duration { runner.run(ids_to_run) }
-          notify(:bisect_individual_run_complete, :duration => duration, :results => results)
-
-          abort_if_ordering_inconsistent(results)
-          (failed_example_ids & results.failed_example_ids) == failed_example_ids
-        end
-
-        INFINITY = (1.0 / 0) # 1.8.7 doesn't define Float::INFINITY so we define our own...
-
-        def each_bisect_round(&block)
-          last_round, duration = track_duration do
-            1.upto(INFINITY) do |round|
-              break if :done == bisect_round(round, &block)
-            end
-          end
-
-          notify(:bisect_complete, :round => last_round, :duration => duration,
-                                   :original_non_failing_count => non_failing_example_ids.size,
-                                   :remaining_count => remaining_ids.size)
-        end
-
-        def bisect_round(round)
-          value, duration = track_duration do
-            subsets = SubsetEnumerator.new(remaining_ids)
-            notify(:bisect_round_started, :round => round,
-                                          :subset_size => subsets.subset_size,
-                                          :remaining_count => remaining_ids.size)
-
-            yield subsets
-          end
-
-          notify(:bisect_round_finished, :duration => duration, :round => round)
-          value
-        end
-
-        def track_duration
-          start = ::RSpec::Core::Time.now
-          [yield, ::RSpec::Core::Time.now - start]
-        end
-
-        def abort_if_ordering_inconsistent(results)
-          expected_order = all_example_ids & results.all_example_ids
-          return if expected_order == results.all_example_ids
-
-          raise BisectFailedError, "\n\nThe example ordering is inconsistent. " \
-                "`--bisect` relies upon consistent ordering (e.g. by passing " \
-                "`--seed` if you're using random ordering) to work properly."
-        end
-
-        def notify(*args)
-          reporter.publish(*args)
-        end
-      end
-    end
-  end
-end

data/.bundle/gems/ruby/2.2.0/gems/rspec-core-3.3.2/lib/rspec/core/bisect/runner.rb

@@ -1,139 +0,0 @@
-RSpec::Support.require_rspec_core "shell_escape"
-require 'open3'
-
-module RSpec
-  module Core
-    module Bisect
-      # Provides an API to run the suite for a set of locations, using
-      # the given bisect server to capture the results.
-      # @private
-      class Runner
-        attr_reader :original_cli_args
-
-        def initialize(server, original_cli_args)
-          @server            = server
-          @original_cli_args = original_cli_args.reject { |arg| arg.start_with?("--bisect") }
-        end
-
-        def run(locations)
-          run_locations(locations, original_results.failed_example_ids)
-        end
-
-        def command_for(locations)
-          parts = []
-
-          parts << RUBY << load_path
-          parts << open3_safe_escape(RSpec::Core.path_to_executable)
-
-          parts << "--format"   << "bisect"
-          parts << "--drb-port" << @server.drb_port
-          parts.concat reusable_cli_options
-          parts.concat locations.map { |l| open3_safe_escape(l) }
-
-          parts.join(" ")
-        end
-
-        def repro_command_from(locations)
-          parts = []
-
-          parts << "rspec"
-          parts.concat Formatters::Helpers.organize_ids(locations)
-          parts.concat original_cli_args_without_locations
-
-          parts.join(" ")
-        end
-
-        def original_results
-          @original_results ||= run_locations(original_locations)
-        end
-
-      private
-
-        include RSpec::Core::ShellEscape
-        # On JRuby, Open3.popen3 does not handle shellescaped args properly:
-        # https://github.com/jruby/jruby/issues/2767
-        if RSpec::Support::Ruby.jruby?
-          # :nocov:
-          alias open3_safe_escape quote
-          # :nocov:
-        else
-          alias open3_safe_escape escape
-        end
-
-        def run_locations(locations, *capture_args)
-          @server.capture_run_results(*capture_args) do
-            run_command command_for(locations)
-          end
-        end
-
-        # `Open3.capture2e` does not work on JRuby:
-        # https://github.com/jruby/jruby/issues/2766
-        if Open3.respond_to?(:capture2e) && !RSpec::Support::Ruby.jruby?
-          def run_command(cmd)
-            Open3.capture2e(cmd).first
-          end
-        else # for 1.8.7
-          # :nocov:
-          def run_command(cmd)
-            out = err = nil
-
-            Open3.popen3(cmd) do |_, stdout, stderr|
-              # Reading the streams blocks until the process is complete
-              out = stdout.read
-              err = stderr.read
-            end
-
-            "Stdout:\n#{out}\n\nStderr:\n#{err}"
-          end
-          # :nocov:
-        end
-
-        def reusable_cli_options
-          @reusable_cli_options ||= begin
-            opts = original_cli_args_without_locations
-
-            if (port = parsed_original_cli_options[:drb_port])
-              opts -= %W[ --drb-port #{port} ]
-            end
-
-            parsed_original_cli_options.fetch(:formatters) { [] }.each do |(name, out)|
-              opts -= %W[ --format #{name} -f -f#{name} ]
-              opts -= %W[ --out #{out} -o -o#{out} ]
-            end
-
-            opts
-          end
-        end
-
-        def original_cli_args_without_locations
-          @original_cli_args_without_locations ||= begin
-            files_or_dirs = parsed_original_cli_options.fetch(:files_or_directories_to_run)
-            @original_cli_args - files_or_dirs
-          end
-        end
-
-        def parsed_original_cli_options
-          @parsed_original_cli_options ||= Parser.parse(@original_cli_args)
-        end
-
-        def original_locations
-          parsed_original_cli_options.fetch(:files_or_directories_to_run)
-        end
-
-        def load_path
-          @load_path ||= "-I#{$LOAD_PATH.map { |p| open3_safe_escape(p) }.join(':')}"
-        end
-
-        # Path to the currently running Ruby executable, borrowed from Rake:
-        # https://github.com/ruby/rake/blob/v10.4.2/lib/rake/file_utils.rb#L8-L12
-        # Note that we skip `ENV['RUBY']` because we don't have to deal with running
-        # RSpec from within a MRI source repository:
-        # https://github.com/ruby/rake/commit/968682759b3b65e42748cd2befb2ff3e982272d9
-        RUBY = File.join(
-          RbConfig::CONFIG['bindir'],
-          RbConfig::CONFIG['ruby_install_name'] + RbConfig::CONFIG['EXEEXT']).
-          sub(/.*\s.*/m, '"\&"')
-      end
-    end
-  end
-end

data/.bundle/gems/ruby/2.2.0/gems/rspec-core-3.3.2/lib/rspec/core/bisect/server.rb

@@ -1,61 +0,0 @@
-require 'drb/drb'
-require 'drb/acl'
-
-module RSpec
-  module Core
-    # @private
-    module Bisect
-      # @private
-      BisectFailedError = Class.new(StandardError)
-
-      # @private
-      # A DRb server that receives run results from a separate RSpec process
-      # started by the bisect process.
-      class Server
-        def self.run
-          server = new
-          server.start
-          yield server
-        ensure
-          server.stop
-        end
-
-        def capture_run_results(expected_failures=[])
-          self.expected_failures  = expected_failures
-          self.latest_run_results = nil
-          run_output = yield
-          latest_run_results || raise_bisect_failed(run_output)
-        end
-
-        def start
-          # Only allow remote DRb requests from this machine.
-          DRb.install_acl ACL.new(%w[ deny all allow localhost allow 127.0.0.1 ])
-
-          # We pass `nil` as the first arg to allow it to pick a DRb port.
-          @drb = DRb.start_service(nil, self)
-        end
-
-        def stop
-          @drb.stop_service
-        end
-
-        def drb_port
-          @drb_port ||= Integer(@drb.uri[/\d+$/])
-        end
-
-        # Fetched via DRb by the BisectFormatter to determine when to abort.
-        attr_accessor :expected_failures
-
-        # Set via DRb by the BisectFormatter with the results of the run.
-        attr_accessor :latest_run_results
-
-      private
-
-        def raise_bisect_failed(run_output)
-          raise BisectFailedError, "Failed to get results from the spec " \
-                "run. Spec run output:\n\n#{run_output}"
-        end
-      end
-    end
-  end
-end