flatware-cucumber 0.4.0 → 2.0.0.rc1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: af10de976bd3f5ab9978612d0eca4303fce90326
-  data.tar.gz: 06c0102f0d981ac87c918a77a346b35abd9dbd8f
+SHA256:
+  metadata.gz: ca4704cbed2b88a90d866db8ba7b74b3ba32214e27ab1c543a802f6fd90f11a6
+  data.tar.gz: 38d82c0121d3c9a3c67e3b129ae75f1fdbefa31c1dd6486b48c17b3793651094
 SHA512:
-  metadata.gz: f54ab4f38b3b837151349f8d453ef39f27a3855fada7cffd042c07c0afc7e54c60cf2f806f4725896d7c0a8311d87fd0f6ad96eee5103e212ed91e54f53304be
-  data.tar.gz: 1f3b63d49b7ffb911bfc49fec675f9e8b54e87b9756716d48a85dd64e862f185dce981955c6d8de32d774daa2e103f18d5a579edc92c0083a2a690835343bbfc
+  metadata.gz: 5a8b8f51c2c83933398e7b8f3d19ec55db65d58dfc944966a094e97fc176893af18f79b486cf101159a07d4588ff86bc75d800d032c4809e1f120c9c03ce2cba
+  data.tar.gz: 3262a5428592bd11866750ce8a019a5433471296b7b7e2f00f4316cbbfdc51536ad08c1a6c11525f1343e5ce15053648a9320b7c6cfbe058c6653b81895752b2

data/README.md

@@ -7,39 +7,13 @@
 
 Flatware parallelizes your test suite to significantly reduce test time.
 
-## Requirements
-
-* ZeroMQ > 4.0
-
-## Installation
-
-### ZeroMQ
-
-#### Linux Ubuntu
-
-```sh
-sudo apt-get install -qq libzmq3-dev
-```
-
-(Never you mind the 3. This package contains ZMQ version 4.)
-
-#### Mac OSX
-
-Ruby FFI isn't getting along with the latest ZMQ formula. A tweaked verson is available in the Hashrocket tap.
-
-```sh
-brew tap hashrocket/formulas
-brew install hashrocket/formulas/zeromq
-brew install zeromq
-```
-
 ### Flatware
 
 Add the runners you need to your Gemfile:
 
 ```ruby
-gem 'flatware-rspec'    # one
-gem 'flatware-cucumber' # or both
+gem 'flatware-rspec', require: false    # one
+gem 'flatware-cucumber', require: false # or both
 ```
 
 then run
@@ -66,6 +40,18 @@ To run your entire suite with the default rspec options add the `flatware-rspec`
 $ flatware rspec
 ```
 
+The rspec runner can balance worker loads, making your suite even faster.
+
+It forms balaced groups of spec files according to their last run times, if you've set `example_status_persistence_file_path` [in your RSpec config](https://relishapp.com/rspec/rspec-core/v/3-8/docs/command-line/only-failures).
+
+For this to work the configuration option must be loaded before any specs are run. The `.rspec` file is one way to achive this:
+
+    --require spec_helper
+
+But beware, if you're using ActiveRecord in your suite you'll need to avoid doing things that cause it to establish a database connection in `spec_helper.rb`. If ActiveRecord connects before flatware forks off workers, each will die messily. All of this will just work if you're following [the recomended pattern of splitting your helpers into `spec_helper` and `rails_helper`](https://github.com/rspec/rspec-rails/blob/v3.8.2/lib/generators/rspec/install/templates/spec/rails_helper.rb). Another option is to use [the configurable hooks](
+#faster-startup-with-activerecord
+).
+
 ### Options
 
 If you'd like to limit the number of forked workers, you can pass the 'w' flag:
@@ -78,7 +64,7 @@ You can also pass most cucumber/rspec options to Flatware. For example, to run o
 features that are not tagged 'javascript', you can:
 
 ```sh
-$ flatware cucumber -t ~@javascript
+$ flatware cucumber -t 'not @javascript'
 ```
 
 Additionally, for either cucumber or rspec you can specify a directory:
@@ -116,9 +102,31 @@ Now you are ready to rock:
 $ flatware rspec && flatware cucumber
 ```
 
-## Planned Features
+### Faster Startup With ActiveRecord
 
-* Use heuristics to run your slowest tests first
+Flatware has a couple lifecycle callbacks that you can use to avoid booting your app
+over again on every core. One way to take advantage of this via a `spec/flatware_helper.rb` file like so:
+
+```ruby
+Flatware.configure do |conf|
+  conf.before_fork do
+    require 'rails_helper'
+
+    ActiveRecord::Base.connection.disconnect!
+  end
+
+  conf.after_fork do |test_env_number|
+    config = ActiveRecord::Base.connection_config
+
+    ActiveRecord::Base.establish_connection(
+      config.merge(
+        database: config.fetch(:database) + test_env_number.to_s
+      )
+    )
+  end
+end
+```
+Now when I run `bundle exec flatware rspec -r ./spec/flatware_helper` My app only boots once, rather than once per core.
 
 ## Design Goals
 
@@ -149,20 +157,10 @@ directory. CD there and `flatware` will be in your path so you can tinker away.
 
 ## How it works
 
-Flatware relies on a message passing system to enable concurrency.
-The main process declares a worker for each cpu in the computer. Each
-worker forks from the main process and is then assigned a portion of the
-test suite.  As the worker runs the test suite it sends progress
-messages to the main process.  These messages are collected and when
-the last worker is finished the main process provides a report on the
-collected progress messages.
+Flatware relies on a message passing system to enable concurrency. The main process forks a worker for each cpu in the computer. These workers are each given a chunk of the tests to run. The workers report back to the main process about their progress. The main process prints those progress messages. When the last worker is finished the main process prints the results.
 
 ## Resources
 
-To learn more about the messaging system that Flatware uses, take a look at the
-[excellent ZeroMQ guide][z].
-
-[z]: http://zguide.zeromq.org/page:all
 [a]: https://github.com/cucumber/aruba
 
 ## Contributing to Flatware

data/lib/flatware/cucumber.rb

@@ -0,0 +1,51 @@
+require 'cucumber'
+require 'flatware/cucumber/formatter'
+require 'flatware/cucumber/result'
+require 'flatware/cucumber/step_result'
+require 'flatware/cucumber/formatters/console'
+require 'flatware/cucumber/cli'
+
+module Flatware
+  module Cucumber
+    class Config
+      attr_reader :config, :args
+
+      def initialize(cucumber_config, args)
+        @config = cucumber_config
+        @args = args
+      end
+
+      def feature_dir
+        @config.feature_dirs.first
+      end
+
+      def jobs
+        feature_files.map { |file| Job.new file, args }.to_a
+      end
+
+      private
+
+      def feature_files
+        config.feature_files - config.feature_dirs
+      end
+    end
+
+    module_function
+
+    def configure(args, out_stream = $stdout, error_stream = $stderr)
+      raw_args = args.dup
+      cli_config = ::Cucumber::Cli::Configuration.new(out_stream, error_stream)
+      cli_config.parse! args + %w[--format Flatware::Cucumber::Formatter]
+      cucumber_config = ::Cucumber::Configuration.new cli_config
+      Config.new cucumber_config, raw_args
+    end
+
+    def run(feature_files, options)
+      runtime(Array(feature_files) + options).run!
+    end
+
+    def runtime(args)
+      ::Cucumber::Runtime.new(configure(args).config)
+    end
+  end
+end

data/lib/flatware/cucumber/cli.rb

@@ -1,22 +1,46 @@
+# frozen_string_literal: true
+
 require 'flatware/cli'
 
 module Flatware
+  # cucumber thor command
   class CLI
     worker_option
-    method_option 'dispatch-endpoint', type: :string, default: 'ipc://dispatch'
-    method_option 'sink-endpoint', type: :string, default: 'ipc://task'
-    desc "cucumber [FLATWARE_OPTS] [CUCUMBER_ARGS]", "parallelizes cucumber with custom arguments"
+    method_option(
+      'sink-endpoint',
+      type: :string,
+      default: 'drbunix:sink'
+    )
+    desc(
+      'cucumber [FLATWARE_OPTS] [CUCUMBER_ARGS]',
+      'parallelizes cucumber with custom arguments'
+    )
     def cucumber(*args)
       config = Cucumber.configure args
 
-      unless config.jobs.any?
-        puts "Please create some feature files in the #{config.feature_dir} directory."
-        exit 1
-      end
+      ensure_jobs(config)
 
       Flatware.verbose = options[:log]
-      Worker.spawn count: workers, runner: Cucumber, dispatch: options['dispatch-endpoint'], sink: options['sink-endpoint']
-      start_sink jobs: config.jobs, workers: workers, formatter: Flatware::Cucumber::Formatters::Console.new($stdout, $stderr)
+      sink = options['sink-endpoint']
+      Worker.spawn(count: workers, runner: Cucumber, sink: sink)
+      start_sink(
+        jobs: config.jobs,
+        workers: workers,
+        formatter: Flatware::Cucumber::Formatters::Console.new($stdout, $stderr)
+      )
+    end
+
+    private
+
+    def ensure_jobs(config)
+      return if config.jobs.any?
+
+      abort(
+        format(
+          'Please create some feature files in the %<dir>s directory.',
+          dir: config.feature_dir
+        )
+      )
     end
   end
 end

data/lib/flatware/cucumber/formatter.rb

@@ -6,7 +6,7 @@ module Flatware
     class Formatter
       Checkpoint = Struct.new :steps, :scenarios do
         def failures?
-          scenarios.any? &:failed?
+          scenarios.any?(&:failed?)
         end
       end
 
@@ -21,10 +21,11 @@ module Flatware
       end
 
       def initialize(config)
-        config.on_event :after_test_case,  &method(:on_after_test_case)
-        config.on_event :after_test_step,  &method(:on_after_test_step)
-        config.on_event :finished_testing, &method(:on_finished_testing)
-        config.on_event :step_match,       &method(:on_step_match)
+        # FIXME: can we sneak the sink in through the config?
+        config.on_event :test_case_finished, &method(:on_test_case_finished)
+        config.on_event :test_step_finished, &method(:on_test_step_finished)
+        config.on_event :test_run_finished,  &method(:on_test_run_finished)
+        config.on_event :step_activated,     &method(:on_step_activated)
         reset
       end
 
@@ -38,23 +39,31 @@ module Flatware
 
       attr_reader :steps, :scenarios, :matched_steps
 
-      def on_after_test_case(event)
-        scenarios << Scenario.new(event.test_case.name, event.test_case.location.to_s, event.result.to_sym)
+      def on_test_case_finished(event)
+        scenarios << Scenario.new(
+          event.test_case.name,
+          event.test_case.location.to_s,
+          event.result.to_sym
+        )
       end
 
-      def on_step_match(event)
+      def on_step_activated(event)
         @matched_steps << event.step_match.location.to_s
       end
 
-      def on_after_test_step(event)
-        if really_a_step?(event.test_step) or event.result.undefined?
-          steps << StepResult.new(event.result.to_sym, event.result.failed? && event.result.exception)
-          Sink::client.progress Result.new event.result.to_sym
-        end
+      def on_test_step_finished(event)
+        result = event.result
+        return unless really_a_step?(event.test_step) || result.undefined?
+
+        steps << StepResult.new(
+          result.to_sym,
+          result.failed? && result.exception
+        )
+        Sink.client.progress Result.new result.to_sym
       end
 
-      def on_finished_testing(*)
-        Sink::client.checkpoint Checkpoint.new steps, scenarios
+      def on_test_run_finished(*)
+        Sink.client.checkpoint Checkpoint.new steps, scenarios
         reset
       end
 

data/lib/flatware/cucumber/formatters/console.rb

@@ -1,48 +1,56 @@
+# frozen_string_literal: true
+
 require 'flatware/cucumber/formatters/console/summary'
 require 'cucumber/formatter/console'
 
-module Flatware::Cucumber::Formatters
-  class Console
-    #for format_string
-    include ::Cucumber::Formatter::Console
-
-    FORMATS = {
-      passed:    '.',
-      failed:    'F',
-      undefined: 'U',
-      pending:   'P',
-      skipped:   '-'
-    }
-
-    STATUSES = FORMATS.keys
-
-    attr_reader :out, :err
-
-    def initialize(stdout, stderr)
-      @out, @err = stdout, stderr
-    end
-
-    def progress(result)
-      out.print format result.progress
-    end
-
-    def summarize(checkpoints)
-      steps = checkpoints.flat_map(&:steps)
-      scenarios = checkpoints.flat_map(&:scenarios)
-      Summary.new(steps, scenarios, out).summarize
-    end
-
-    def summarize_remaining(remaining_jobs)
-      out.puts
-      out.puts "The following features have not been run:"
-      for job in remaining_jobs
-        out.puts job.id
+module Flatware
+  module Cucumber
+    module Formatters
+      class Console
+        # for format_string
+        include ::Cucumber::Formatter::Console
+
+        FORMATS = {
+          passed: '.',
+          failed: 'F',
+          undefined: 'U',
+          pending: 'P',
+          skipped: '-'
+        }.freeze
+
+        STATUSES = FORMATS.keys
+
+        attr_reader :out, :err
+
+        def initialize(stdout, stderr)
+          @out = stdout
+          @err = stderr
+        end
+
+        def progress(result)
+          out.print format result.progress
+        end
+
+        def summarize(checkpoints)
+          steps = checkpoints.flat_map(&:steps)
+          scenarios = checkpoints.flat_map(&:scenarios)
+          Summary.new(steps, scenarios, out).summarize
+        end
+
+        def summarize_remaining(remaining_jobs)
+          out.puts
+          out.puts 'The following features have not been run:'
+          remaining_jobs.each do |job|
+            out.puts job.id
+          end
+        end
+
+        private
+
+        def format(status)
+          format_string FORMATS[status], status
+        end
       end
     end
-
-    private
-    def format(status)
-      format_string FORMATS[status], status
-    end
   end
 end

data/lib/flatware/cucumber/formatters/console/summary.rb

@@ -1,65 +1,82 @@
 require 'cucumber/formatter/console'
 require 'flatware/cucumber/formatters/console'
-require 'flatware/cucumber/checkpoint'
 
-module Flatware::Cucumber::Formatters
-  class Console
-    class Summary
-      include ::Cucumber::Formatter::Console
-      attr_reader :io, :steps, :scenarios
+module Flatware
+  module Cucumber
+    module Formatters
+      class Console
+        class Summary
+          include ::Cucumber::Formatter::Console
+          attr_reader :io, :steps, :scenarios
 
-      def initialize(steps, scenarios=[], io=StringIO.new)
-        @io = io
-        @steps = steps
-        @scenarios = scenarios
-      end
+          def initialize(steps, scenarios = [], io = StringIO.new)
+            @io = io
+            @steps = steps
+            @scenarios = scenarios
+          end
 
-      def summarize
-        2.times { io.puts }
-        print_failures(steps, 'step')
-        print_failures(scenarios.select(&:failed_outside_step?), 'scenario')
-        print_failed_scenarios scenarios
-        print_counts 'scenario', scenarios
-        print_counts 'step', steps
-      end
+          def summarize
+            2.times { io.puts }
+            print_failures(steps, 'step')
+            print_failures(scenarios.select(&:failed_outside_step?), 'scenario')
+            print_failed_scenarios scenarios
+            print_counts 'scenario', scenarios
+            print_counts 'step', steps
+          end
 
-      private
+          private
 
-      def print_failed_scenarios(scenarios)
-        return unless scenarios.any? &with_status(:failed)
+          def print_failed_scenarios(scenarios)
+            failed_scenarios = scenarios.select(&with_status(:failed))
+            return if failed_scenarios.empty?
 
-        io.puts format_string "Failing Scenarios:", :failed
-        scenarios.select(&with_status(:failed)).sort_by(&:file_colon_line).each do |scenario|
-          io.puts format_string(scenario.file_colon_line, :failed) + format_string(" # Scenario: " + scenario.name, :comment)
-        end
-        io.puts
-      end
+            io.puts format_string 'Failing Scenarios:', :failed
+            failed_scenarios
+              .sort_by(&:file_colon_line)
+              .map(&method(:to_failed_scenario_line))
+              .each(&io.method(:puts))
+            io.puts
+          end
 
-      def print_failures(collection, label)
-        failures = collection.select(&with_status(:failed))
-        print_elements failures, :failed, pluralize(label, failures.size)
-      end
+          def to_failed_scenario_line(scenario)
+            [
+              [scenario.file_colon_line, :failed],
+              ["# Scenario: #{scenario.name}", :comment]
+            ].map do |string, format|
+              format_string string, format
+            end.join(' ')
+          end
 
-      def print_counts(label, collection)
-        io.puts pluralize(label, collection.size) + count_summary(collection)
-      end
+          def print_failures(collection, label)
+            failures = collection.select(&with_status(:failed))
+            print_elements failures, :failed, pluralize(label, failures.size)
+          end
 
-      def pluralize(word, number)
-        "#{number} #{number == 1 ? word : word + 's'}"
-      end
+          def print_counts(label, collection)
+            io.puts(
+              pluralize(label, collection.size) + count_summary(collection)
+            )
+          end
 
-      def with_status(status)
-        proc {|r| r.status == status}
-      end
+          def pluralize(word, number)
+            "#{number} #{number == 1 ? word : "#{word}s"}"
+          end
+
+          def with_status(status)
+            proc { |r| r.status == status }
+          end
 
-      def count_summary(results)
-        return "" unless results.any?
-        status_counts = STATUSES.map do |status|
-          count = results.select(&with_status(status)).size
-          format_string "#{count} #{status}", status if count > 0
-        end.compact.join ", "
+          def count_summary(results)
+            return '' unless results.any?
 
-        " (#{status_counts})"
+            status_counts = STATUSES.map do |status|
+              count = results.select(&with_status(status)).size
+              format_string "#{count} #{status}", status if count.positive?
+            end.compact.join ', '
+
+            " (#{status_counts})"
+          end
+        end
       end
     end
   end

data/lib/flatware/cucumber/result.rb

@@ -5,12 +5,12 @@ module Flatware
 
       def initialize(progress)
         @progress = progress
-        @worker   = ENV['TEST_ENV_NUMBER'].to_i
+        @worker   = ENV.fetch('TEST_ENV_NUMBER', 0).to_i
       end
 
       class << self
         def step(*args)
-          step = StepResult.new *args
+          step = StepResult.new(*args)
           new step.progress, [step]
         end
 

data/lib/flatware/cucumber/runtime.rb

@@ -3,13 +3,12 @@ require 'cucumber'
 module Flatware
   module Cucumber
     class Runtime < ::Cucumber::Runtime
-
       attr_accessor :configuration, :loader
-      attr_reader :out, :err
-      attr_reader :visitor
+      attr_reader :out, :err, :visitor
 
-      def initialize(out=StringIO.new, err=out)
-        @out, @err = out, err
+      def initialize(out = StringIO.new, err = out)
+        @out = out
+        @err = err
         super(default_configuration)
         load_step_definitions
         @results = Results.new(configuration)
@@ -21,9 +20,13 @@ module Flatware
         config
       end
 
-      def run(feature_files=[], options=[])
+      def run(feature_files = [], options = [])
         @loader = nil
-        options = Array(feature_files) + %w[--format Flatware::Cucumber::Formatter] + options
+        options = [
+          Array(feature_files),
+          %w[--format Flatware::Cucumber::Formatter],
+          options
+        ].reduce(:+)
 
         configure(::Cucumber::Cli::Main.new(options, out, err).configuration)
 

data/lib/flatware/cucumber/step_result.rb

@@ -5,7 +5,8 @@ module Flatware
       attr_reader :status, :exception
 
       def initialize(status, exception)
-        @status, @exception = status, (serialized(exception) if exception)
+        @status = status
+        @exception = (serialized(exception) if exception)
       end
 
       def passed?
@@ -21,9 +22,10 @@ module Flatware
       end
 
       private
-      def serialized(e)
-        e.backtrace and e.backtrace.unshift e.backtrace.shift.sub(Dir.pwd, '.')
-        SerializedException.new(e.class, e.message, e.backtrace)
+
+      def serialized(err)
+        err.backtrace&.unshift(err.backtrace.shift.sub(Dir.pwd, '.'))
+        SerializedException.new(err.class, err.message, err.backtrace)
       end
     end
   end

metadata

@@ -1,43 +1,43 @@
 --- !ruby/object:Gem::Specification
 name: flatware-cucumber
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 2.0.0.rc1
 platform: ruby
 authors:
 - Brian Dunn
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2017-01-27 00:00:00.000000000 Z
+date: 2021-03-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: flatware
+  name: cucumber
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '='
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.4.0
+        version: '3.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '='
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.4.0
+        version: '3.0'
 - !ruby/object:Gem::Dependency
-  name: cucumber
+  name: flatware
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - '='
       - !ruby/object:Gem::Version
-        version: '2.0'
+        version: 2.0.0.rc1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - '='
       - !ruby/object:Gem::Version
-        version: '2.0'
+        version: 2.0.0.rc1
 description: A distributed cucumber runner
 email: brian@hashrocket.com
 executables: []
@@ -49,37 +49,38 @@ files:
 - LICENSE.txt
 - README.md
 - lib/flatware-cucumber.rb
-- lib/flatware/cucumber/checkpoint.rb
+- lib/flatware/cucumber.rb
 - lib/flatware/cucumber/cli.rb
 - lib/flatware/cucumber/formatter.rb
 - lib/flatware/cucumber/formatters/console.rb
 - lib/flatware/cucumber/formatters/console/summary.rb
 - lib/flatware/cucumber/result.rb
 - lib/flatware/cucumber/runtime.rb
-- lib/flatware/cucumber/scenario_result.rb
 - lib/flatware/cucumber/step_result.rb
 homepage: http://github.com/briandunn/flatware
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - "~>"
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.6'
+  - - "<"
     - !ruby/object:Gem::Version
-      version: '2.1'
+      version: '3.1'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.6.8
-signing_key: 
+rubygems_version: 3.2.3
+signing_key:
 specification_version: 4
 summary: A distributed cucumber runner
 test_files: []

data/lib/flatware/cucumber/checkpoint.rb

@@ -1,28 +0,0 @@
-module Flatware
-  module Cucumber
-    class Checkpoint
-      attr_reader :steps, :scenarios
-      def initialize(steps, scenarios)
-        @steps, @scenarios = serialize_steps(steps), serialize_scenarios(scenarios)
-      end
-
-      def failures?
-        scenarios.any? &:failed?
-      end
-
-      private
-
-      def serialize_steps(steps)
-        steps.map do |step|
-          StepResult.new step.status, step.exception
-        end
-      end
-
-      def serialize_scenarios(scenarios)
-        scenarios.map do |scenario|
-          ScenarioResult.new scenario.status, scenario.file_colon_line, scenario.name, scenario.exception
-        end
-      end
-    end
-  end
-end

data/lib/flatware/cucumber/scenario_result.rb

@@ -1,38 +0,0 @@
-require 'flatware/serialized_exception'
-module Flatware
-  module Cucumber
-    class ScenarioResult
-      attr_reader :status, :file_colon_line, :name
-      def initialize(status, file_colon_line, name, e)
-        @status = status
-        @file_colon_line = file_colon_line
-        @name = name
-        @exception = SerializedException.new(e.class, e.message, e.backtrace) if e
-        @failed_outside_step = false
-      end
-
-      def passed?
-        status == :passed
-      end
-
-      def failed?
-        status == :failed
-      end
-
-      def failed_outside_step!(file_colon_line)
-        @failed_outside_step = file_colon_line
-      end
-
-      def failed_outside_step?
-        !!@failed_outside_step
-      end
-
-      def exception
-        @exception.tap do |e|
-          e.backtrace = e.backtrace.grep(Regexp.new(Dir.pwd)).map { |line| line[Dir.pwd.size..-1] }
-          e.backtrace = e.backtrace + [@failed_outside_step] if failed_outside_step?
-        end
-      end
-    end
-  end
-end