pork 0.9.0 → 0.9.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 0720abd3578e820759c2cec35d565a41e41d6f79
-  data.tar.gz: 3abb0dc9d216004aa1fa11590fef142671111168
+  metadata.gz: 885c569da2496923eeac8a765bb713a38d882e79
+  data.tar.gz: 0e9fb16d8d4b9de93177ea86da953639c7500e22
 SHA512:
-  metadata.gz: 6387d2c2049e7bbab044bcfba005616e3a236b9f58f2303c06fbd6b47613ee277c8219f098b49671e5011f94c3dab80aa449ffa8effb139da8885a1fc138355f
-  data.tar.gz: e4e2189fc58eede08bdcf3d65580ef1728474728fce82db3dae57f5ab013b6611b4385b5b16700ab54feba4b97e9cd1ed18470ea05ad633622f78222bdbc09a4
+  metadata.gz: 66d37601b58be4a81c6c1e41fa4bde8c55d8a7ac827d43acf18ffae90babac1894dc0cb90c21d3edafb6c042a4c20bd81d1a992267b6655a9e8d92376ca9d819
+  data.tar.gz: 68ecfbbf3939cf7adeb1662dbcb826c5845a6e147d1dea0bcc348f1582593c8e01e43bda5fd20423446b47865b3a6720d21b21a1c549f5cf8b91fe534ddb2c75

data/.travis.yml

@@ -1,9 +1,11 @@
-before_install: 'git submodule update --init'
-script: 'ruby -r bundler/setup -S rake test'
 
+language: ruby
 rvm:
   - 1.9.3
   - 2.0.0
   - ruby
   - rbx-2
   - jruby
+
+script: 'ruby -r bundler/setup -S rake test'
+sudo: false

data/CHANGES.md

@@ -1,5 +1,21 @@
 # CHANGES
 
+## Pork 0.9.1 -- 2014-07-14
+
+### Bugs fixed
+
+* It would now properly `exit(1)` when there's an error.
+* It would now properly search the stashes chain upon `paste`.
+
+
+### Enhancement
+
+* `Kernel#should` now accepts a second argument for building messages lazily.
+* `Should#satisfy` now accepts a second argument for building messages lazily.
+* Introduced `Pork.inspect_failure_mode` to switch failure display mode.
+* Default `Pork.inspect_failure_mode` to `:auto`, which would display failures
+  accordingly.
+
 ## Pork 0.9.0 -- 2014-07-11
 
 * First serious release! Bunch of updates. Nearly complete.

data/README.md

@@ -274,6 +274,196 @@ end
 
 ## The API
 
+### Kernel#should
+
+All the assertions begin with `should`. Whenever we called `should` on an
+object, it would create an `Pork::Should` object which would verify the
+assertion we make. For the simplest case, this verifies if `1 == 1`:
+
+``` ruby
+require 'pork/auto'
+
+would{ 1.should.eq 1 }
+```
+
+Sometimes we would also want to have a customized message if the assertion
+failed, as in `assert_equal 1, 1, 'the message'`, we pass the message as the
+first argument to should.
+
+``` ruby
+require 'pork/auto'
+
+would{ 1.should('verify one equals to one').eq 1 }
+```
+
+In a rare case, constructing the message could be expensive, so we might not
+want to build the message if the assertion passed. Then we pass the second
+argument as the constructor of the message.
+
+``` ruby
+require 'pork/auto'
+
+would{ 1.should(nil, lambda{'verify one equals to one'}).eq 1 }
+```
+
+Other than built in assertions such as `eq`, all methods in the questioning
+object are available. For example, for arrays we could use `empty?`,
+`include?` and `[]`.
+
+``` ruby
+describe Array do
+  would 'have array methods as verifiers' do
+    [ ].should.empty?
+    [1].should.include? 1
+    [1].should[0]
+  end
+end
+```
+
+The assertions would only fail whenever the result was `false` or `nil`,
+otherwise pass.
+
+### Pork::Should#satisfy
+
+If we want to have custom verifier other than the methods from questioning
+object, this is it.
+
+``` ruby
+require 'pork/auto'
+
+describe do
+  divided_by_2 = lambda{ |n| n % 2 == 0 }
+
+  would do
+    2.should.satisfy(&divided_by_2)
+  end
+end
+```
+
+The message argument applies to `should` also applies to `satisfy`.
+
+``` ruby
+require 'pork/auto'
+
+describe do
+  divided_by_2 = lambda{ |n| n % 2 == 0 }
+
+  would do
+    2.should.satisfy('be divided by two', &divided_by_2)
+    2.should.satisfy(nil, lambda{'be divided by two'}, &divided_by_2)
+  end
+end
+```
+
+### Pork::Should#not
+
+An easy way to negate the expectation.
+
+``` ruby
+require 'pork/auto'
+
+would{ 1.should.not.eq 2 }
+```
+
+### Pork::Should#eq
+
+To avoid warnings from Ruby, using `eq` instead of `==`. It's fine if you
+still prefer using `==` if you don't care about warnings.
+
+``` ruby
+require 'pork/auto'
+
+would{ 1.should.eq 1 }
+```
+
+### Pork::Should#lt
+
+To avoid warnings from Ruby, using `lt` instead of `<`. It's fine if you
+still prefer using `<` if you don't care about warnings.
+
+``` ruby
+require 'pork/auto'
+
+would{ 1.should.lt 2 }
+```
+
+### Pork::Should#gt
+
+To avoid warnings from Ruby, using `gt` instead of `>`. It's fine if you
+still prefer using `>` if you don't care about warnings.
+
+``` ruby
+require 'pork/auto'
+
+would{ 1.should.gt 0 }
+```
+
+### Pork::Should#lte
+
+To avoid warnings from Ruby, using `lte` instead of `<=`. It's fine if you
+still prefer using `<=` if you don't care about warnings.
+
+``` ruby
+require 'pork/auto'
+
+would{ 1.should.lte 1 }
+```
+
+### Pork::Should#gte
+
+To avoid warnings from Ruby, using `gte` instead of `>=`. It's fine if you
+still prefer using `>=` if you don't care about warnings.
+
+``` ruby
+require 'pork/auto'
+
+would{ 1.should.gte 1 }
+```
+
+### Pork::Should#raise
+
+Expect for exceptions! There are two ways to call it. Either you could use
+lambda to wrap the questioning expression, or you could simply pass a block
+as the questioning expression.
+
+``` ruby
+require 'pork/auto'
+
+describe 'Pork::Should#raise' do
+  would 'check with a block' do
+    e = should.raise(RuntimeError){ raise "nnf" }
+    e.should.message.include?("nnf")
+  end
+
+  would 'check with a lambda' do
+    e = lambda{ raise "nnf" }.should.raise(RuntimeError)
+    e.should.message.include?("nnf")
+  end
+end
+```
+
+### Pork::Should#throw
+
+Expect for something to be thrown. There are two ways to call it. Either
+you could use lambda to wrap the questioning expression, or you could
+simply pass a block as the questioning expression.
+
+``` ruby
+require 'pork/auto'
+
+describe 'Pork::Should#throw' do
+  would 'check with a block' do
+    e = should.throw(:nnf){ throw :nnf, 0 }
+    e.should.eq [:nnf, 0]
+  end
+
+  would 'check with a lambda' do
+    e = lambda{ throw :nnf, 1 }.should.throw(:nnf)
+    e.should.eq [:nnf, 1]
+  end
+end
+```
+
 ### Pork::API.describe
 
 So this creates a test suite which should be containing various test cases
@@ -457,131 +647,6 @@ describe do
 end
 ```
 
-### Pork::Should#satisfy
-
-If we want to have custom verifier, that is it.
-
-``` ruby
-require 'pork/auto'
-
-describe do
-  divided_by_2 = lambda{ |n| n % 2 == 0 }
-
-  would do
-    2.should.satisfy(&divided_by_2)
-  end
-end
-```
-
-### Pork::Should#not
-
-An easy way to negate the expectation.
-
-``` ruby
-require 'pork/auto'
-
-would{ 1.should.not.eq 2 }
-```
-
-### Pork::Should#eq
-
-To avoid warnings from Ruby, using `eq` instead of `==`. It's fine if you
-still prefer using `==` if you don't care about warnings.
-
-``` ruby
-require 'pork/auto'
-
-would{ 1.should.eq 1 }
-```
-
-### Pork::Should#lt
-
-To avoid warnings from Ruby, using `lt` instead of `<`. It's fine if you
-still prefer using `<` if you don't care about warnings.
-
-``` ruby
-require 'pork/auto'
-
-would{ 1.should.lt 2 }
-```
-
-### Pork::Should#gt
-
-To avoid warnings from Ruby, using `gt` instead of `>`. It's fine if you
-still prefer using `>` if you don't care about warnings.
-
-``` ruby
-require 'pork/auto'
-
-would{ 1.should.gt 0 }
-```
-
-### Pork::Should#lte
-
-To avoid warnings from Ruby, using `lte` instead of `<=`. It's fine if you
-still prefer using `<=` if you don't care about warnings.
-
-``` ruby
-require 'pork/auto'
-
-would{ 1.should.lte 1 }
-```
-
-### Pork::Should#gte
-
-To avoid warnings from Ruby, using `gte` instead of `>=`. It's fine if you
-still prefer using `>=` if you don't care about warnings.
-
-``` ruby
-require 'pork/auto'
-
-would{ 1.should.gte 1 }
-```
-
-### Pork::Should#raise
-
-Expect for exceptions! There are two ways to call it. Either you could use
-lambda to wrap the questioning expression, or you could simply pass a block
-as the questioning expression.
-
-``` ruby
-require 'pork/auto'
-
-describe 'Pork::Should#raise' do
-  would 'check with a block' do
-    e = should.raise(RuntimeError){ raise "nnf" }
-    e.should.message.include?("nnf")
-  end
-
-  would 'check with a lambda' do
-    e = lambda{ raise "nnf" }.should.raise(RuntimeError)
-    e.should.message.include?("nnf")
-  end
-end
-```
-
-### Pork::Should#throw
-
-Expect for something to be thrown. There are two ways to call it. Either
-you could use lambda to wrap the questioning expression, or you could
-simply pass a block as the questioning expression.
-
-``` ruby
-require 'pork/auto'
-
-describe 'Pork::Should#throw' do
-  would 'check with a block' do
-    e = should.throw(:nnf){ throw :nnf, 0 }
-    e.should.eq [:nnf, 0]
-  end
-
-  would 'check with a lambda' do
-    e = lambda{ throw :nnf, 1 }.should.throw(:nnf)
-    e.should.eq [:nnf, 1]
-  end
-end
-```
-
 ### Pork.report
 
 Report the summary from the tests. Usually you would want to call this at
@@ -606,9 +671,38 @@ extend Pork::API
 Pork.report_at_exit
 ```
 
+### Pork.inspect_failure_mode
+
+By default, `Pork.inspect_failure_mode` is set to `:auto`, which would
+display failures accordingly. For example, if the message is short, it would
+simply show the message. But if the message is long, it would try to insert
+a newline between actual result and expected result, since it would be much
+easier for human to distinguish the difference this way. If the message is
+really long, it would even use `diff` to show the difference.
+
+This is because if the actual string is long, it would be quite painful to
+find the actual difference for human without assistance.
+
+However, this might not really be desired at times. So we should be able to
+switch between each mode. For now, we have the following modes:
+
+* :auto (default)
+* :inline
+* :newline
+* :diff
+
+If we want to force to a specific mode, here's how we would do:
+
+``` ruby
+Pork.inspect_failure_mode :newline
+```
+
+Then it would always use the mode we specified.
+
 ## CONTRIBUTORS:
 
 * Lin Jen-Shin (@godfat)
+* Josh Kalderimis (@joshk)
 
 ## LICENSE:
 

data/lib/pork.rb

@@ -2,8 +2,8 @@
 require 'thread'
 
 module Kernel
-  def should message=nil, &checker
-    Pork::Should.new(self, message, &checker)
+  def should message=nil, message_lazy=nil, &checker
+    Pork::Should.new(self, message, message_lazy, &checker)
   end
 end
 
@@ -19,7 +19,55 @@ module Pork
     Pork.stats.start
     @report_at_exit ||= at_exit do
       stats.report
-      exit stats.failures.size + stats.errors.size
+      exit stats.failures.size + stats.errors.size + ($! && 1).to_i
+    end
+  end
+  # default to :auto while eliminating warnings for uninitialized ivar
+  def self.inspect_failure_mode mode=nil; @mode = mode || @mode ||= :auto; end
+  def self.inspect_failure *args
+    lambda{ public_send("inspect_failure_#{inspect_failure_mode}", *args) }
+  end
+
+  def self.inspect_failure_auto object, msg, args, negate
+    if args.size > 1
+      inspect_failure_inline(object, msg, args, negate)
+    elsif object.kind_of?(Hash) && args.first.kind_of?(Hash)
+      inspect_failure_inline(Hash[object.sort], msg,
+                             [Hash[args.first.sort]], negate)
+    elsif object.kind_of?(String) && object.size > 400 &&
+          object.count("\n") > 4 && !`which diff`.empty?
+      inspect_failure_diff(object, msg, args, negate)
+    else
+      ins = object.inspect
+      if ins.size > 78
+        inspect_failure_newline(object, msg, args, negate)
+      else
+        inspect_failure_inline( object, msg, args, negate)
+      end
+    end
+  end
+
+  def self.inspect_failure_inline object, msg, args, negate
+    a = args.map(&:inspect).join(', ')
+    "#{object.inspect}.#{msg}(#{a}) to return #{!negate}"
+  end
+
+  def self.inspect_failure_newline object, msg, args, negate
+    a = args.map(&:inspect).join(",\n")
+    "\n#{object.inspect}.#{msg}(\n#{a}) to return #{!negate}"
+  end
+
+  def self.inspect_failure_diff object, msg, args, negate
+    require 'tempfile'
+    Tempfile.open('pork-expect') do |expect|
+      Tempfile.open('pork-was') do |was|
+        expect.puts(object.to_s)
+        expect.close
+        was.puts(args.map(&:to_s).join(",\n"))
+        was.close
+        name = "#{object.class}##{msg}(\n"
+        "#{name}#{`diff #{expect.path} #{was.path}`}) to return #{!negate}"
+      end
     end
   end
 
@@ -46,8 +94,7 @@ module Pork
     end
     def copy  desc=:default, &suite; stash[desc] = suite; end
     def paste desc=:default, *args
-      stashes = [self, super_executor].compact.map(&:stash)
-      module_exec(*args, &stashes.find{ |s| s[desc] }[desc])
+      module_exec(*args, &search_stash(desc))
     end
     def would desc=:default, &test
       assertions = Pork.stats.assertions
@@ -74,21 +121,22 @@ module Pork
     end
 
     protected
-    def init desc=''
-      @desc, @before, @after, @stash = desc, [], [], {}
-    end
+    def init desc=''; @desc, @before, @after, @stash = desc, [], [], {}; end
     def super_executor
       @super_executor ||= ancestors[1..-1].find{ |a| a <= Executor }
     end
+    def search_stash desc
+      stash[desc] or super_executor && super_executor.search_stash(desc)
+    end
     def description_for name=''
       "#{desc}#{super_executor && super_executor.description_for}#{name}"
     end
     def run_before context
-      super_executor.run_before(context) if super_executor
+      super_executor && super_executor.run_before(context)
       before.each{ |b| context.instance_eval(&b) }
     end
     def run_after context
-      super_executor.run_after(context) if super_executor
+      super_executor && super_executor.run_after(context)
       after.each{ |b| context.instance_eval(&b) }
     end
   end
@@ -101,58 +149,26 @@ module Pork
     def ok                    ; Pork.stats.incr_assertions        ; end
   end
 
-  module InspectInlineError
-    def inspect_error object, msg, args, negate
-      a = args.map(&:inspect).join(', ')
-      "#{object.inspect}.#{msg}(#{a}) to return #{!negate}"
-    end
-  end
-
-  module InspectNewlineError
-    def inspect_error object, msg, args, negate
-      a = args.map(&:inspect).join(', ')
-      "\n#{object.inspect}.#{msg}(\n#{a}) to return #{!negate}"
-    end
-  end
-
-  module InspectDiffError
-    def inspect_error object, msg, args, negate
-      ::Kernel.require 'tempfile'
-      ::Tempfile.open('pork-expect') do |expect|
-        ::Tempfile.open('pork-was') do |was|
-          expect.puts(object.to_s)
-          expect.close
-          was.puts(args.map(&:to_s).join(",\n"))
-          was.close
-          name = "#{object.class}##{msg}(\n"
-          diff = ::Kernel.__send__(:`, "diff #{expect.path} #{was.path}")
-          "#{name}#{diff}) to return #{!negate}"
-        end
-      end
-    end
-  end
-
   class Should < BasicObject
     instance_methods.each{ |m| undef_method(m) unless m =~ /^__|^object_id$/ }
-    include ::Pork::InspectInlineError
-
-    def initialize object, message, &checker
-      @object = object
-      @negate = false
-      @message = message
+    def initialize object, message=nil, message_lazy=nil, &checker
+      @object, @negate = object, false
+      @message, @message_lazy = message, message_lazy
       satisfy(&checker) if checker
     end
 
     def method_missing msg, *args, &block
-      satisfy(inspect_error(@object, msg, args, @negate)) do
+      satisfy(nil, ::Pork.inspect_failure(@object, msg, args, @negate)) do
         @object.public_send(msg, *args, &block)
       end
     end
 
-    def satisfy desc=@object
+    def satisfy desc=@object, desc_lazy=nil
       result = yield(@object)
       if !!result == @negate
-        ::Kernel.raise Failure.new("Expect #{desc}\n#{@message}".chomp)
+        d =     desc_lazy &&     desc_lazy.call || desc
+        m = @message_lazy && @message_lazy.call || @message
+        ::Kernel.raise Failure.new("Expect #{d}\n#{m}".chomp)
       else
         ::Pork.stats.incr_assertions
       end
@@ -195,13 +211,7 @@ module Pork
     end
 
     private
-    def __not__
-      if @negate == true
-        'not '
-      else
-        ''
-      end
-    end
+    def __not__; if @negate == true then 'not ' else '' end; end
   end
 
   class Stats < Struct.new(:tests, :assertions, :skips, :failures, :errors)
@@ -214,12 +224,8 @@ module Pork
     def incr_skips     ; @mutex.synchronize{ self.skips += 1; print('s')}; end
     def add_failure *e ; @mutex.synchronize{ failures << e; print('F')}; end
     def add_error   *e ; @mutex.synchronize{ errors   << e; print('E')}; end
-    def numbers
-      [tests, assertions, failures.size, errors.size, skips]
-    end
-    def start
-      @start ||= Time.now
-    end
+    def numbers; [tests, assertions, failures.size, errors.size, skips]; end
+    def start  ; @start ||= Time.now                                   ; end
     def report
       puts
       puts (failures + errors).map{ |(e, m)|

data/lib/pork/version.rb

@@ -1,4 +1,4 @@
 
 module Pork
-  VERSION = '0.9.0'
+  VERSION = '0.9.1'
 end

data/pork.gemspec

@@ -1,14 +1,14 @@
 # -*- encoding: utf-8 -*-
-# stub: pork 0.9.0 ruby lib
+# stub: pork 0.9.1 ruby lib
 
 Gem::Specification.new do |s|
   s.name = "pork"
-  s.version = "0.9.0"
+  s.version = "0.9.1"
 
   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 = "2014-07-11"
+  s.date = "2014-07-14"
   s.description = "Pork -- Simple and clean and modular testing library.\n\n[Bacon][] reimplemented around 250 lines of code.\n\n[Bacon]: https://github.com/chneukirchen/bacon"
   s.email = ["godfat (XD) godfat.org"]
   s.files = [

data/test/test_bacon.rb

@@ -304,7 +304,7 @@ describe "shared/behaves_like" do
   would "raise NameError when the context is not found" do
     lambda {
       ctx.paste "whoops"
-    }.should.raise NameError
+    }.should.raise LocalJumpError
   end
 
   paste "a shared context"

data/test/test_nested.rb

@@ -44,6 +44,10 @@ describe 'A' do
     would do
       t.should.eq true
     end
+
+    describe 'C' do
+      paste
+    end
   end
 
   would 'skip' do
@@ -55,3 +59,37 @@ end
 would 'also work on top-level' do
   true.should.eq true
 end
+
+describe 'Pork.inspect_failure' do
+  would 'hash' do
+    Pork.inspect_failure_auto(
+      {:b => 1, :a => 0}, :==, [{:a => 1, :b => 0}], false).
+      should.eq '{:a=>0, :b=>1}.==({:a=>1, :b=>0}) to return true'
+  end
+
+  would 'newline' do
+    obj, arg = 'a'*80, 'b'*80
+    Pork.inspect_failure_auto(obj, :==, [arg], true).
+      should.eq "\n#{obj.inspect}.==(\n#{arg.inspect}) to return false"
+  end
+
+  would 'diff' do
+    s = File.read(__FILE__)
+    n = s.count("\n")
+    Pork.inspect_failure_auto(s, :==, ["#{s}b\n"], true).
+      should.eq "String#==(\n#{n}a#{n+1}\n> b\n) to return false"
+  end
+end
+
+describe 'should(message)' do
+  would 'show message' do
+    should.raise(Pork::Failure){ should('nnf').satisfy('qoo'){ false } }.
+      message.should.eq "Expect qoo\nnnf"
+  end
+
+  would 'show lazy message' do
+    should.raise(Pork::Failure) do
+      should(nil, lambda{'nnf'}).satisfy(nil, lambda{'qoo'}){ false }
+    end.message.should.eq "Expect qoo\nnnf"
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: pork
 version: !ruby/object:Gem::Version
-  version: 0.9.0
+  version: 0.9.1
 platform: ruby
 authors:
 - Lin Jen-Shin (godfat)
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-07-11 00:00:00.000000000 Z
+date: 2014-07-14 00:00:00.000000000 Z
 dependencies: []
 description: |-
   Pork -- Simple and clean and modular testing library.