pork 1.2.2 → 1.2.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c261975cc7cf0b2bcacb506cc04b3e1c088ea9b5
-  data.tar.gz: 0aeb04d6e629d99461713681d2b611863c97f582
+  metadata.gz: 095bec1d9b0e5589ead858fce38929b381210569
+  data.tar.gz: a311efe4b88dd95d9d3121092ebd716227d6e207
 SHA512:
-  metadata.gz: 72a8a67eb1423fd9faa19a4d7eec5ec336ee9ce2b9fd261ba2329c8bf28de762ffbf6b5013d547c07a27880654ac9819402816bd435881f9512280dfcedca966
-  data.tar.gz: 32b9c1379c816168dcde3f84148793516ed85f477cebb50ea95bdbe2807c8a38f94490bb980e3d69b73750dc665e52350332446bcd977c4819bfdf4d8ed21b09
+  metadata.gz: d580f3bb350761f874bfa061d554cb0d7c2f8a4fd74ac6fe90465c9c06100f89fba3186d452751f8a28bd72ebc4a7727ec0862b0523727cdf463f701531378d1
+  data.tar.gz: af26e6604565d1b9041b30f0a993cae03c58ac4bcf515f376eb0bdaa187c3d5b3da0b6e683b49a82daae58d8a64fe36b5edb646cf366e618744a0715af17f402

data/CHANGES.md

@@ -1,5 +1,15 @@
 # CHANGES
 
+## Pork 1.2.3 -- 2015-04-16
+
+### Enhancement
+
+* Now `would` could take a second argument with `:group => [:name]`,
+  and you could also specifying the groups to run in `PORK_TEST`.
+  Checkout README for more information. Input from @mz026
+
+* `PORK_TEST` could also accept a file path without a line number now.
+
 ## Pork 1.2.2 -- 2015-03-19
 
 ### Enhancement

data/README.md

@@ -361,16 +361,6 @@ run `rake test` to run all the tests.
 [Fish shell]: http://fishshell.com/
 [gemgem]: https://github.com/godfat/gemgem
 
-## Mutant integration
-
-Pork also ships with [mutant][] integration. Here's an example to run it:
-
-    mutant -Ilib -rjellyfish --use pork Jellyfish
-
-for [jellyfish][].
-
-[jellyfish]: https://github.com/godfat/jellyfish
-
 ## The API
 
 ### Kernel#should
@@ -764,23 +754,80 @@ describe do
 end
 ```
 
-### Pork.autorun
+## The Options
 
-Calling this would register an `at_exit` hook to run tests at exit.
-This also accepts an argument to turn on and off autorun. Calling this
-multiple times is ok. (It's not thread safe though, don't call this twice
-from different threads at the same time. If you really want to do this,
-let's add a mutex for this)
+### `env PORK_TEST=`
+
+As the code base grows, at some point running the whole test suites could be
+very slow and frustrating while doing agile development. In this case, we
+might want to run only a subset of the whole test suites. Granted that we
+could already divide the tests into files, and only load one file and run
+tests inside the file. But if the tests are just slow, we might still want to
+run only a specific test case. This is where `env PORK_TEST=` shines.
+
+Suppose you run the tests via:
+
+``` shell
+ruby -Ilib test/test_pork.rb
+```
+
+Then you could do:
+
+``` shell
+env PORK_TEST=test/test_pork.rb:123 ruby -Ilib test/test_pork.rb
+```
+
+So that it would only run the test case around test_pork.rb line 123.
+If you run the tests via:
+
+``` shell
+rake test
+```
+
+Then you could do:
+
+``` shell
+env PORK_TEST=test/test_pork.rb:123 rake test
+```
+
+It's the same thing just that `rake test` might load more tests which would
+never run. Note that if you omit the line number, then the whole file would
+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:
 
-It would also exit with 0 if no error occurs or N for N errors and failures.
 
 ``` ruby
-Pork.autorun        # enable
-Pork.autorun(false) # disable
-Pork.autorun(true)  # enable
+would 'pass', :groups => [:core, :more] do
+  ok
+end
+
+would 'also pass', :groups => [:more] do
+  ok
+end
 ```
 
-`require 'pork/auto'` would call `Pork.autorun`
+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.
+
+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.
+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.
+
+Summary by examples:
+
+* `env PORK_TEST='test/test_pork.rb:123' rake test`
+* `env PORK_TEST='test/test_pork.rb' rake test`
+* `env PORK_TEST='group0' rake test`
+* `env PORK_TEST='group0,group1' rake test`
 
 ### Pork.execute_mode
 
@@ -866,6 +913,24 @@ Pork.inspect_failure_mode :newline
 
 Then it would always use the mode we specified.
 
+### Pork.autorun
+
+Calling this would register an `at_exit` hook to run tests at exit.
+This also accepts an argument to turn on and off autorun. Calling this
+multiple times is ok. (It's not thread safe though, don't call this twice
+from different threads at the same time. If you really want to do this,
+let's add a mutex for this)
+
+It would also exit with 0 if no error occurs or N for N errors and failures.
+
+``` ruby
+Pork.autorun        # enable
+Pork.autorun(false) # disable
+Pork.autorun(true)  # enable
+```
+
+`require 'pork/auto'` would call `Pork.autorun`
+
 ### Pork.Rainbows!
 
 Have you seen Rainbows!?

data/lib/pork/imp.rb

@@ -24,8 +24,8 @@ module Pork
       @tests << [:describe, executor]
     end
 
-    def would desc=:default, &test
-      @tests << [:would, desc, test]
+    def would desc=:default, opts={}, &test
+      @tests << [:would, desc, test, opts]
     end
 
     def execute mode, *args

data/lib/pork/mode/shuffled.rb

@@ -8,15 +8,32 @@ module Pork
     end
 
     def all_paths
-      all_tests.values.flat_map(&:values).flatten(1)
+      (all_tests[:files] || {}).values.flat_map(&:values).flatten(1)
     end
 
-    def [] source_location
-      file_str, line_str = source_location.split(':')
+    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 tests = all_tests[file]
-      _, paths = tests.reverse_each.find{ |(l, _)| l <= line }
-      paths
+      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
@@ -48,18 +65,33 @@ module Pork
     end
 
     def build_all_tests result={}, path=[]
-      @tests.each_with_index.inject(result) do |r, ((type, arg, test), index)|
+      @tests.each_with_index.inject(result) do |r,
+                                                ((type, imp, test, opts),
+                                                  index)|
         current = path + [index]
         case type
         when :describe
-          arg.build_all_tests(r, current)
+          imp.build_all_tests(r, current)
         when :would
-          file, line = test.source_location
-          ((r[File.expand_path(file)] ||= {})[line] ||= []) << current
+          groups = opts[:groups]
+          store_for_groups(r, current, groups) if groups
+          store_for_source(r, current, *test.source_location)
         end
         r
       end
     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(Shuffled)

data/lib/pork/version.rb

@@ -1,4 +1,4 @@
 
 module Pork
-  VERSION = '1.2.2'
+  VERSION = '1.2.3'
 end

data/pork.gemspec

@@ -1,14 +1,14 @@
 # -*- encoding: utf-8 -*-
-# stub: pork 1.2.2 ruby lib
+# stub: pork 1.2.3 ruby lib
 
 Gem::Specification.new do |s|
   s.name = "pork"
-  s.version = "1.2.2"
+  s.version = "1.2.3"
 
   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-03-19"
+  s.date = "2015-04-16"
   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 = [
@@ -47,6 +47,7 @@ Gem::Specification.new do |s|
   "test/test_bacon.rb",
   "test/test_inspect.rb",
   "test/test_nested.rb",
+  "test/test_pork_test.rb",
   "test/test_readme.rb",
   "test/test_should.rb"]
   s.homepage = "https://github.com/godfat/pork"
@@ -57,6 +58,7 @@ Gem::Specification.new do |s|
   "test/test_bacon.rb",
   "test/test_inspect.rb",
   "test/test_nested.rb",
+  "test/test_pork_test.rb",
   "test/test_readme.rb",
   "test/test_should.rb"]
 

data/test/test_pork_test.rb

@@ -0,0 +1,57 @@
+
+require 'pork/test'
+
+describe 'PORK_TEST=a' do
+  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'
+    expect(block.source_location).eq [__FILE__, line]
+    expect(opts)                 .eq :groups => [:a, :b]
+  end
+
+  def extract path, executor
+    path.inject(executor.instance_variable_get(:@tests)) do |tests, idx|
+      type, arg, = tests[idx]
+      case type
+      when :describe # we need to go deeper
+        arg.instance_variable_get(:@tests)
+      else
+        tests[idx] # should end here
+      end
+    end
+  end
+
+  would 'find the corresponding test case', :groups => [:a, :b] do
+    line = __LINE__ - 1
+    [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__)                  # file
+    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['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__]
+      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
+      expect(a[1])                .eq 'find the corresponding test case'
+      expect(a[3])                .eq :groups => [:a, :b]
+      expect(b[0])                .eq :would
+      expect(b[1])                .eq 'find both'
+      expect(b[2].source_location).eq [__FILE__, line]
+      expect(b[3])                .eq :groups => [:b]
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: pork
 version: !ruby/object:Gem::Version
-  version: 1.2.2
+  version: 1.2.3
 platform: ruby
 authors:
 - Lin Jen-Shin (godfat)
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-03-19 00:00:00.000000000 Z
+date: 2015-04-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: muack
@@ -71,6 +71,7 @@ files:
 - test/test_bacon.rb
 - test/test_inspect.rb
 - test/test_nested.rb
+- test/test_pork_test.rb
 - test/test_readme.rb
 - test/test_should.rb
 homepage: https://github.com/godfat/pork
@@ -101,5 +102,6 @@ test_files:
 - test/test_bacon.rb
 - test/test_inspect.rb
 - test/test_nested.rb
+- test/test_pork_test.rb
 - test/test_readme.rb
 - test/test_should.rb