pork 0.9.2 → 1.0.0

data/lib/pork/inspect.rb

@@ -0,0 +1,97 @@
+
+module Pork
+  # default to :auto while eliminating warnings for uninitialized ivar
+  def self.inspect_failure_mode inspect=nil
+    @inspect = inspect || @inspect ||= :auto
+  end
+
+  class Inspect < Struct.new(:flip)
+    def self.with *args
+      lambda{ public_send("with_#{Pork.inspect_failure_mode}", *args) }
+    end
+
+    def self.with_auto expect, msg, args, negate
+      if args.size > 1
+        with_inline(expect, msg, args, negate)
+
+      elsif expect.kind_of?(Hash) && args.first.kind_of?(Hash)
+        if expect.inspect.size > 78
+          for_diff_hash(msg, negate,
+            Inspect.new(true).diff_hash(expect, args.first).
+              merge(Inspect.new(false).diff_hash(args.first, expect)))
+        else
+          with_inline(Hash[expect.sort], msg, [Hash[args.first.sort]], negate)
+        end
+
+      elsif expect.kind_of?(String) && expect.size > 400 &&
+            expect.count("\n") > 4 && !`which diff`.empty?
+        with_diff(expect, msg, args, negate)
+
+      elsif expect.inspect.size > 78
+        with_newline(expect, msg, args, negate)
+
+      else
+        with_inline( expect, msg, args, negate)
+      end
+    end
+
+    def self.for_diff_hash msg, negate, result
+      "\n" + result.map do |key, (expect, actual)|
+        body = with_auto(expect, msg, [actual], negate)
+        "\tHash with key path: #{key.inspect}\n#{body.sub(/\A\n/, '')}"
+      end.join("\n\n")
+    end
+
+    def self.with_inline expect, msg, args, negate
+      a = args.map(&:inspect).join(', ')
+      "#{expect.inspect}.#{msg}(#{a}) to return #{!negate}"
+    end
+
+    def self.with_newline expect, msg, args, negate
+      a = args.map(&:inspect).join(",\n")
+      "\n#{expect.inspect}.#{msg}(\n#{a}) to return #{!negate}"
+    end
+
+    def self.with_diff expect, msg, args, negate
+      require 'tempfile'
+      Tempfile.open('pork-expect') do |its|
+        Tempfile.open('pork-was') do |was|
+          its.puts(expect.to_s)
+          its.close
+          was.puts(args.map(&:to_s).join(",\n"))
+          was.close
+          name = "#{expect.class}##{msg}(\n"
+          "#{name}#{`diff #{its.path} #{was.path}`}) to return #{!negate}"
+        end
+      end
+    end
+
+    def diff_hash expect, actual, result={}, prefix=''
+      expect.inject(result) do |r, (key, e)|
+        diff_object(e, actual[key], r, "#{prefix}#{key}")
+      end
+    end
+
+    def diff_array expect, actual, result={}, prefix=''
+      expect.each.with_index.inject(result) do |r, (e, idx)|
+        diff_object(e, actual[idx], r, "#{prefix}#{idx}")
+      end
+    end
+
+    def diff_object expect, actual, result, prefix
+      return result if expect == actual
+
+      if expect.kind_of?(Hash) && actual.kind_of?(Hash)
+        diff_hash(expect, actual, result, "#{prefix}:")
+      elsif expect.kind_of?(Array) && actual.kind_of?(Array)
+        diff_array(expect, actual, result, "#{prefix}:")
+      elsif flip
+        result[prefix] = [actual, expect]
+      else
+        result[prefix] = [expect, actual]
+      end
+
+      result
+    end
+  end
+end

data/lib/pork/isolate.rb

@@ -0,0 +1,55 @@
+
+require 'pork'
+require 'pork/executor'
+
+module Pork
+  module Isolate
+    def all_tests
+      @all_tests ||= Hash[build_all_tests]
+    end
+
+    def isolate name, stat=Stat.new
+      execute(stat) do |s|
+        execute_with_isolation(all_tests[name], s)
+      end
+    end
+
+    protected
+    def build_all_tests paths=[]
+      @tests.flat_map.with_index do |(type, arg, _), index|
+        current = paths + [index]
+        case type
+        when :describe
+          arg.build_all_tests(current)
+        when :would
+          [["#{desc.chomp(': ')} #{arg} ##{current}", current]]
+        else
+          []
+        end
+      end
+    end
+
+    def execute_with_isolation paths, stat, super_env=nil
+      env = Env.new(super_env)
+      idx = paths.first
+
+      @tests.first(idx).each do |(type, arg, _)|
+        case type
+        when :before
+          env.before << arg
+        when :after
+          env.after  << arg
+        end
+      end
+
+      if paths.size == 1
+        _, desc, test = @tests[idx]
+        run(desc, test, stat, env)
+      else
+        @tests[idx][1].execute_with_isolation(paths.drop(1), stat, env)
+      end
+    end
+  end
+
+  Executor.extend(Isolate)
+end

data/lib/pork/mode/parallel.rb

@@ -0,0 +1,16 @@
+
+require 'pork'
+require 'pork/isolate'
+
+module Pork
+  module Parallel
+    def parallel cores=8, stat=Stat.new
+      all_tests.keys.shuffle.each_slice(cores).map do |names|
+        Thread.new{ names.each{ |n| isolate(n, stat) } }
+      end.each(&:join)
+      stat
+    end
+  end
+
+  Executor.extend(Parallel)
+end

data/lib/pork/mode/shuffle.rb

@@ -0,0 +1,16 @@
+
+require 'pork'
+require 'pork/isolate'
+
+module Pork
+  module Shuffle
+    def shuffle stat=Stat.new
+      all_tests.keys.shuffle.each do |name|
+        isolate(name, stat)
+      end
+      stat
+    end
+  end
+
+  Executor.extend(Shuffle)
+end

data/lib/pork/should.rb

@@ -0,0 +1,25 @@
+
+require 'pork/executor'
+
+module Kernel
+  def should *args, &block
+    Pork::Expect.new(
+      Thread.current.group.list.first[:pork_stat], self, *args, &block)
+  end
+end
+
+module Pork
+  module Should
+    def execute stat=Stat.new
+      thread = Thread.current
+      original_group, group = thread.group, ThreadGroup.new
+      group.add(thread)
+      thread[:pork_stat] = stat
+      super
+    ensure
+      original_group.add(thread)
+    end
+  end
+
+  Executor.extend(Should)
+end

data/lib/pork/stat.rb

@@ -0,0 +1,38 @@
+
+require 'thread'
+
+module Pork
+  class Stat < Struct.new(:tests, :assertions, :skips,
+                          :failures, :errors, :start, :io)
+    def initialize io=$stdout
+      @mutex = Mutex.new
+      super(0, 0, 0, [], [], Time.now, io)
+    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 }; end
+    def add_failure *e ; @mutex.synchronize{ failures        << e }; end
+    def add_error   *e ; @mutex.synchronize{ errors          << e }; end
+    def passed?; failures.size + errors.size == 0                      ; end
+    def numbers; [tests, assertions, failures.size, errors.size, skips]; end
+    def report
+      io.puts
+      io.puts (failures + errors).map{ |(e, m)|
+        "\n#{m}\n#{e.class}: #{e.message}\n  #{backtrace(e)}"
+      }
+      io.printf("\nFinished in %f seconds.\n", Time.now - start)
+      io.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(/\w+)?\.rb:\d+} }
+      end.join("\n  ")
+    end
+  end
+end

data/lib/pork/test.rb

@@ -0,0 +1,17 @@
+
+require 'pork/auto'
+require 'muack'
+
+copy do
+  before do
+    Muack::API.stub(Pork::Executor.all_tests).keys.peek_return do |names|
+      names.reject do |n|
+        n =~ /^Pork::(Isolate|Shuffle|Parallel) /
+      end
+    end
+  end
+
+  after do
+    Muack.reset
+  end
+end

data/lib/pork/version.rb

@@ -1,4 +1,4 @@
 
 module Pork
-  VERSION = '0.9.2'
+  VERSION = '1.0.0'
 end

data/pork.gemspec

@@ -1,39 +1,74 @@
 # -*- encoding: utf-8 -*-
-# stub: pork 0.9.2 ruby lib
+# stub: pork 1.0.0 ruby lib
 
 Gem::Specification.new do |s|
   s.name = "pork"
-  s.version = "0.9.2"
+  s.version = "1.0.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-11-07"
-  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.date = "2014-11-20"
+  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 = [
   ".gitignore",
   ".gitmodules",
   ".travis.yml",
   "CHANGES.md",
+  "Gemfile",
   "LICENSE",
   "README.md",
   "Rakefile",
+  "lib/mutant/integration/pork.rb",
   "lib/pork.rb",
   "lib/pork/auto.rb",
+  "lib/pork/context.rb",
+  "lib/pork/env.rb",
+  "lib/pork/error.rb",
+  "lib/pork/executor.rb",
+  "lib/pork/expect.rb",
+  "lib/pork/imp.rb",
+  "lib/pork/inspect.rb",
+  "lib/pork/isolate.rb",
+  "lib/pork/mode/parallel.rb",
+  "lib/pork/mode/shuffle.rb",
+  "lib/pork/should.rb",
+  "lib/pork/stat.rb",
+  "lib/pork/test.rb",
   "lib/pork/version.rb",
   "pork.gemspec",
   "task/README.md",
   "task/gemgem.rb",
   "test/test_bacon.rb",
+  "test/test_inspect.rb",
+  "test/test_isolate.rb",
   "test/test_nested.rb",
-  "test/test_readme.rb"]
+  "test/test_parallel.rb",
+  "test/test_readme.rb",
+  "test/test_shuffle.rb"]
   s.homepage = "https://github.com/godfat/pork"
   s.licenses = ["Apache License 2.0"]
-  s.rubygems_version = "2.4.2"
+  s.rubygems_version = "2.4.4"
   s.summary = "Pork -- Simple and clean and modular testing library."
   s.test_files = [
   "test/test_bacon.rb",
+  "test/test_inspect.rb",
+  "test/test_isolate.rb",
   "test/test_nested.rb",
-  "test/test_readme.rb"]
+  "test/test_parallel.rb",
+  "test/test_readme.rb",
+  "test/test_shuffle.rb"]
+
+  if s.respond_to? :specification_version then
+    s.specification_version = 4
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_development_dependency(%q<muack>, [">= 0"])
+    else
+      s.add_dependency(%q<muack>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<muack>, [">= 0"])
+  end
 end

data/task/gemgem.rb

@@ -38,6 +38,99 @@ module Gemgem
     self.spec = spec
   end
 
+  def gem_install
+    require 'rubygems/commands/install_command'
+    # read ~/.gemrc
+    Gem.use_paths(Gem.configuration[:gemhome], Gem.configuration[:gempath])
+    Gem::Command.extra_args = Gem.configuration[:gem]
+
+    # setup install options
+    cmd = Gem::Commands::InstallCommand.new
+    cmd.handle_options([])
+
+    # install
+    install = Gem::Installer.new(gem_path, cmd.options)
+    install.install
+    puts "\e[35mGem installed: \e[33m#{strip_path(install.gem_dir)}\e[0m"
+  end
+
+  def gem_spec
+    create
+    write
+  end
+
+  def gem_build
+    require 'fileutils'
+    require 'rubygems/package'
+    gem = nil
+    Dir.chdir(dir) do
+      gem = Gem::Package.build(Gem::Specification.load(spec_path))
+      FileUtils.mkdir_p(pkg_dir)
+      FileUtils.mv(gem, pkg_dir) # gem is relative path, but might be ok
+    end
+    puts "\e[35mGem built: \e[33m#{strip_path("#{pkg_dir}/#{gem}")}\e[0m"
+  end
+
+  def gem_release
+    sh_git('tag', gem_tag)
+    sh_git('push')
+    sh_git('push', '--tags')
+    sh_gem('push', gem_path)
+  end
+
+  def gem_check
+    ver = spec.version.to_s
+
+    if ENV['VERSION'].nil?
+      puts("\e[35mExpected "                                  \
+           "\e[33mVERSION\e[35m=\e[33m#{ver}\e[0m")
+      exit(1)
+
+    elsif ENV['VERSION'] != ver
+      puts("\e[35mExpected \e[33mVERSION\e[35m=\e[33m#{ver} " \
+           "\e[35mbut got\n         "                         \
+           "\e[33mVERSION\e[35m=\e[33m#{ENV['VERSION']}\e[0m")
+      exit(2)
+    end
+  end
+
+  def test
+    return if test_files.empty?
+
+    if ENV['COV'] || ENV['CI']
+      require 'simplecov'
+      if ENV['CI']
+        require 'coveralls'
+        SimpleCov.formatter = Coveralls::SimpleCov::Formatter
+      end
+      SimpleCov.start do
+        add_filter('test/')
+        add_filter('test.rb')
+      end
+    end
+
+    test_files.each{ |file| require "#{dir}/#{file[0..-4]}" }
+  end
+
+  def clean
+    return if ignored_files.empty?
+
+    require 'fileutils'
+    trash = File.expand_path("~/.Trash/#{spec.name}")
+    puts "Move the following files into: \e[35m#{strip_path(trash)}\e[33m"
+
+    ignored_files.each do |file|
+      from = "#{dir}/#{file}"
+      to   = "#{trash}/#{File.dirname(file)}"
+      puts strip_path(from)
+
+      FileUtils.mkdir_p(to)
+      FileUtils.mv(from, to)
+    end
+
+    print "\e[0m"
+  end
+
   def write
     File.open(spec_path, 'w'){ |f| f << split_lines(spec.to_ruby) }
   end
@@ -173,82 +266,38 @@ namespace :gem do
 
 desc 'Install gem'
 task :install => [:build] do
-  Gemgem.sh_gem('install', Gemgem.gem_path)
+  Gemgem.gem_install
 end
 
 desc 'Build gem'
 task :build => [:spec] do
-  require 'fileutils'
-  require 'rubygems/package'
-  gem = nil
-  Dir.chdir(Gemgem.dir) do
-    gem = Gem::Package.build(Gem::Specification.load(Gemgem.spec_path))
-    FileUtils.mkdir_p(Gemgem.pkg_dir)
-    FileUtils.mv(gem, Gemgem.pkg_dir) # gem is relative path, but might be ok
-  end
-  puts "\e[35mGem built: \e[33m" \
-       "#{Gemgem.strip_path("#{Gemgem.pkg_dir}/#{gem}")}\e[0m"
+  Gemgem.gem_build
 end
 
 desc 'Generate gemspec'
 task :spec do
-  Gemgem.create
-  Gemgem.write
+  Gemgem.gem_spec
 end
 
 desc 'Release gem'
 task :release => [:spec, :check, :build] do
-  Gemgem.module_eval do
-    sh_git('tag', Gemgem.gem_tag)
-    sh_git('push')
-    sh_git('push', '--tags')
-    sh_gem('push', Gemgem.gem_path)
-  end
+  Gemgem.gem_release
 end
 
 task :check do
-  ver = Gemgem.spec.version.to_s
-
-  if ENV['VERSION'].nil?
-    puts("\e[35mExpected "                                  \
-         "\e[33mVERSION\e[35m=\e[33m#{ver}\e[0m")
-    exit(1)
-
-  elsif ENV['VERSION'] != ver
-    puts("\e[35mExpected \e[33mVERSION\e[35m=\e[33m#{ver} " \
-         "\e[35mbut got\n         "                         \
-         "\e[33mVERSION\e[35m=\e[33m#{ENV['VERSION']}\e[0m")
-    exit(2)
-  end
+  Gemgem.gem_check
 end
 
 end # of gem namespace
 
 desc 'Run tests'
 task :test do
-  next if Gemgem.test_files.empty?
-  Gemgem.test_files.each{ |file| require "#{Gemgem.dir}/#{file[0..-4]}" }
+  Gemgem.test
 end
 
 desc 'Trash ignored files'
 task :clean => ['gem:spec'] do
-  next if Gemgem.ignored_files.empty?
-
-  require 'fileutils'
-  trash = File.expand_path("~/.Trash/#{Gemgem.spec.name}")
-  puts "Move the following files into:" \
-       " \e[35m#{Gemgem.strip_path(trash)}\e[33m"
-
-  Gemgem.ignored_files.each do |file|
-    from = "#{Gemgem.dir}/#{file}"
-    to   = "#{trash}/#{File.dirname(file)}"
-    puts Gemgem.strip_path(from)
-
-    FileUtils.mkdir_p(to)
-    FileUtils.mv(from, to)
-  end
-
-  print "\e[0m"
+  Gemgem.clean
 end
 
 task :default do