pork 1.3.1 → 1.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b60799f58ae3ada9e2e21aac7abd1976b58fc4a5
-  data.tar.gz: d164b9472b6172aa706d5b0277e76973f72d442c
+  metadata.gz: 2a1e1b97195a2ba57307d273567e63ba63984492
+  data.tar.gz: 1fa9b61acb0d8fa4face3e6175d0cff655d4f4a6
 SHA512:
-  metadata.gz: 976ed47455385545294100c395a7eae919bf05817abe3d28ece08c123160fe6cc76a41e2d6ee41b40cd53520ef163b0c9f91355a474ad75cfd98dd4b00afc2fe
-  data.tar.gz: e5829c79dad56585a2fd33e74dab2692d6ece7261de31d53e6428da3fdad1cac47287f361205221f3840ab7edd79129e17738e57793d10e5981bf89fc4deaf50
+  metadata.gz: 733207de6f02953d3bd378047b756e35495d59ccd8620dd39d169c5d90b25de788a2592613eb3bc3d8cd9d713195247f7423cd16cf8217f8f249e5c718e97a15
+  data.tar.gz: 63dfbffaf0a50ed00e0c79ba022a180816de4279667dd318c268fe1b5ab3fe412a9e4ae1f769f0c42132181197cdad761a6e5e2254dcb3103dd6101c2fd561b7

data/.travis.yml

@@ -5,7 +5,6 @@ rvm:
   - 2.1
   - 2.2
   - rbx-2
-  - jruby
   - jruby-head
 
 install: 'bundle install --retry=3'

data/CHANGES.md

@@ -1,5 +1,13 @@
 # CHANGES
 
+## Pork 1.4.0 -- 2015-07-18
+
+### Enhancement
+
+* Introduced `Pork.report_mode` and `ENV['PORK_REPORT']`.
+* The replicating command for `ENV['PORK_SEED']` is more accurate now.
+* Now you can still run test sequentially when ENV['PORK_TEST'] is set.
+
 ## Pork 1.3.1 -- 2015-06-06
 
 ### Enhancement

data/README.md

@@ -835,6 +835,21 @@ Summary by examples:
 * `env PORK_TEST='group0' rake test`
 * `env PORK_TEST='group0,group1' rake test`
 
+### `env PORK_SEED=`
+
+By default, before running a test case, Pork would try to generate a
+random seed for each test case. This way, we could easily replicate
+each test case by setting the same random seed.
+
+However, this could hurt performance and randomness. This is a trade off
+before Ruby can restore arbitrary random state. If you don't want this
+behaviour, you could set `PORK_SEED=random` to force Pork only set the
+seed before running the entire test suite, saving you some performance
+and randomness.
+
+Otherwise, you don't have to care about this option. Just copy and
+paste the replicating command when one of your test cases failed.
+
 ### Pork.execute_mode
 
 By default, `Pork.execute_mode` is set to `:shuffled` which would execute
@@ -869,6 +884,42 @@ Or:
 env PORK_MODE=parallel ruby -Ilib test/test_pork.rb
 ```
 
+### Pork.report_mode
+
+By default, `Pork.report_mode` is set to `:dot` which would print a dot
+for each test case. This is the same as test/unit bundled in Ruby. We
+provide another option: `:description` which would print the description
+for each test case. This might be useful if you are not running a bunch
+of test cases. All the options are:
+
+* `:dot` (default)
+* `:description`
+
+Pass the symbol to it to use the mode:
+
+``` ruby
+Pork.report_mode :description
+```
+
+On the other hand, you could also set `ENV['PORK_REPORT']` for picking an
+reporting mode. This would be convenient if you just want to switch to a
+particular mode temporary via command line. For example:
+
+``` shell
+env PORK_REPORT=description rake test
+```
+
+Or:
+
+``` shell
+env PORK_REPORT=description ruby -Ilib test/test_pork.rb
+```
+
+Caveat: You might see interleaving description output if you're running with
+`Pork.execute_mode :shuffled` because... it's shuffled. You might want to run
+in `Pork.execute_mode :sequential` along with `Pork.report_mode :description`
+if you don't want to see interleaving descriptions.
+
 ### Pork.inspect_failure_mode
 
 By default, `Pork.inspect_failure_mode` is set to `:auto`, which would

data/lib/pork.rb

@@ -13,18 +13,32 @@ module Pork
   end
 
   # default to :shuffled while eliminating warnings for uninitialized ivar
-  def self.execute_mode execute=nil
-    @execute = execute || @execute ||= :shuffled
+  def self.execute_mode mode=nil
+    @execute_mode = mode || @execute_mode ||= :shuffled
+  end
+
+  def self.report_mode mode=nil
+    @report_mode = mode || @report_mode ||= :dot
+    require "pork/report/#{@report_mode}"
+    @report_mode
+  end
+
+  def self.report_class
+    const_get(report_mode.to_s.capitalize)
+  end
+
+  def self.report_extensions
+    @report_extensions ||= []
   end
 
   def self.Rainbows!
     require 'pork/extra/rainbows'
-    Pork::Stat.__send__(:include, Pork::Rainbows)
+    report_extensions << Rainbows
   end
 
   def self.show_source
     require 'pork/extra/show_source'
-    Pork::Stat.__send__(:include, Pork::ShowSource)
+    report_extensions << ShowSource
   end
 
   def self.stat
@@ -39,6 +53,25 @@ module Pork
               end
   end
 
+  def self.reseed
+    if ENV['PORK_SEED']
+      seed
+    else
+      new_seed = Random.new_seed
+      Random.srand(new_seed)
+      new_seed
+    end
+  end
+
+  def self.srand
+    case ENV['PORK_SEED']
+    when nil, 'random'
+      Random.srand(seed)
+    else
+      Random.srand(Integer(ENV['PORK_SEED']))
+    end
+  end
+
   def self.trap sig='SIGINT'
     Signal.trap(sig) do
       stat.report
@@ -48,15 +81,10 @@ module Pork
   end
 
   def self.execute
-    Random.srand(ENV['PORK_SEED'].to_i) if ENV['PORK_SEED']
-    seed
     if ENV['PORK_TEST']
-      require 'pork/mode/shuffled'
+      require 'pork/isolate'
       if tests = Executor[ENV['PORK_TEST']]
-        paths, imps =
-          tests.group_by{ |p| p.kind_of?(Array) }.values_at(true, false)
-        @stat = Executor.execute(execute_mode, stat, paths) if paths
-        @stat = imps.inject(stat){ |s, i| i.execute(execute_mode, s) } if imps
+        @stat = Executor.execute(execute_mode, stat, tests)
       else
         puts "Cannot find test: #{ENV['PORK_TEST']}"
         exit 254
@@ -67,7 +95,9 @@ module Pork
   end
 
   def self.run
+    srand
     execute_mode(ENV['PORK_MODE'])
+    report_mode(ENV['PORK_REPORT'])
     trap
     execute
     stat.report

data/lib/pork/executor.rb

@@ -4,6 +4,10 @@ require 'pork/context'
 
 module Pork
   class Executor < Struct.new(:pork_stat, :pork_description)
+    # we don't want this method from Struct.new, it's confusing when
+    # pork/isolate was not loaded. (i.e. isolate would override it anyway)
+    singleton_class.superclass.send(:remove_method, :[])
+
     extend Imp
     include Context
     init

data/lib/pork/extra/rainbows.rb

@@ -1,15 +1,19 @@
 
 module Pork
   module Rainbows
-    def case_pass msg='.'
-      @rainbows ||= 0
-      io.print( color256(rainbows(@rainbows)){msg} )
-      @rainbows  += 1
+    def msg_pass
+      @rainbows ||= -1
+      @rainbows  += +1
+      color256(rainbows(@rainbows), strip_color(super))
     end
 
     private
-    def color256 rgb
-      "\e[38;5;#{rgb}m#{yield}\e[0m"
+    def strip_color text
+      text.gsub(/\e\[\d+m/, '')
+    end
+
+    def color256 rgb, text
+      "\e[38;5;#{rgb}m#{text}\e[0m"
     end
 
     def rainbows i

data/lib/pork/imp.rb

@@ -30,11 +30,7 @@ module Pork
 
     def execute mode, *args
       require "pork/mode/#{mode}"
-      if args.size == 1 || mode.to_s != 'sequential'
-        send(mode, *args)
-      else # cannot run sequential tests for specific paths
-        shuffled(*args)
-      end
+      public_send(mode, *args)
     end
 
     private
@@ -46,35 +42,38 @@ module Pork
     def run stat, desc, test, env
       assertions = stat.assertions
       context = new(stat, desc)
-      run_protected(stat, desc, test) do
+      seed = Pork.reseed
+      stat.reporter.case_start(context)
+      run_protected(stat, desc, test, seed) do
         env.run_before(context)
         context.instance_eval(&test)
         if assertions == stat.assertions
           raise Error.new('Missing assertions')
         end
-        stat.case_pass
+        stat.reporter.case_pass
       end
     ensure
       stat.incr_tests
-      run_protected(stat, desc, test){ env.run_after(context) }
+      run_protected(stat, desc, test, seed){ env.run_after(context) }
+      stat.reporter.case_end
     end
 
-    def run_protected stat, desc, test
+    def run_protected stat, desc, test, seed
       yield
     rescue Error, StandardError => e
       case e
       when Skip
         stat.incr_skips
-        stat.case_skip
+        stat.reporter.case_skip
       else
-        err = [e, description_for("would #{desc}"), test]
+        err = [e, description_for("would #{desc}"), test, seed]
         case e
         when Failure
           stat.add_failure(err)
-          stat.case_failed
+          stat.reporter.case_failed
         when Error, StandardError
           stat.add_error(err)
-          stat.case_errored
+          stat.reporter.case_errored
         end
       end
     end

data/lib/pork/isolate.rb

@@ -0,0 +1,102 @@
+
+require 'pork'
+
+module Pork
+  module Isolate
+    def all_tests
+      @all_tests ||= build_all_tests
+    end
+
+    def all_paths
+      (all_tests[:files] || {}).values.flat_map(&:values).flatten(1).uniq
+    end
+
+    def [] index
+      by_groups(index) || by_source(index)
+    end
+
+    def by_groups groups
+      return unless tests = all_tests[:groups]
+      paths = groups.split(',').flat_map do |g|
+        tests[g.strip] || []
+      end.uniq
+      paths unless paths.empty?
+    end
+
+    def by_source source
+      return unless tests = all_tests[:files]
+      file_str, line_str = source.split(':')
+      file, line = File.expand_path(file_str), line_str.to_i
+      return unless cases = tests[file]
+      if line.zero?
+        cases.values.flatten(1).uniq
+      else
+        _, paths = cases.reverse_each.find{ |(l, _)| l <= line }
+        paths
+      end
+    end
+
+    protected
+    def isolate stat, path, super_env=nil
+      env = Env.new(super_env)
+      idx = path.first
+
+      @tests.first(idx).each do |(type, arg, _)|
+        case type
+        when :before
+          env.before << arg
+        when :after
+          env.after  << arg
+        end
+      end
+
+      if path.size == 1
+        _, desc, test = @tests[idx]
+        run(stat, desc, test, env)
+      else
+        @tests[idx][1].isolate(stat, path.drop(1), env)
+      end
+
+      stat
+    end
+
+    def build_all_tests result={}, path=[]
+      @tests.each_with_index.inject(result) do |r,
+                                                ((type, imp, test, opts),
+                                                  index)|
+        current = path + [index]
+
+        case type
+        when :describe
+          imp.build_all_tests(r, current) do |nested|
+            store_path(r, nested, test, opts[:groups])
+          end
+        when :would
+          yield(current) if block_given?
+          store_path(r, current, test, opts[:groups])
+        end
+
+        r
+      end
+    end
+
+    def store_path tests, path, test, groups
+      store_for_groups(tests, path, groups) if groups
+      store_for_source(tests, path, *test.source_location)
+    end
+
+    def store_for_groups tests, path, groups
+      r = tests[:groups] ||= {}
+      groups.each do |g|
+        (r[g.to_s] ||= []) << path
+      end
+    end
+
+    def store_for_source tests, path, file, line
+      r = tests[:files] ||= {}
+      ((r[File.expand_path(file)] ||= {})[line] ||= []) << path
+    end
+  end
+
+  Executor.extend(Isolate)
+end

data/lib/pork/mode/parallel.rb

@@ -10,7 +10,7 @@ module Pork
     def parallel stat=Stat.new, paths=all_paths
       paths.shuffle.each_slice(cores).map do |paths_slice|
         Thread.new do
-          execute(:shuffled, Stat.new(stat.io), paths_slice)
+          execute(:shuffled, Stat.new(stat.reporter), paths_slice)
         end
       end.map(&:value).inject(stat, &:merge)
     end

data/lib/pork/mode/sequential.rb

@@ -3,7 +3,17 @@ require 'pork'
 
 module Pork
   module Sequential
-    def sequential stat=Stat.new, super_env=nil
+    def sequential stat=Stat.new, paths=nil
+      if paths
+        require 'pork/isolate'
+        paths.inject(stat, &method(:isolate))
+      else # maybe we could remove this mode if it's not faster and lighter
+        sequential_with_env(stat)
+      end
+    end
+
+    protected
+    def sequential_with_env stat, super_env=nil
       env = Env.new(super_env)
       @tests.each do |(type, arg, test)|
         case type
@@ -12,7 +22,7 @@ module Pork
         when :after
           env.after  << arg
         when :describe
-          arg.sequential(stat, env)
+          arg.sequential_with_env(stat, env)
         when :would
           run(stat, arg, test, env)
         end

data/lib/pork/mode/shuffled.rb

@@ -1,102 +1,11 @@
 
-require 'pork'
+require 'pork/isolate'
 
 module Pork
   module Shuffled
-    def all_tests
-      @all_tests ||= build_all_tests
-    end
-
-    def all_paths
-      (all_tests[:files] || {}).values.flat_map(&:values).flatten(1).
-        select{ |path| path.kind_of?(Array) }
-    end
-
-    def [] index
-      by_groups(index) || by_source(index)
-    end
-
-    def by_groups groups
-      return unless tests = all_tests[:groups]
-      paths = groups.split(',').flat_map do |g|
-        tests[g.strip] || []
-      end.uniq
-      paths unless paths.empty?
-    end
-
-    def by_source source
-      return unless tests = all_tests[:files]
-      file_str, line_str = source.split(':')
-      file, line = File.expand_path(file_str), line_str.to_i
-      return unless cases = tests[file]
-      if line.zero?
-        cases.values.flatten(1)
-      else
-        _, paths = cases.reverse_each.find{ |(l, _)| l <= line }
-        paths
-      end
-    end
-
     def shuffled stat=Stat.new, paths=all_paths
       paths.shuffle.inject(stat, &method(:isolate))
     end
-
-    protected
-    def isolate stat, path, super_env=nil
-      env = Env.new(super_env)
-      idx = path.first
-
-      @tests.first(idx).each do |(type, arg, _)|
-        case type
-        when :before
-          env.before << arg
-        when :after
-          env.after  << arg
-        end
-      end
-
-      if path.size == 1
-        _, desc, test = @tests[idx]
-        run(stat, desc, test, env)
-      else
-        @tests[idx][1].isolate(stat, path.drop(1), env)
-      end
-
-      stat
-    end
-
-    def build_all_tests result={}, path=[]
-      @tests.each_with_index.inject(result) do |r,
-                                                ((type, imp, test, opts),
-                                                  index)|
-        current = path + [index]
-        path_or_imp = case type
-                      when :describe
-                        imp
-                      when :would
-                        current
-                      else
-                        next r
-                      end
-        groups = opts[:groups]
-        store_for_groups(r, path_or_imp, groups) if groups
-        store_for_source(r, path_or_imp, *test.source_location)
-        imp.build_all_tests(r, current) if type == :describe
-        r
-      end
-    end
-
-    def store_for_groups tests, path_or_imp, groups
-      r = tests[:groups] ||= {}
-      groups.each do |g|
-        (r[g.to_s] ||= []) << path_or_imp
-      end
-    end
-
-    def store_for_source tests, path_or_imp, file, line
-      r = tests[:files] ||= {}
-      ((r[File.expand_path(file)] ||= {})[line] ||= []) << path_or_imp
-    end
   end
 
   Executor.extend(Shuffled)

data/lib/pork/more/bottomup_backtrace.rb

@@ -1,5 +1,5 @@
 
-require 'pork/stat'
+require 'pork'
 
 module Pork
   module BottomupBacktrace
@@ -9,5 +9,5 @@ module Pork
     end
   end
 
-  Pork::Stat.__send__(:include, Pork::BottomupBacktrace)
+  report_extensions << BottomupBacktrace
 end

data/lib/pork/more/color.rb

@@ -1,14 +1,14 @@
 
-require 'pork/stat'
+require 'pork'
 
 module Pork
   module Color
-    def case_skip    msg='s'; super(yellow( msg)); end
-    def case_failed  msg='F'; super(magenta(msg)); end
-    def case_errored msg='E'; super(red(    msg)); end
+    def msg_skip   ;  yellow(super); end
+    def msg_failed ; magenta(super); end
+    def msg_errored;     red(super); end
 
     private
-    def command name
+    def command name, seed
       gray(super)
     end
 
@@ -28,8 +28,8 @@ module Pork
       cyan(super)
     end
 
-    def numbers
-      super.zip(%w[green green magenta red yellow]).map do |(num, col)|
+    def numbers stat
+      stat.numbers.zip(%w[green green magenta red yellow]).map do |(num, col)|
         if num == 0
           num
         else
@@ -38,8 +38,8 @@ module Pork
       end
     end
 
-    def velocity
-      super.zip(%w[cyan blue blue]).map do |(str, col)|
+    def velocity stat
+      stat.velocity.zip(%w[cyan blue blue]).map do |(str, col)|
         send(col, str)
       end
     end
@@ -69,5 +69,5 @@ module Pork
     end
   end
 
-  Pork::Stat.__send__(:include, Pork::Color)
+  report_extensions << Color
 end

data/lib/pork/report.rb

@@ -0,0 +1,128 @@
+
+module Pork
+  Report = Struct.new(:io)
+
+  module Report::Imp
+    def initialize o=$stdout
+      super
+      extend(*Pork.report_extensions.reverse)
+    end
+
+    def case_start _; end
+    def case_end    ; end
+    def case_pass   ; io.print msg_pass   ; end
+    def case_skip   ; io.print msg_skip   ; end
+    def case_failed ; io.print msg_failed ; end
+    def case_errored; io.print msg_errored; end
+
+    def report stat
+      io.puts
+      io.puts messages(stat)
+      io.printf("\nFinished in %s seconds, %s tests/s, %s assertions/s \n",
+                *velocity(stat))
+      io.printf("%s tests, %s assertions, %s failures, %s errors, %s skips\n",
+                *numbers(stat))
+    end
+
+    private
+    def velocity stat
+      stat.velocity
+    end
+
+    def numbers stat
+      stat.numbers
+    end
+
+    def messages stat
+      stat.exceptions.reverse_each.map do |(err, msg, test, seed)|
+        "\n  #{show_command(test.source_location, seed)}" \
+        "\n  #{show_backtrace(test, err)}"                \
+        "#{show_source(test, err)}"                       \
+        "\n#{show_message(msg)}"                          \
+        "\n#{show_exception(err)}"
+      end
+    end
+
+    def show_command source_location, seed
+      "Replicate this test with:\n#{command(source_location, seed)}"
+    end
+
+    def command source_location, seed
+      "env#{pork_test(source_location)} #{pork_mode} #{pork_seed(seed)}" \
+      " #{Gem.ruby} -S #{$0} #{ARGV.join(' ')}"
+    end
+
+    def show_backtrace test, err
+      backtrace(test, err).join("\n  ")
+    end
+
+    def backtrace test, err
+      if $VERBOSE
+        err.backtrace
+      else
+        strip(reject_pork(test, err))
+      end
+    end
+
+    def show_source _, _
+      ''
+    end
+
+    def highlight_line line
+      line
+    end
+
+    def backlight_line line
+      line
+    end
+
+    def show_message msg
+      msg
+    end
+
+    def show_exception err
+      "#{err.class}: #{err.message}"
+    end
+
+    def reject_pork test, err
+      bt = err.backtrace.reject{ |l| l =~ %r{/lib/pork(/\w+)*\.rb:\d+} }
+      if bt.empty?
+        ["#{test.source_location.join(':')}:in `block in would'"]
+      else
+        bt
+      end
+    end
+
+    def strip bt
+      strip_home(strip_cwd(bt))
+    end
+
+    def strip_home bt
+      bt.map{ |path| path.sub(ENV['HOME'], '~') }
+    end
+
+    def strip_cwd bt
+      bt.map{ |path| path.sub("#{Dir.pwd}/", '') }
+    end
+
+    def pork_test source_location
+      if !!ENV['PORK_SEED'] == !!ENV['PORK_TEST'] || ENV['PORK_TEST']
+        file, line = source_location
+        " PORK_TEST='#{strip([file]).join}:#{line}'"
+      else
+        # cannot replicate a test case with PORK_SEED set and PORK_TEST unset
+        # unless we could restore random's state (srand didn't work for that)
+      end
+    end
+
+    def pork_mode
+      "PORK_MODE=#{Pork.execute_mode}"
+    end
+
+    def pork_seed seed
+      "PORK_SEED=#{seed}"
+    end
+  end
+
+  Report.__send__(:include, Report::Imp)
+end

data/lib/pork/report/description.rb

@@ -0,0 +1,39 @@
+
+require 'pork/report/dot'
+
+module Pork
+  class Description < Dot
+    attr_accessor :last_executor
+
+    def msg_pass
+      msg = "\e[1Go"
+      if respond_to?(:green, true)
+        green(msg)
+      else
+        msg
+      end
+    end
+
+    def msg_skip   ; "\e[1G#{super}"; end
+    def msg_failed ; "\e[1G#{super}"; end
+    def msg_errored; "\e[1G#{super}"; end
+
+    def case_start context
+      self.last_executor ||= Executor
+      executor = context.class
+      levels = executor.ancestors.drop(1).count{ |a| a <= Executor }
+
+      if executor != Executor && last_executor != executor
+        io.puts "#{'  ' * (levels - 1)}#{executor.desc}"
+      end
+
+      io.print "#{'  ' * levels}#{context.pork_description}: "
+
+      self.last_executor = executor
+    end
+
+    def case_end
+      io.puts
+    end
+  end
+end

data/lib/pork/report/dot.rb

@@ -0,0 +1,11 @@
+
+require 'pork/report'
+
+module Pork
+  class Dot < Report
+    def msg_pass   ; '.'; end
+    def msg_skip   ; 's'; end
+    def msg_failed ; 'F'; end
+    def msg_errored; 'E'; end
+  end
+end

data/lib/pork/stat.rb

@@ -1,146 +1,57 @@
 
 require 'thread'
+require 'pork/report'
 
 module Pork
-  Stat = Struct.new(:io, :start, :mutex,
+  Stat = Struct.new(:reporter, :start, :mutex,
                     :tests, :assertions, :skips, :failures, :errors,
                     :exceptions)
 
-  Stat::Imp = Module.new do
+  module Stat::Imp
     attr_accessor :stop
-    def initialize io=$stdout, st=Time.now, mu=Mutex.new,
+    def initialize rt=Pork.report_class.new,
+                   st=Time.now, mu=Mutex.new,
                    t=0, a=0, s=0, f=0, e=0, x=[]
       super
     end
+
     def incr_assertions; mutex.synchronize{ self.assertions += 1 }; end
     def incr_tests     ; mutex.synchronize{ self.tests      += 1 }; end
     def incr_skips     ; mutex.synchronize{ self.skips      += 1 }; end
+
     def add_failure err
       mutex.synchronize do
         self.failures += 1
         exceptions << err
       end
     end
+
     def add_error err
       mutex.synchronize do
         self.errors += 1
         exceptions << err
       end
     end
-    def case_pass    msg='.'; io.print msg; end
-    def case_skip    msg='s'; io.print msg; end
-    def case_failed  msg='F'; io.print msg; end
-    def case_errored msg='E'; io.print msg; end
+
     def passed?; exceptions.size == 0                        ; end
     def numbers; [tests, assertions, failures, errors, skips]; end
+
     def velocity
       time_spent = stop - start
       [time_spent.round(6),
        (tests / time_spent).round(4),
        (assertions / time_spent).round(4)]
     end
+
     def report
       self.stop = Time.now
-      io.puts
-      io.puts report_exceptions
-      io.printf("\nFinished in %s seconds, %s tests/s, %s assertions/s \n",
-                *velocity)
-      io.printf("%s tests, %s assertions, %s failures, %s errors, %s skips\n",
-                *numbers)
+      reporter.report(self)
     end
+
     def merge stat
-      self.class.new(io, start, mutex,
+      self.class.new(reporter, start, mutex,
         *to_a.drop(3).zip(stat.to_a.drop(3)).map{ |(a, b)| a + b })
     end
-
-    private
-    def report_exceptions
-      exceptions.reverse_each.map do |(err, msg, test)|
-        "\n  #{show_command(test.source_location)}" \
-        "\n  #{show_backtrace(test, err)}"          \
-        "#{show_source(test, err)}"                 \
-        "\n#{show_message(msg)}"                    \
-        "\n#{show_exception(err)}"
-      end
-    end
-
-    def show_command source_location
-      "Replicate this test with:\n#{command(source_location)}"
-    end
-
-    def command source_location
-      "#{env(source_location)} #{Gem.ruby} -S #{$0} #{ARGV.join(' ')}"
-    end
-
-    def show_backtrace test, err
-      backtrace(test, err).join("\n  ")
-    end
-
-    def backtrace test, err
-      if $VERBOSE
-        err.backtrace
-      else
-        strip(reject_pork(test, err))
-      end
-    end
-
-    def show_source _, _
-      ''
-    end
-
-    def highlight_line line
-      line
-    end
-
-    def backlight_line line
-      line
-    end
-
-    def show_message msg
-      msg
-    end
-
-    def show_exception err
-      "#{err.class}: #{err.message}"
-    end
-
-    def reject_pork test, err
-      bt = err.backtrace.reject{ |l| l =~ %r{/lib/pork(/\w+)*\.rb:\d+} }
-      if bt.empty?
-        ["#{test.source_location.join(':')}:in `block in would'"]
-      else
-        bt
-      end
-    end
-
-    def strip bt
-      strip_home(strip_cwd(bt))
-    end
-
-    def strip_home bt
-      bt.map{ |path| path.sub(ENV['HOME'], '~') }
-    end
-
-    def strip_cwd bt
-      bt.map{ |path| path.sub("#{Dir.pwd}/", '') }
-    end
-
-    def env source_location
-      "env #{pork(source_location)} #{pork_mode} #{pork_seed}"
-    end
-
-    def pork source_location
-      file, line = source_location
-      "PORK_TEST='#{strip([file]).join}:#{line}'"
-    end
-
-    def pork_mode
-      "PORK_MODE=#{Pork.execute_mode}"
-    end
-
-    def pork_seed
-      "PORK_SEED=#{Pork.seed}"
-    end
   end
 
   Stat.__send__(:include, Stat::Imp)

data/lib/pork/test.rb

@@ -1,19 +1,16 @@
 
 require 'pork/auto'
 
-Pork.autorun(false)
+Pork.autorun
 Pork.show_source
+Pork.Rainbows! if rand(10) == 0
 
-at_exit do
-  Pork.module_eval do
-    execute_mode(ENV['PORK_MODE'])
-    trap
-    execute
+Pork.singleton_class.send(:prepend, Module.new{
+  def execute
+    super
     %w[sequential shuffled parallel].each do |mode|
       execute_mode(mode)
-      execute
+      super
     end
-    stat.report
-    exit stat.failures + stat.errors + ($! && 1).to_i
   end
-end
+})

data/lib/pork/version.rb

@@ -1,4 +1,4 @@
 
 module Pork
-  VERSION = '1.3.1'
+  VERSION = '1.4.0'
 end

data/pork.gemspec

@@ -1,14 +1,14 @@
 # -*- encoding: utf-8 -*-
-# stub: pork 1.3.1 ruby lib
+# stub: pork 1.4.0 ruby lib
 
 Gem::Specification.new do |s|
   s.name = "pork"
-  s.version = "1.3.1"
+  s.version = "1.4.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.require_paths = ["lib"]
   s.authors = ["Lin Jen-Shin (godfat)"]
-  s.date = "2015-06-06"
+  s.date = "2015-07-18"
   s.description = "Pork -- Simple and clean and modular testing library.\n\nInspired by [Bacon][].\n\n[Bacon]: https://github.com/chneukirchen/bacon"
   s.email = ["godfat (XD) godfat.org"]
   s.files = [
@@ -32,6 +32,7 @@ Gem::Specification.new do |s|
   "lib/pork/extra/show_source.rb",
   "lib/pork/imp.rb",
   "lib/pork/inspect.rb",
+  "lib/pork/isolate.rb",
   "lib/pork/mode/parallel.rb",
   "lib/pork/mode/sequential.rb",
   "lib/pork/mode/shuffled.rb",
@@ -39,6 +40,9 @@ Gem::Specification.new do |s|
   "lib/pork/more/bottomup_backtrace.rb",
   "lib/pork/more/color.rb",
   "lib/pork/more/should.rb",
+  "lib/pork/report.rb",
+  "lib/pork/report/description.rb",
+  "lib/pork/report/dot.rb",
   "lib/pork/stat.rb",
   "lib/pork/test.rb",
   "lib/pork/version.rb",
@@ -54,7 +58,7 @@ Gem::Specification.new do |s|
   "test/test_stat.rb"]
   s.homepage = "https://github.com/godfat/pork"
   s.licenses = ["Apache License 2.0"]
-  s.rubygems_version = "2.4.7"
+  s.rubygems_version = "2.4.8"
   s.summary = "Pork -- Simple and clean and modular testing library."
   s.test_files = [
   "test/test_bacon.rb",

data/test/test_pork_test.rb

@@ -2,8 +2,8 @@
 require 'pork/test'
 
 describe 'PORK_TEST=a' do
-  def verify line, executor, index, offset=0
-    path = executor[index][offset]
+  def verify line, executor, index
+    path = executor[index].first
     type, desc, block, opts = extract(path, executor)
     expect(type)                 .eq :would
     expect(desc)                 .eq 'find the corresponding test case'
@@ -23,17 +23,13 @@ describe 'PORK_TEST=a' do
     end
   end
 
-  def woulds
-    @woulds ||= Pork::Executor[__FILE__].select{ |p| p.kind_of?(Array) }
-  end
-
   would 'find the corresponding test case', :groups => [:a, :b] do
     line = __LINE__ - 1
-    [self.class, Pork::Executor].each.with_index do |executor, index|
+    [self.class, Pork::Executor].each do |executor|
       verify(line, executor, "#{__FILE__}:#{__LINE__}") # line
       verify(line, executor, 'a')                       # group
       verify(line, executor, "#{__FILE__}:#{__LINE__}") # diff line
-      verify(line, executor, __FILE__, index)           # file
+      verify(line, executor, __FILE__)                  # file
       # for self.class, would is the 1st, for Pork::Executor, would is 2nd
     end
   end
@@ -41,14 +37,14 @@ describe 'PORK_TEST=a' do
   describe 'PORK_TEST=b' do
     would 'find both', :groups => [:b] do
       line = __LINE__ - 1
-      Pork::Executor[__FILE__].size.should.eq 6 # 3 describe
-      woulds                  .size.should.eq 3
-      Pork::Executor['a']     .size.should.eq 1
-      Pork::Executor['b']     .size.should.eq 2
-      Pork::Executor['b']          .should.eq woulds.first(2)
-      Pork::Executor['a,b']        .should.eq woulds.first(2)
-      self.class['a']              .should.nil?
-      self.class['b']         .size.should.eq 1
+      woulds = Pork::Executor[__FILE__]
+      woulds               .size.should.eq 4
+      Pork::Executor['a']  .size.should.eq 1
+      Pork::Executor['b']  .size.should.eq 2
+      Pork::Executor['b']       .should.eq woulds.first(2)
+      Pork::Executor['a,b']     .should.eq woulds.first(2)
+      self.class['a']           .should.nil?
+      self.class['b']      .size.should.eq 1
 
       a, b = Pork::Executor['b'].map{ |path| extract(path, Pork::Executor) }
       expect(a[0])                .eq :would
@@ -65,9 +61,15 @@ describe 'PORK_TEST=a' do
     would 'inherit groups from describe', :groups => [:d] do
       line = __LINE__ - 2
       c = Pork::Executor['c']
-      expect(c.size )                              .eq 1
-      expect(c.first)                              .eq self.class
-      expect(Pork::Executor["#{__FILE__}:#{line}"]).eq [self.class]
+      d = Pork::Executor['d']
+      expect(c.size)                               .eq 2
+      expect(d.size)                               .eq 1
+      expect(c.first)                              .eq d.first
+      expect(Pork::Executor["#{__FILE__}:#{line}"]).eq c
+    end
+
+    would 'dummy' do
+      ok
     end
   end
 end

data/test/test_stat.rb

@@ -21,19 +21,21 @@ describe Pork::Stat do
   end
 
   def run check=:expect_one_error
-    @stat = @executor.execute(Pork.execute_mode, Pork::Stat.new(StringIO.new))
+    @stat = @executor.execute(
+      Pork.execute_mode,
+      Pork::Stat.new(Pork.report_class.new(StringIO.new)))
     send(check)
   end
 
   def expect_one_error
-    expect(@stat.io.string) .eq "\e[31mE\e[0m"
+    expect(@stat.reporter.io.string).eq "\e[31mE\e[0m"
     expect(@stat.tests)     .eq 1
     expect(@stat.assertions).eq 0
     expect(@stat.errors)    .eq 1
   end
 
   def expect_one_failure
-    expect(@stat.io.string) .eq "\e[35mF\e[0m"
+    expect(@stat.reporter.io.string).eq "\e[35mF\e[0m"
     expect(@stat.tests)     .eq 1
     expect(@stat.assertions).eq 0
     expect(@stat.failures)  .eq 1
@@ -46,7 +48,7 @@ describe Pork::Stat do
     err, _, test = @stat.exceptions.first
     err.set_backtrace([])
 
-    expect(@stat.send(:show_backtrace, test, err)).not.empty?
+    expect(@stat.reporter.send(:show_backtrace, test, err)).not.empty?
   end
 
   describe 'Pork::Stat#show_source' do
@@ -54,7 +56,7 @@ describe Pork::Stat do
       run(check)
       err, _, test = @stat.exceptions.first
       yield(err) if block_given?
-      expect(@stat.send(:show_source, test, err)).include?(source)
+      expect(@stat.reporter.send(:show_source, test, err)).include?(source)
     end
 
     would 'one line' do

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: pork
 version: !ruby/object:Gem::Version
-  version: 1.3.1
+  version: 1.4.0
 platform: ruby
 authors:
 - Lin Jen-Shin (godfat)
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-06-06 00:00:00.000000000 Z
+date: 2015-07-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: method_source
@@ -56,6 +56,7 @@ files:
 - lib/pork/extra/show_source.rb
 - lib/pork/imp.rb
 - lib/pork/inspect.rb
+- lib/pork/isolate.rb
 - lib/pork/mode/parallel.rb
 - lib/pork/mode/sequential.rb
 - lib/pork/mode/shuffled.rb
@@ -63,6 +64,9 @@ files:
 - lib/pork/more/bottomup_backtrace.rb
 - lib/pork/more/color.rb
 - lib/pork/more/should.rb
+- lib/pork/report.rb
+- lib/pork/report/description.rb
+- lib/pork/report/dot.rb
 - lib/pork/stat.rb
 - lib/pork/test.rb
 - lib/pork/version.rb
@@ -96,7 +100,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.7
+rubygems_version: 2.4.8
 signing_key: 
 specification_version: 4
 summary: Pork -- Simple and clean and modular testing library.