pork 0.9.2 → 1.0.0

data/lib/pork.rb

@@ -1,247 +1,30 @@
 
-require 'thread'
-
-module Kernel
-  def should message=nil, message_lazy=nil, &checker
-    Pork::Should.new(self, message, message_lazy, &checker)
-  end
-end
+require 'pork/executor'
 
 module Pork
-  Error   = Class.new(StandardError)
-  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 + ($! && 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
-
   module API
     module_function
     def before █ Executor.before(&block); end
     def after  █ 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 copy     desc=:default, █ Executor.copy(    desc, &block); end
     def paste    desc=:default, *args ; Executor.paste(   desc, *args ); end
+    def describe desc=:default, &suite; Executor.describe(desc, &suite); end
     def would    desc=:default, &test ; Executor.would(   desc, &test ); end
   end
 
-  module Imp
-    attr_reader :stash, :desc
-    def before &block
-      if block_given? then @before << block else @before end
-    end
-    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
-      module_exec(*args, &search_stash(desc))
-    end
-    def would desc=:default, &test
-      assertions = Pork.stats.assertions
-      context = new(desc)
-      run_before(context)
-      context.instance_eval(&test)
-      if assertions == Pork.stats.assertions
-        raise Error.new('Missing assertions')
-      end
-    rescue Error, StandardError => e
-      case e
-      when Skip
-        Pork.stats.incr_skips
-      when Failure
-        Pork.stats.add_failure(e, description_for("would #{desc}"))
-      when Error, StandardError
-        Pork.stats.add_error(  e, description_for("would #{desc}"))
-      end
-    else
-      print '.'
-    ensure
-      Pork.stats.incr_tests
-      run_after(context)
-    end
-
-    protected
-    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 && super_executor.run_before(context)
-      before.each{ |b| context.instance_eval(&b) }
-    end
-    def run_after context
-      super_executor && super_executor.run_after(context)
-      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
+  # default to :execute while eliminating warnings for uninitialized ivar
+  def self.execute_mode execute=nil
+    @execute = execute || @execute ||= :execute
   end
 
-  class Should < BasicObject
-    instance_methods.each{ |m| undef_method(m) unless m =~ /^__|^object_id$/ }
-    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(nil, ::Pork.inspect_failure(@object, msg, args, @negate)) do
-        @object.public_send(msg, *args, &block)
-      end
-    end
-
-    def satisfy desc=@object, desc_lazy=nil
-      result = yield(@object)
-      if !!result == @negate
-        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
-      result
-    end
-
-    def not &checker
-      @negate = !@negate
-      satisfy(&checker) if checker
-      self
-    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
-        begin
-          if ::Kernel.block_given? then yield else @object.call end
-        rescue exception => e
-          e
-        else
-          false
-        end
-      end
-    end
-
-    def throw msg
-      satisfy("#{__not__}throwing #{msg}") do
-        flag = true
-        data = ::Kernel.catch(msg) do
-          if ::Kernel.block_given? then yield else @object.call end
-          flag = false
-        end
-        flag && [msg, data]
-      end
-    end
-
-    private
-    def __not__; if @negate == true then 'not ' else '' end; end
-  end
-
-  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  ")
+  def self.autorun auto=true
+    @auto = auto
+    @autorun ||= at_exit do
+      next unless @auto
+      require "pork/mode/#{execute_mode}" unless execute_mode == :execute
+      stat = Executor.public_send(execute_mode)
+      stat.report
+      exit stat.failures.size + stat.errors.size + ($! && 1).to_i
     end
   end
 end

data/lib/pork/auto.rb

@@ -1,4 +1,5 @@
 
 require 'pork'
+require 'pork/should'
 extend Pork::API
-Pork.report_at_exit
+Pork.autorun

data/lib/pork/context.rb

@@ -0,0 +1,24 @@
+
+require 'pork/expect'
+require 'pork/error'
+
+module Pork
+  module Context
+    private
+    def expect *args, &block
+      Expect.new(pork_stat, *args, &block)
+    end
+
+    def skip
+      raise Skip.new
+    end
+
+    def flunk reason='Flunked'
+      raise Error.new(reason)
+    end
+
+    def ok
+      pork_stat.incr_assertions
+    end
+  end
+end

data/lib/pork/env.rb

@@ -0,0 +1,18 @@
+
+module Pork
+  class Env < Struct.new(:super_env, :before, :after)
+    def initialize se=nil
+      super(se, [], [])
+    end
+
+    def run_before context
+      super_env && super_env.run_before(context)
+      before.each{ |b| context.instance_eval(&b) }
+    end
+
+    def run_after context
+      super_env && super_env.run_after(context)
+      after.each{ |b| context.instance_eval(&b) }
+    end
+  end
+end

data/lib/pork/error.rb

@@ -0,0 +1,6 @@
+
+module Pork
+  Error   = Class.new(StandardError)
+  Failure = Class.new(Error)
+  Skip    = Class.new(Error)
+end

data/lib/pork/executor.rb

@@ -0,0 +1,11 @@
+
+require 'pork/imp'
+require 'pork/context'
+
+module Pork
+  class Executor < Struct.new(:pork_stat)
+    extend Imp
+    include Context
+    init
+  end
+end

data/lib/pork/expect.rb

@@ -0,0 +1,69 @@
+
+require 'pork/inspect'
+
+module Pork
+  class Expect < BasicObject
+    instance_methods.each{ |m| undef_method(m) unless m =~ /^__|^object_id$/ }
+    def initialize stat, object=nil, message=nil, message_lazy=nil, &checker
+      @stat, @object, @negate = stat, object, false
+      @message, @message_lazy = message, message_lazy
+      satisfy(&checker) if checker
+    end
+
+    def method_missing msg, *args, &block
+      satisfy(nil, Inspect.with(@object, msg, args, @negate)) do
+        @object.public_send(msg, *args, &block)
+      end
+    end
+
+    def satisfy desc=@object, desc_lazy=nil
+      result = yield(@object)
+      if !!result == @negate
+        d =     desc_lazy &&     desc_lazy.call || desc
+        m = @message_lazy && @message_lazy.call || @message
+        ::Kernel.raise Failure.new("Expect #{d}\n#{m}".chomp)
+      else
+        @stat.incr_assertions
+      end
+      result
+    end
+
+    def not &checker
+      @negate = !@negate
+      satisfy(&checker) if checker
+      self
+    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
+        begin
+          if ::Kernel.block_given? then yield else @object.call end
+        rescue exception => e
+          e
+        else
+          false
+        end
+      end
+    end
+
+    def throw msg
+      satisfy("#{__not__}throwing #{msg}") do
+        flag = true
+        data = ::Kernel.catch(msg) do
+          if ::Kernel.block_given? then yield else @object.call end
+          flag = false
+        end
+        flag && [msg, data]
+      end
+    end
+
+    private
+    def __not__; if @negate == true then 'not ' else '' end; end
+  end
+end

data/lib/pork/imp.rb

@@ -0,0 +1,103 @@
+
+require 'pork/env'
+require 'pork/stat'
+require 'pork/error'
+require 'pork/expect'
+
+module Pork
+  module Imp
+    attr_reader :desc, :tests
+
+    def before &block; @tests << [:before, block]; end
+    def after  &block; @tests << [:after , block]; end
+
+    def copy  desc=:default, &suite
+      @stash[desc] = suite
+    end
+    def paste desc=:default, *args
+      module_exec(*args, &search_stash(desc))
+    end
+
+    def describe desc=:default, &suite
+      executor = Class.new(self){ init("#{desc}: ") }
+      executor.module_eval(&suite)
+      @tests << [:describe, executor]
+    end
+
+    def would desc=:default, &test
+      @tests << [:would, desc, test]
+    end
+
+    def execute stat=Stat.new
+      if block_given?
+        yield(stat)
+      else
+        execute_with_parent(stat)
+      end
+      stat
+    end
+
+    private
+    def init desc=''
+      @desc, @tests, @stash = desc, [], {}
+      @super_executor = ancestors[1..-1].find{ |a| a <= Executor }
+    end
+
+    def run desc, test, stat, env
+      assertions = stat.assertions
+      context = new(stat)
+      run_protected(desc, stat) do
+        env.run_before(context)
+        context.instance_eval(&test)
+        if assertions == stat.assertions
+          raise Error.new('Missing assertions')
+        end
+        stat.io.print '.'
+      end
+    ensure
+      stat.incr_tests
+      run_protected(desc, stat){ env.run_after(context) }
+    end
+
+    def run_protected desc, stat
+      yield
+    rescue Error, StandardError => e
+      case e
+      when Skip
+        stat.incr_skips
+        stat.io.print 's'
+      when Failure
+        stat.add_failure(e, description_for("would #{desc}"))
+        stat.io.print 'F'
+      when Error, StandardError
+        stat.add_error(  e, description_for("would #{desc}"))
+        stat.io.print 'E'
+      end
+    end
+
+    protected
+    def execute_with_parent stat, super_env=nil
+      env = Env.new(super_env)
+      @tests.each do |(type, arg, test)|
+        case type
+        when :before
+          env.before << arg
+        when :after
+          env.after  << arg
+        when :describe
+          arg.execute_with_parent(stat, env)
+        when :would
+          run(arg, test, stat, env)
+        end
+      end
+    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
+  end
+end