bibtex_to_scrapbox 0.1.0

data/gems/gems/rspec-core-3.6.0/lib/rspec/core/backtrace_formatter.rb

@@ -0,0 +1,65 @@
+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 /lib/bundler/ /exe/bundle: ]
+        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 [] unless backtrace
+        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/gems/gems/rspec-core-3.6.0/lib/rspec/core/bisect/coordinator.rb

@@ -0,0 +1,66 @@
+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/gems/gems/rspec-core-3.6.0/lib/rspec/core/bisect/example_minimizer.rb

@@ -0,0 +1,169 @@
+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
+
+          _, duration = track_duration do
+            bisect(non_failing_example_ids)
+          end
+
+          notify(:bisect_complete, :duration => duration,
+                                   :original_non_failing_count => non_failing_example_ids.size,
+                                   :remaining_count => remaining_ids.size)
+
+          remaining_ids + failed_example_ids
+        end
+
+        def bisect(candidate_ids)
+          notify(:bisect_dependency_check_started)
+          if get_expected_failures_for?([])
+            notify(:bisect_dependency_check_failed)
+            self.remaining_ids = []
+            return
+          end
+          notify(:bisect_dependency_check_passed)
+
+          bisect_over(candidate_ids)
+        end
+
+        def bisect_over(candidate_ids)
+          return if candidate_ids.one?
+
+          notify(
+            :bisect_round_started,
+            :candidate_range => example_range(candidate_ids),
+            :candidates_count => candidate_ids.size
+          )
+
+          slice_size = (candidate_ids.length / 2.0).ceil
+          lhs, rhs = candidate_ids.each_slice(slice_size).to_a
+
+          ids_to_ignore, duration = track_duration do
+            [lhs, rhs].find do |ids|
+              get_expected_failures_for?(remaining_ids - ids)
+            end
+          end
+
+          if ids_to_ignore
+            self.remaining_ids -= ids_to_ignore
+            notify(
+              :bisect_round_ignoring_ids,
+              :ids_to_ignore => ids_to_ignore,
+              :ignore_range => example_range(ids_to_ignore),
+              :remaining_ids => remaining_ids,
+              :duration => duration
+            )
+            bisect_over(candidate_ids - ids_to_ignore)
+          else
+            notify(
+              :bisect_round_detected_multiple_culprits,
+              :duration => duration
+            )
+            bisect_over(lhs)
+            bisect_over(rhs)
+          end
+        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
+        # Convenience class for describing a subset of the candidate examples
+        ExampleRange = Struct.new(:start, :finish) do
+          def description
+            if start == finish
+              "example #{start}"
+            else
+              "examples #{start}-#{finish}"
+            end
+          end
+        end
+
+      private
+
+        def example_range(ids)
+          ExampleRange.new(
+            non_failing_example_ids.find_index(ids.first) + 1,
+            non_failing_example_ids.find_index(ids.last) + 1
+          )
+        end
+
+        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
+            @remaining_ids      = non_failing_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),
+            :ids_to_run => 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
+
+        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/gems/gems/rspec-core-3.6.0/lib/rspec/core/bisect/runner.rb

@@ -0,0 +1,169 @@
+RSpec::Support.require_rspec_core "shell_escape"
+require 'open3'
+require 'shellwords'
+
+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.concat environment_repro_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(*capture_args)
+          @server.capture_run_results(*capture_args) do
+            run_command command_for([])
+          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(bisect_environment_hash, cmd).first
+          end
+        else # for 1.8.7
+          # :nocov:
+          def run_command(cmd)
+            out = err = nil
+
+            original_spec_opts = ENV['SPEC_OPTS']
+            ENV['SPEC_OPTS'] = spec_opts_without_bisect
+
+            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}"
+          ensure
+            ENV['SPEC_OPTS'] = original_spec_opts
+          end
+          # :nocov:
+        end
+
+        def bisect_environment_hash
+          if ENV.key?('SPEC_OPTS')
+            { 'SPEC_OPTS' => spec_opts_without_bisect }
+          else
+            {}
+          end
+        end
+
+        def environment_repro_parts
+          bisect_environment_hash.map do |k, v|
+            %Q(#{k}="#{v}")
+          end
+        end
+
+        def spec_opts_without_bisect
+          Shellwords.join(
+            Shellwords.split(ENV.fetch('SPEC_OPTS', '')).reject do |arg|
+              arg =~ /^--bisect/
+            end
+          )
+        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