pork 0.1.0 → 0.9.0

data/lib/pork.rb

@@ -1,71 +1,57 @@
 
 require 'thread'
 
-module Pork
-  class Stats < Struct.new(:tests, :assertions, :skips, :failures, :errors)
-    def initialize
-      @mutex = Mutex.new
-      super(0, 0, 0, [], [])
-    end
-    def assertions= num; @mutex.synchronize{ super                    }; end
-    def tests=      num; @mutex.synchronize{ super                    }; end
-    def skips=      num; @mutex.synchronize{ super        ; 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 report
-      puts
-      puts (failures + errors).map{ |(e, m)|
-        "\n#{m}\n#{e.class}: #{e.message}\n  #{backtrace(e)}"
-      }
-      printf("\nFinished in %f seconds.\n", Time.now - @start)
-      printf("%d tests, %d assertions, %d failures, %d errors, %d skips\n",
-             *numbers)
-    end
-    private
-    def backtrace e
-      if $VERBOSE
-        e.backtrace
-      else
-        e.backtrace.reject{ |line| line =~ %r{/pork\.rb:\d+} }
-      end.join("\n  ")
-    end
+module Kernel
+  def should message=nil, &checker
+    Pork::Should.new(self, message, &checker)
   end
+end
+
+module Pork
+  Error   = Class.new(Exception)
+  Failure = Class.new(Error)
+  Skip    = Class.new(Error)
 
   def self.stats ; @stats ||= Stats.new; end
   def self.reset ; @stats   = nil      ; end
   def self.report; stats.report; reset ; end
+  def self.report_at_exit
+    Pork.stats.start
+    @report_at_exit ||= at_exit do
+      stats.report
+      exit stats.failures.size + stats.errors.size
+    end
+  end
 
   module API
     module_function
-    def describe desc, &suite
-      Pork.stats.start
-      Pork::Executor.execute(self, desc, &suite)
-      Pork.stats.tests += 1
-    end
+    def before &block; Executor.before(&block); end
+    def after  &block; Executor.after( &block); end
+    def describe desc=:default, &suite; Executor.describe(desc, &suite); end
+    def copy     desc=:default, &suite; Executor.copy(    desc, &suite); end
+    def paste    desc=:default, *args ; Executor.paste(   desc, *args ); end
+    def would    desc=:default, &test ; Executor.would(   desc, &test ); end
   end
 
-  Error   = Class.new(Exception)
-  Failure = Class.new(Error)
-  Skip    = Class.new(Error)
-
-  class Executor < Struct.new(:name)
-    extend Pork::API
-    def self.execute caller, desc, &suite
-      parent = if caller.kind_of?(Class) then caller else self end
-      Class.new(parent){
-        @desc, @before, @after = "#{desc}:", [], []
-      }.module_eval(&suite)
+  module Imp
+    attr_reader :stash, :desc
+    def before &block
+      if block_given? then @before << block else @before end
     end
-
-    def self.would name, &test
+    def after  &block
+      if block_given? then @after  << block else @after  end
+    end
+    def describe desc=:default, &suite
+      Class.new(self){ init("#{desc}: ") }.module_eval(&suite)
+    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])
+    end
+    def would desc=:default, &test
       assertions = Pork.stats.assertions
-      context = new(name)
+      context = new(desc)
       run_before(context)
       context.instance_eval(&test)
       if assertions == Pork.stats.assertions
@@ -74,55 +60,81 @@ module Pork
     rescue Error, StandardError => e
       case e
       when Skip
-        Pork.stats.skips += 1
+        Pork.stats.incr_skips
       when Failure
-        Pork.stats.add_failure(e, description_for("would #{name}"))
+        Pork.stats.add_failure(e, description_for("would #{desc}"))
       when Error, StandardError
-        Pork.stats.add_error(  e, description_for("would #{name}"))
+        Pork.stats.add_error(  e, description_for("would #{desc}"))
       end
     else
       print '.'
     ensure
+      Pork.stats.incr_tests
       run_after(context)
     end
 
-    def self.before &block
-      if block_given? then @before << block else @before end
+    protected
+    def init desc=''
+      @desc, @before, @after, @stash = desc, [], [], {}
     end
-    def self.after  &block
-      if block_given? then @after  << block else @after  end
-    end
-
-    def self.super_executor
-      @super_executor ||= ancestors[1..-1].find{ |a| a < Executor }
+    def super_executor
+      @super_executor ||= ancestors[1..-1].find{ |a| a <= Executor }
     end
-
-    def self.description_for name=''
-      supername = if super_executor
-                    " #{super_executor.description_for}"
-                  else
-                    ' '
-                  end
-      "#{@desc}#{supername}#{name}"
+    def description_for name=''
+      "#{desc}#{super_executor && super_executor.description_for}#{name}"
     end
-
-    def self.run_before context
+    def run_before context
       super_executor.run_before(context) if super_executor
       before.each{ |b| context.instance_eval(&b) }
     end
-
-    def self.run_after context
+    def run_after context
       super_executor.run_after(context) if super_executor
       after.each{ |b| context.instance_eval(&b) }
     end
+  end
+
+  class Executor < Struct.new(:desc)
+    extend Pork::Imp, Pork::API
+    init
+    def skip                  ; raise Skip.new("Skipping #{desc}"); end
+    def flunk reason='Flunked'; raise Error.new(reason)           ; end
+    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
 
-    def skip
-      raise Skip.new("Skipping #{name}")
+  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
@@ -132,8 +144,7 @@ module Pork
     end
 
     def method_missing msg, *args, &block
-      satisfy("#{@object.inspect}.#{msg}(#{args.join(', ')}) to" \
-              " return #{!@negate}") do
+      satisfy(inspect_error(@object, msg, args, @negate)) do
         @object.public_send(msg, *args, &block)
       end
     end
@@ -143,7 +154,7 @@ module Pork
       if !!result == @negate
         ::Kernel.raise Failure.new("Expect #{desc}\n#{@message}".chomp)
       else
-        ::Pork.stats.assertions += 1
+        ::Pork.stats.incr_assertions
       end
       result
     end
@@ -154,9 +165,11 @@ module Pork
       self
     end
 
-    def eq rhs
-      self == rhs
-    end
+    def eq  rhs; self == rhs; end
+    def lt  rhs; self <  rhs; end
+    def gt  rhs; self >  rhs; end
+    def lte rhs; self <= rhs; end
+    def gte rhs; self >= rhs; end
 
     def raise exception=::RuntimeError
       satisfy("#{__not__}raising #{exception}") do
@@ -173,18 +186,14 @@ module Pork
     def throw msg
       satisfy("#{__not__}throwing #{msg}") do
         flag = true
-        ::Kernel.catch(msg) do
+        data = ::Kernel.catch(msg) do
           if ::Kernel.block_given? then yield else @object.call end
           flag = false
         end
-        flag
+        flag && [msg, data]
       end
     end
 
-    def flunk reason='Flunked'
-      ::Kernel.raise Error.new(reason)
-    end
-
     private
     def __not__
       if @negate == true
@@ -194,10 +203,39 @@ module Pork
       end
     end
   end
-end
 
-module Kernel
-  def should message=nil, &checker
-    Pork::Should.new(self, message, &checker)
+  class Stats < Struct.new(:tests, :assertions, :skips, :failures, :errors)
+    def initialize
+      @mutex = Mutex.new
+      super(0, 0, 0, [], [])
+    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; 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 report
+      puts
+      puts (failures + errors).map{ |(e, m)|
+        "\n#{m}\n#{e.class}: #{e.message}\n  #{backtrace(e)}"
+      }
+      printf("\nFinished in %f seconds.\n", Time.now - @start)
+      printf("%d tests, %d assertions, %d failures, %d errors, %d skips\n",
+             *numbers)
+    end
+    private
+    def backtrace e
+      if $VERBOSE
+        e.backtrace
+      else
+        e.backtrace.reject{ |line| line =~ %r{/pork\.rb:\d+} }
+      end.join("\n  ")
+    end
   end
 end

data/lib/pork/auto.rb

@@ -0,0 +1,4 @@
+
+require 'pork'
+extend Pork::API
+Pork.report_at_exit

data/lib/pork/version.rb

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

data/pork.gemspec

@@ -1,36 +1,39 @@
 # -*- encoding: utf-8 -*-
-# stub: pork 0.1.0 ruby lib
+# stub: pork 0.9.0 ruby lib
 
 Gem::Specification.new do |s|
   s.name = "pork"
-  s.version = "0.1.0"
+  s.version = "0.9.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 = "2014-07-09"
-  s.description = "[Bacon][] reimplemented in an even more lightweight manner.\n\n[Bacon]: https://github.com/chneukirchen/bacon"
+  s.date = "2014-07-11"
+  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 = [
+  ".gitignore",
   ".gitmodules",
   ".travis.yml",
+  "CHANGES.md",
   "LICENSE",
   "README.md",
   "Rakefile",
   "lib/pork.rb",
-  "lib/pork/task.rb",
+  "lib/pork/auto.rb",
   "lib/pork/version.rb",
-  "pkg/pork-0.1.0.gem",
   "pork.gemspec",
   "task/README.md",
   "task/gemgem.rb",
   "test/test_bacon.rb",
-  "test/test_nested.rb"]
+  "test/test_nested.rb",
+  "test/test_readme.rb"]
   s.homepage = "https://github.com/godfat/pork"
   s.licenses = ["Apache License 2.0"]
   s.rubygems_version = "2.3.0"
-  s.summary = "[Bacon][] reimplemented in an even more lightweight manner."
+  s.summary = "Pork -- Simple and clean and modular testing library."
   s.test_files = [
   "test/test_bacon.rb",
-  "test/test_nested.rb"]
+  "test/test_nested.rb",
+  "test/test_readme.rb"]
 end

data/task/gemgem.rb

@@ -227,10 +227,6 @@ end # of gem namespace
 desc 'Run tests'
 task :test do
   next if Gemgem.test_files.empty?
-
-  # require 'bacon'
-  # Bacon.extend(Bacon::TestUnitOutput)
-  # Bacon.summary_on_exit
   Gemgem.test_files.each{ |file| require "#{Gemgem.dir}/#{file[0..-4]}" }
 end
 

data/test/test_bacon.rb

@@ -1,23 +1,21 @@
 
-require 'pork'
+require 'pork/auto'
 
-# Hooray for meta-testing.
-module MetaTests
-  def succeed block
-    block.should.not.raise Pork::Error
-  end
-
-  def fail block
-    block.should.raise Pork::Error
-  end
+describe Pork do
+  # Hooray for meta-testing.
+  include Module.new{
+    def succeed block
+      block.should.not.raise Pork::Error
+    end
 
-  def equal_string x
-    lambda{ |s| x == s.to_s }
-  end
-end
+    def fail block
+      block.should.raise Pork::Error
+    end
 
-Pork::API.describe Pork do
-  include MetaTests
+    def equal_string x
+      lambda{ |s| x == s.to_s }
+    end
+  }
 
   would "have should.satisfy" do
     succeed lambda { should.satisfy { 1 == 1 } }
@@ -221,13 +219,13 @@ Pork::API.describe Pork do
     succeed lambda { (1+2).should.not(&f) }
   end
 
-  would "have should.flunk" do
-    fail lambda { should.flunk }
-    fail lambda { should.flunk "yikes" }
+  would "have flunk" do
+    fail lambda { flunk }
+    fail lambda { flunk "yikes" }
   end
 end
 
-Pork::API.describe "before/after" do
+describe "before/after" do
   before do
     @a = 1
     @b = 2
@@ -287,89 +285,97 @@ Pork::API.describe "before/after" do
   end
 end
 
-# shared "a shared context" do
-#   it "gets called where it is included" do
-#     true.should.be.true
-#   end
-# end
-
-# shared "another shared context" do
-#   it "can access data" do
-#     @magic.should.be.equal 42
-#   end
-# end
-
-# describe "shared/behaves_like" do
-#   behaves_like "a shared context"
-
-#   ctx = self
-#   it "raises NameError when the context is not found" do
-#     lambda {
-#       ctx.behaves_like "whoops"
-#     }.should.raise NameError
-#   end
-
-#   behaves_like "a shared context"
-
-#   before {
-#     @magic = 42
-#   }
-#   behaves_like "another shared context"
-# end
-
-# describe "Methods" do
-#   def the_meaning_of_life
-#     42
-#   end
-
-#   def the_towels
-#     yield "DON'T PANIC"
-#   end
-
-#   it "should be accessible in a test" do
-#     the_meaning_of_life.should == 42
-#   end
-
-#   describe "when in a sibling context" do
-#     it "should be accessible in a test" do
-#       the_meaning_of_life.should == 42
-#     end
-
-#     it "should pass the block" do
-#       the_towels do |label|
-#         label.should == "DON'T PANIC"
-#       end.should == true
-#     end
-#   end
-# end
-
-# describe 'describe arguments' do
-
-#   def check(ctx,name)
-#     ctx.should.be.an.instance_of Bacon::Context
-#     ctx.instance_variable_get('@name').should == name
-#   end
-
-#   it 'should work with string' do
-#     check(describe('string') {},'string')
-#   end
-
-#   it 'should work with symbols' do
-#     check(describe(:behaviour) {},'behaviour')
-#   end
-
-#   it 'should work with modules' do
-#     check(describe(Bacon) {},'Bacon')
-#   end
-
-#   it 'should work with namespaced modules' do
-#     check(describe(Bacon::Context) {},'Bacon::Context')
-#   end
-
-#   it 'should work with multiple arguments' do
-#     check(describe(Bacon::Context, :empty) {},'Bacon::Context empty')
-#   end
-
-# end
-
-Pork.report
+copy "a shared context" do
+  would "get called where it is included" do
+    true.should.eq true
+  end
+end
+
+copy "another shared context" do
+  would "access data" do
+    @magic.should.eq 42
+  end
+end
+
+describe "shared/behaves_like" do
+  paste "a shared context"
+
+  ctx = self
+  would "raise NameError when the context is not found" do
+    lambda {
+      ctx.paste "whoops"
+    }.should.raise NameError
+  end
+
+  paste "a shared context"
+
+  before {
+    @magic = 42
+  }
+  paste "another shared context"
+end
+
+describe "Methods" do
+  def the_meaning_of_life
+    42
+  end
+
+  def the_towels
+    yield "DON'T PANIC"
+  end
+
+  would "be accessible in a test" do
+    the_meaning_of_life.should.eq 42
+  end
+
+  describe "when in a sibling context" do
+    would "should be accessible in a test" do
+      the_meaning_of_life.should.eq 42
+    end
+
+    would "should pass the block" do
+      the_towels do |label|
+        label.should.eq "DON'T PANIC"
+      end.should.eq true
+    end
+  end
+end
+
+describe 'describe arguments' do
+  check = lambda do |ctx, desc, name=nil|
+    ctx.should.lt Pork::Executor
+    ctx.description_for(name).should.eq "#{desc}: #{name}"
+  end
+
+  would 'work with string' do
+    str = 'string'
+    Pork::API.describe(str) do
+      check[self, str]
+      would 'a' do check[self.class, str, 'a'] end
+    end
+  end
+
+  would 'work with symbols' do
+    str = 'behaviour'
+    Pork::API.describe(:behaviour) do
+      check[self, str]
+      would 'b' do check[self.class, str, 'b'] end
+    end
+  end
+
+  would 'work with modules' do
+    str = 'Pork'
+    Pork::API.describe(Pork) do
+      check[self, str]
+      would 'c' do check[self.class, str, 'c'] end
+    end
+  end
+
+  would 'work with namespaced modules' do
+    str = 'Pork::Executor'
+    Pork::API.describe(Pork::Executor) do
+      check[self, str]
+      would 'd' do check[self.class, str, 'd'] end
+    end
+  end
+end