pork 1.2.4 → 1.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d777bebd67882252ec22825a62266878e8afb245
-  data.tar.gz: 5b59151244bdf671ca2c239b9eb503dd43eb04a4
+  metadata.gz: 4e51ae61ad2d2b0d608bdb753560c3cc2294cd1d
+  data.tar.gz: ca7c3abfecf2f801008cd1b9583abd4dcb8eaed4
 SHA512:
-  metadata.gz: 7345227bf8de435f9673db212c5d255dfd4ec2f11f73caa5cd9b2154d99491fe3e159c7d293e3e3b7c42d1696c935dab8c0279ccea4211e26b9a081d6763531a
-  data.tar.gz: 11175993f303c48a9984e0f967bb713b1a28c17c214badc2dc73cb98e1f8eada9d2a6ecdb14fc923121b9f01253b18da2cdf286c58c7fbbcba7701a3598af37d
+  metadata.gz: 0f03bec4e90ae00a3da243db950cf9874990c80fd0bdafc83f97e7e5f1770db8e1b4c3a80af77f70822214e88fadff79c11e056d521ef03c2dddf41222c9ae89
+  data.tar.gz: c79774e3e1d78c1ccc8f0ca5f5765b8ee632ab929d260f36353cafaffdb4289955e3bc81fec7e77b9fc7e2513091772612166d79787cc33743d8f8d409c83cf6

data/.travis.yml

@@ -6,6 +6,7 @@ rvm:
   - 2.2
   - rbx-2
   - jruby
+  - jruby-head
 
 install: 'bundle install --retry=3'
 script: 'ruby -r bundler/setup -S rake test'

data/CHANGES.md

@@ -1,5 +1,24 @@
 # CHANGES
 
+## Pork 1.3.0 -- 2015-05-24
+
+### Incompatible changes
+
+* `Pork.run` is renamed to `Pork.execute`,
+  and `Pork.run` would now do a full run.
+
+* `Pork::Executor.all_tests` would also include paths to describe blocks.
+
+### Enhancement
+
+* Now `describe` could also take a second argument to specify groups.
+* `PORK_TEST` could also accept a file path and line number pointing to a
+  describe block. Previously only would block would work.
+
+### Bugs fixed
+
+* `Pork.show_source` would never raise SyntaxError anymore.
+
 ## Pork 1.2.4 -- 2015-04-25
 
 ### Enhancement

data/README.md

@@ -801,28 +801,30 @@ run.
 #### `env PORK_TEST=` with `:groups`
 
 `PORK_TEST` could also take a list of groups. Groups are defined in the tests,
-as the second argument to `would`. Take this as an example:
+as the second argument to `describe` and `would`. Take this as an example:
 
 
 ``` ruby
-would 'pass', :groups => [:core, :more] do
-  ok
-end
+describe 'all', :groups => [:all] do
+  would 'pass', :groups => [:core, :more] do
+    ok
+  end
 
-would 'also pass', :groups => [:more] do
-  ok
+  would 'also pass', :groups => [:more] do
+    ok
+  end
 end
 ```
 
-Then if specifying `PORK_TEST=more`, then both tests would run. If specifying
-`PORK_TEST=core`, then only the first would run. We could also specifying
-multiple groups, separated with commas (,), like `PORK_TEST=core,more`,
-then of course both tests would run.
+Then if specifying `PORK_TEST=all`, or `PORK_TEST=more`, then both tests
+would run. If specifying `PORK_TEST=core`, then only the first would run.
+We could also specifying multiple groups, separated with commas (,), like
+`PORK_TEST=core,more`, then of course both tests would run.
 
 This would be very useful when you want to run a specific test case without
 typing the whole file path and finding the line number. Just edit your test
-source by adding some temporary group like `:groups => [:test]` and then
-run the test command prefixed by `env PORK_TEST=test` then you're done.
+source by adding some temporary group like `:groups => [:only]` and then
+run the test command prefixed by `env PORK_TEST=only` then you're done.
 You could just remove the group after debugging. This must be much easier to
 do then commenting out a bunch of random codes in the tests.
 

data/lib/pork.rb

@@ -47,30 +47,37 @@ module Pork
     end
   end
 
-  def self.run
+  def self.execute
     Random.srand(ENV['PORK_SEED'].to_i) if ENV['PORK_SEED']
     seed
     if ENV['PORK_TEST']
       require 'pork/mode/shuffled'
-      if paths = Executor[ENV['PORK_TEST']]
-        @stat = Executor.execute(Pork.execute_mode, stat, paths)
+      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
       else
         puts "Cannot find test: #{ENV['PORK_TEST']}"
         exit 254
       end
     else
-      @stat = Executor.execute(Pork.execute_mode, stat)
+      @stat = Executor.execute(execute_mode, stat)
     end
   end
 
+  def self.run
+    execute_mode(ENV['PORK_MODE'])
+    trap
+    execute
+    stat.report
+  end
+
   def self.autorun auto=true
     @auto = auto
     @autorun ||= at_exit do
       next unless @auto
-      execute_mode(ENV['PORK_MODE'])
-      trap
       run
-      stat.report
       exit stat.failures + stat.errors + ($! && 1).to_i
     end
   end

data/lib/pork/extra/show_source.rb

@@ -28,6 +28,8 @@ module Pork
         end
       end.join
       "\n#{result.chomp}"
+    rescue SyntaxError => e
+      "\nPork bug: Cannot parse the source. Please report: #{e}"
     end
   end
 end

data/lib/pork/imp.rb

@@ -18,14 +18,14 @@ module Pork
       module_exec(*args, &search_stash(desc))
     end
 
-    def describe desc=:default, &suite
+    def describe desc=:default, opts={}, &suite
       executor = Class.new(self){ init("#{desc}: ") }
       executor.module_eval(&suite)
-      @tests << [:describe, executor]
+      @tests << [:describe, executor, suite || lambda{}, opts]
     end
 
     def would desc=:default, opts={}, &test
-      @tests << [:would, desc, test || lambda{}, opts]
+      @tests << [:would   , desc    , test  || lambda{}, opts]
     end
 
     def execute mode, *args

data/lib/pork/mode/shuffled.rb

@@ -8,7 +8,8 @@ module Pork
     end
 
     def all_paths
-      (all_tests[:files] || {}).values.flat_map(&:values).flatten(1)
+      (all_tests[:files] || {}).values.flat_map(&:values).flatten(1).
+        select{ |path| path.kind_of?(Array) }
     end
 
     def [] index
@@ -69,28 +70,32 @@ module Pork
                                                 ((type, imp, test, opts),
                                                   index)|
         current = path + [index]
-        case type
-        when :describe
-          imp.build_all_tests(r, current)
-        when :would
-          groups = opts[:groups]
-          store_for_groups(r, current, groups) if groups
-          store_for_source(r, current, *test.source_location)
-        end
+        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, groups
+    def store_for_groups tests, path_or_imp, groups
       r = tests[:groups] ||= {}
       groups.each do |g|
-        (r[g.to_s] ||= []) << path
+        (r[g.to_s] ||= []) << path_or_imp
       end
     end
 
-    def store_for_source tests, path, file, line
+    def store_for_source tests, path_or_imp, file, line
       r = tests[:files] ||= {}
-      ((r[File.expand_path(file)] ||= {})[line] ||= []) << path
+      ((r[File.expand_path(file)] ||= {})[line] ||= []) << path_or_imp
     end
   end
 

data/lib/pork/test.rb

@@ -8,10 +8,10 @@ at_exit do
   Pork.module_eval do
     execute_mode(ENV['PORK_MODE'])
     trap
-    run
+    execute
     %w[sequential shuffled parallel].each do |mode|
       execute_mode(mode)
-      run
+      execute
     end
     stat.report
     exit stat.failures + stat.errors + ($! && 1).to_i

data/lib/pork/version.rb

@@ -1,4 +1,4 @@
 
 module Pork
-  VERSION = '1.2.4'
+  VERSION = '1.3.0'
 end

data/pork.gemspec

@@ -1,14 +1,14 @@
 # -*- encoding: utf-8 -*-
-# stub: pork 1.2.4 ruby lib
+# stub: pork 1.3.0 ruby lib
 
 Gem::Specification.new do |s|
   s.name = "pork"
-  s.version = "1.2.4"
+  s.version = "1.3.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-04-25"
+  s.date = "2015-05-24"
   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 = [
@@ -54,7 +54,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.6"
+  s.rubygems_version = "2.4.7"
   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
-    path = executor[index].first
+  def verify line, executor, index, offset=0
+    path = executor[index][offset]
     type, desc, block, opts = extract(path, executor)
     expect(type)                 .eq :would
     expect(desc)                 .eq 'find the corresponding test case'
@@ -23,24 +23,30 @@ 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 do |executor|
+    [self.class, Pork::Executor].each.with_index do |executor, index|
       verify(line, executor, "#{__FILE__}:#{__LINE__}") # line
       verify(line, executor, 'a')                       # group
       verify(line, executor, "#{__FILE__}:#{__LINE__}") # diff line
-      verify(line, executor, __FILE__)                  # file
+      verify(line, executor, __FILE__, index)           # file
+      # for self.class, would is the 1st, for Pork::Executor, would is 2nd
     end
   end
 
   describe 'PORK_TEST=b' do
     would 'find both', :groups => [:b] do
       line = __LINE__ - 1
-      Pork::Executor[__FILE__].size.should.eq 2
+      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 Pork::Executor[__FILE__]
-      Pork::Executor['a,b']        .should.eq Pork::Executor[__FILE__]
+      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
 
@@ -54,4 +60,14 @@ describe 'PORK_TEST=a' do
       expect(b[3])                .eq :groups => [:b]
     end
   end
+
+  describe 'PORK_TEST=c', :groups => [:c] 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]
+    end
+  end
 end

data/test/test_stat.rb

@@ -7,9 +7,22 @@ describe Pork::Stat do
     @executor = Class.new(Pork::Executor){init}
   end
 
-  def run
+  def skip_if_backtrace_is_wrong
+    0.should == {
+    }
+  rescue Pork::Failure => e
+    skip unless e.respond_to?(:backtrace_locations)
+    File.open(__FILE__) do |f|
+      line = e.backtrace_locations.find{ |l|
+               l.label.include?('skip_if_backtrace_is_wrong')
+             }.lineno.times.inject(''){ f.readline }
+      skip if line.include?('}')
+    end
+  end
+
+  def run check=:expect_one_error
     @stat = @executor.execute(Pork.execute_mode, Pork::Stat.new(StringIO.new))
-    expect_one_error
+    send(check)
   end
 
   def expect_one_error
@@ -19,6 +32,13 @@ describe Pork::Stat do
     expect(@stat.errors)    .eq 1
   end
 
+  def expect_one_failure
+    expect(@stat.io.string) .eq "\e[35mF\e[0m"
+    expect(@stat.tests)     .eq 1
+    expect(@stat.assertions).eq 0
+    expect(@stat.failures)  .eq 1
+  end
+
   would 'always have backtrace' do
     @executor.would
     run
@@ -30,8 +50,8 @@ describe Pork::Stat do
   end
 
   describe 'Pork::Stat#show_source' do
-    def verify source
-      run
+    def verify source, check=:expect_one_error
+      run(check)
       err, _, test = @stat.exceptions.first
       yield(err) if block_given?
       expect(@stat.send(:show_source, test, err)).include?(source)
@@ -66,6 +86,24 @@ describe Pork::Stat do
       SOURCE
     end
 
+    would 'multiple lines with == {}' do
+      skip_if_backtrace_is_wrong
+      @executor.would do
+        0.should == {
+
+
+        }
+      end
+      verify(<<-SOURCE.chomp, :expect_one_failure)
+     @executor.would do
+\e[41m  =>   0.should == {\e[0m
+\e[41m  => \e[0m
+\e[41m  => \e[0m
+\e[41m  =>   }\e[0m
+     end
+      SOURCE
+    end
+
     would 'show the line in the test, not other methods' do
       @executor.send(:define_method, :f){ flunk }
       @executor.would do

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: pork
 version: !ruby/object:Gem::Version
-  version: 1.2.4
+  version: 1.3.0
 platform: ruby
 authors:
 - Lin Jen-Shin (godfat)
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-04-25 00:00:00.000000000 Z
+date: 2015-05-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: method_source
@@ -96,7 +96,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.6
+rubygems_version: 2.4.7
 signing_key: 
 specification_version: 4
 summary: Pork -- Simple and clean and modular testing library.