assert 2.4.0 → 2.5.0

data/README.md

@@ -11,22 +11,22 @@ require 'assert'
 
 class MyTests < Assert::Context
 
-  def test_something
+  test "something" do
     assert_equal 1, 1
   end
 
 end
 ```
 
-```sh
+```
 $ assert test/my_tests.rb
 Loaded suite (1 test)
-Running tests in random order, seeded with "33650"
+Running tests in random order, seeded with "56382"
 .
 
 1 result: pass
 
-(0.000199 seconds)
+(0.000128 seconds, 7812.500000 tests/s, 7812.500000 results/s)
 ```
 
 ## What Assert is
@@ -226,11 +226,11 @@ git ls-files --others --exclude-standard  # added files
 
 The git cmds have ` -- #{test_paths}` appended to them to scope their results to just the test paths specified by the CLI and are run together using ` && `.
 
-This, of course, assumes you are working in a git repository.  If you are not or you want to use custom logic to determine the changed files, configure a custom proc.  The proc should take a single parameter which is an array of test paths specified by the CLI.
+This, of course, assumes you are working in a git repository.  If you are not or you want to use custom logic to determine the changed files, configure a custom proc.  The proc should take two parameters: the config and an array of test paths specified by the CLI.
 
 ```ruby
 Assert.configure do |config|
-  config.changed_files do |test_paths|
+  config.changed_proc Proc.new do |config, test_paths|
     `git diff --name-only master -- #{test_paths.join(' ')}`.split("\n")  # or whatever
   end
 end
@@ -242,10 +242,10 @@ If you just want to disable this feature completely:
 Assert.configure do |config|
 
   # run nothing if the `-c` flag is given
-  config.changed_files{ |test_paths| [] }
+  config.changed_proc Proc.new{ |test_paths| [] }
 
   # run all test paths if the `-c` flag is given
-  config.changed_files{ |test_paths| test_paths }
+  config.changed_proc Proc.new{ |test_paths| test_paths }
 
 end
 ```

data/lib/assert.rb

@@ -1,72 +1,19 @@
-require 'singleton'
 require 'assert/version'
 
+require 'assert/config'
+require 'assert/context'
+require 'assert/runner'
+require 'assert/suite'
 require 'assert/utils'
 require 'assert/view'
-require 'assert/suite'
-require 'assert/runner'
-require 'assert/context'
 
 module Assert
 
-  def self.view;   Config.view;   end
-  def self.suite;  Config.suite;  end
-  def self.runner; Config.runner; end
-
-  def self.config; Config; end
-  def self.configure; yield Config if block_given?; end
-
-  class Config
-    include Singleton
-    # map any class methods to the singleton
-    def self.method_missing(m, *a, &b); self.instance.send(m, *a, &b); end
-    def self.respond_to?(m); super || self.instance.respond_to?(m); end
-
-    def self.settings(*items)
-      items.each do |item|
-        define_method(item) do |*args|
-          if !(value = args.size > 1 ? args : args.first).nil?
-            instance_variable_set("@#{item}", value)
-          end
-          instance_variable_get("@#{item}")
-        end
-      end
-    end
-
-    settings :view, :suite, :runner, :test_dir, :test_helper, :changed_files
-    settings :runner_seed, :pp_proc, :use_diff_proc, :run_diff_proc
-    settings :capture_output, :halt_on_fail, :changed_only, :pp_objects, :debug
-
-    def initialize
-      @view   = Assert::View::DefaultView.new($stdout)
-      @suite  = Assert::Suite.new
-      @runner = Assert::Runner.new
-      @test_dir    = "test"
-      @test_helper = "helper.rb"
-      @changed_files = Assert::AssertRunner::DEFAULT_CHANGED_FILES_PROC
-
-      # default option values
-      @runner_seed   = begin; srand; srand % 0xFFFF; end.to_i
-      @pp_proc       = Assert::U.stdlib_pp_proc
-      @use_diff_proc = Assert::U.default_use_diff_proc
-      @run_diff_proc = Assert::U.syscmd_diff_proc
-
-      # mode flags
-      @capture_output = false
-      @halt_on_fail   = true
-      @changed_only   = false
-      @pp_objects     = false
-      @debug          = false
-    end
-
-    def apply(settings)
-      settings.keys.each do |name|
-        if !settings[name].nil? && self.respond_to?(name.to_s)
-          self.send(name.to_s, settings[name])
-        end
-      end
-    end
+  def self.config; @config ||= Config.new; end
+  def self.configure; yield self.config if block_given?; end
 
-  end
+  def self.view;   self.config.view;   end
+  def self.suite;  self.config.suite;  end
+  def self.runner; self.config.runner; end
 
 end

data/lib/assert/assert_runner.rb

@@ -3,26 +3,13 @@ require 'assert/cli'
 module Assert
 
   class AssertRunner
-    TEST_FILE_SUFFIXES  = ['_tests.rb', '_test.rb']
     USER_SETTINGS_FILE  = ".assert/init.rb"
     LOCAL_SETTINGS_FILE = ".assert.rb"
 
-    DEFAULT_CHANGED_FILES_PROC = Proc.new do |test_paths|
-      # use git to determine which files have changes
-      files = []
-      cmd = [
-        "git diff --no-ext-diff --name-only",       # changed files
-        "git ls-files --others --exclude-standard"  # added files
-      ].map{ |c| "#{c} -- #{test_paths.join(' ')}" }.join(' && ')
+    attr_reader :config
 
-      Assert::CLI.bench('Load only changed files') do
-        files = `#{cmd}`.split("\n")
-      end
-      puts Assert::CLI.debug_msg("  `#{cmd}`") if Assert.config.debug
-      files
-    end
-
-    def initialize(test_paths, test_options)
+    def initialize(config, test_paths, test_options)
+      @config = config
       Assert::CLI.bench('Apply settings') do
         apply_user_settings
         apply_local_settings
@@ -30,30 +17,30 @@ module Assert
         apply_env_settings
       end
 
-      files = test_files(test_paths.empty? ? [*Assert.config.test_dir] : test_paths)
-      init(files, path_of(Assert.config.test_dir, files.first))
+      files = test_files(test_paths.empty? ? [*self.config.test_dir] : test_paths)
+      init(files, path_of(self.config.test_dir, files.first))
     end
 
     def init(test_files, test_dir)
       # load any test helper file
-      if test_dir && (h = File.join(test_dir, Config.test_helper)) && File.exists?(h)
+      if test_dir && (h = File.join(test_dir, self.config.test_helper)) && File.exists?(h)
         Assert::CLI.bench('Require test helper'){ require h }
       end
 
       # load the test files
-      Assert.view.fire(:before_load, test_files)
+      self.config.view.fire(:before_load, test_files)
       Assert::CLI.bench("Require #{test_files.count} test files") do
         test_files.each{ |p| require p }
       end
-      if Assert.config.debug
+      if self.config.debug
         puts Assert::CLI.debug_msg("Test files:")
         test_files.each{ |f| puts Assert::CLI.debug_msg("  #{f}") }
       end
-      Assert.view.fire(:after_load)
+      self.config.view.fire(:after_load)
     end
 
     def run
-      Assert.runner.run(Assert.suite, Assert.view)
+      self.config.runner.run(self.config.suite, self.config.view)
     end
 
     protected
@@ -67,19 +54,17 @@ module Assert
     end
 
     def apply_option_settings(options)
-      Assert.config.apply(options)
+      self.config.apply(options)
     end
 
     def apply_env_settings
-      Assert.configure do |c|
-        c.runner_seed ENV['ASSERT_RUNNER_SEED'].to_i if ENV['ASSERT_RUNNER_SEED']
-      end
+      self.config.runner_seed ENV['ASSERT_RUNNER_SEED'].to_i if ENV['ASSERT_RUNNER_SEED']
     end
 
     private
 
     def test_files(test_paths)
-      file_paths = if Assert.config.changed_only
+      file_paths = if self.config.changed_only
         changed_test_files(test_paths)
       else
         globbed_test_files(test_paths)
@@ -89,7 +74,7 @@ module Assert
     end
 
     def changed_test_files(test_paths)
-      globbed_test_files(Assert.config.changed_files.call(test_paths))
+      globbed_test_files(self.config.changed_proc.call(self.config, test_paths))
     end
 
     def globbed_test_files(test_paths)
@@ -100,7 +85,7 @@ module Assert
     end
 
     def is_test_file?(path)
-      TEST_FILE_SUFFIXES.inject(false) do |result, suffix|
+      self.config.test_file_suffixes.inject(false) do |result, suffix|
         result || path =~ /#{suffix}$/
       end
     end

data/lib/assert/assertions.rb

@@ -9,47 +9,49 @@ module Assert
     end
 
     def assert_not_block(desc = nil)
-      assert(!yield, desc){ "Expected block to return a false value." }
+      assert(!yield, desc){ "Expected block to not return a true value." }
     end
     alias_method :refute_block, :assert_not_block
 
     def assert_empty(collection, desc = nil)
       assert(collection.empty?, desc) do
-        "Expected #{Assert::U.show(collection)} to be empty."
+        "Expected #{Assert::U.show(collection, __assert_config__)} to be empty."
       end
     end
 
     def assert_not_empty(collection, desc = nil)
       assert(!collection.empty?, desc) do
-        "Expected #{Assert::U.show(collection)} to not be empty."
+        "Expected #{Assert::U.show(collection, __assert_config__)} to not be empty."
       end
     end
     alias_method :refute_empty, :assert_not_empty
 
     def assert_equal(exp, act, desc = nil)
       assert(act == exp, desc) do
-        exp_show = Assert::U.show_for_diff(exp)
-        act_show = Assert::U.show_for_diff(act)
+        c = __assert_config__
+        exp_show = Assert::U.show_for_diff(exp, c)
+        act_show = Assert::U.show_for_diff(act, c)
 
-        if Assert.config.use_diff_proc.call(exp_show, act_show)
+        if c.use_diff_proc.call(exp_show, act_show)
           "Expected does not equal actual, diff:\n"\
-          "#{Assert.config.run_diff_proc.call(exp_show, act_show)}"
+          "#{c.run_diff_proc.call(exp_show, act_show)}"
         else
-          "Expected #{Assert::U.show(exp)}, not #{Assert::U.show(act)}."
+          "Expected #{Assert::U.show(act, c)} to be equal to #{Assert::U.show(exp, c)}."
         end
       end
     end
 
     def assert_not_equal(exp, act, desc = nil)
       assert(act != exp, desc) do
-        exp_show = Assert::U.show_for_diff(exp)
-        act_show = Assert::U.show_for_diff(act)
+        c = __assert_config__
+        exp_show = Assert::U.show_for_diff(exp, c)
+        act_show = Assert::U.show_for_diff(act, c)
 
-        if Assert.config.use_diff_proc.call(exp_show, act_show)
+        if c.use_diff_proc.call(exp_show, act_show)
           "Expected equals actual, diff:\n"\
-          "#{Assert.config.run_diff_proc.call(exp_show, act_show)}"
+          "#{c.run_diff_proc.call(exp_show, act_show)}"
         else
-          "#{Assert::U.show(act)} not expected to equal #{Assert::U.show(exp)}."
+          "Expected #{Assert::U.show(act, c)} to not be equal to #{Assert::U.show(exp, c)}."
         end
       end
     end
@@ -57,27 +59,29 @@ module Assert
 
     def assert_file_exists(file_path, desc = nil)
       assert(File.exists?(File.expand_path(file_path)), desc) do
-        "Expected #{Assert::U.show(file_path)} to exist."
+        "Expected #{Assert::U.show(file_path, __assert_config__)} to exist."
       end
     end
 
     def assert_not_file_exists(file_path, desc = nil)
       assert(!File.exists?(File.expand_path(file_path)), desc) do
-        "Expected #{Assert::U.show(file_path)} to not exist."
+        "Expected #{Assert::U.show(file_path, __assert_config__)} to not exist."
       end
     end
     alias_method :refute_file_exists, :assert_not_file_exists
 
     def assert_includes(object, collection, desc = nil)
       assert(collection.include?(object), desc) do
-        "Expected #{Assert::U.show(collection)} to include #{Assert::U.show(object)}."
+        "Expected #{Assert::U.show(collection, __assert_config__)}"\
+        " to include #{Assert::U.show(object, __assert_config__)}."
       end
     end
     alias_method :assert_included, :assert_includes
 
     def assert_not_includes(object, collection, desc = nil)
       assert(!collection.include?(object), desc) do
-        "Expected #{Assert::U.show(collection)} to not include #{Assert::U.show(object)}."
+        "Expected #{Assert::U.show(collection, __assert_config__)}"\
+        " to not include #{Assert::U.show(object, __assert_config__)}."
       end
     end
     alias_method :assert_not_included, :assert_not_includes
@@ -86,55 +90,91 @@ module Assert
 
     def assert_instance_of(klass, instance, desc = nil)
       assert(instance.instance_of?(klass), desc) do
-        "Expected #{Assert::U.show(instance)} (#{instance.class}) to be an instance of #{klass}."
+        "Expected #{Assert::U.show(instance, __assert_config__)} (#{instance.class})"\
+        " to be an instance of #{klass}."
       end
     end
 
     def assert_not_instance_of(klass, instance, desc = nil)
       assert(!instance.instance_of?(klass), desc) do
-        "#{Assert::U.show(instance)} (#{instance.class}) not expected to be an instance of #{klass}."
+        "Expected #{Assert::U.show(instance, __assert_config__)} (#{instance.class})"\
+        " to not be an instance of #{klass}."
       end
     end
     alias_method :refute_instance_of, :assert_not_instance_of
 
-    def assert_kind_of(klass, instance, desc=nil)
+    def assert_kind_of(klass, instance, desc = nil)
       assert(instance.kind_of?(klass), desc) do
-        "Expected #{Assert::U.show(instance)} (#{instance.class}) to be a kind of #{klass}."
+        "Expected #{Assert::U.show(instance, __assert_config__)} (#{instance.class})"\
+        " to be a kind of #{klass}."
       end
     end
 
-    def assert_not_kind_of(klass, instance, desc=nil)
+    def assert_not_kind_of(klass, instance, desc = nil)
       assert(!instance.kind_of?(klass), desc) do
-        "#{Assert::U.show(instance)} not expected to be a kind of #{klass}."
+        "Expected #{Assert::U.show(instance, __assert_config__)} (#{instance.class})"\
+        " to not be a kind of #{klass}."
       end
     end
     alias_method :refute_kind_of, :assert_not_kind_of
 
-    def assert_match(exp, act, desc=nil)
+    def assert_match(exp, act, desc = nil)
       exp_regex = String === exp && String === act ? /#{Regexp.escape(exp)}/ : exp
       assert(act =~ exp_regex, desc) do
-        "Expected #{Assert::U.show(act)} to match #{Assert::U.show(exp)}."
+        "Expected #{Assert::U.show(act, __assert_config__)}"\
+        " to match #{Assert::U.show(exp, __assert_config__)}."
       end
     end
 
-    def assert_not_match(exp, act, desc=nil)
+    def assert_not_match(exp, act, desc = nil)
       exp = String === exp && String === act ? /#{Regexp.escape(exp)}/ : exp
       assert(act !~ exp, desc) do
-        "#{Assert::U.show(act)} not expected to match #{Assert::U.show(exp)}."
+        "Expected #{Assert::U.show(act, __assert_config__)}"\
+        " to not match #{Assert::U.show(exp, __assert_config__)}."
       end
     end
     alias_method :refute_match, :assert_not_match
     alias_method :assert_no_match, :assert_not_match
 
-    def assert_nil(object, desc=nil)
-      assert(object.nil?, desc){ "Expected nil, not #{Assert::U.show(object)}." }
+    def assert_nil(object, desc = nil)
+      assert(object.nil?, desc) do
+        "Expected #{Assert::U.show(object, __assert_config__)} to be nil."
+      end
     end
 
-    def assert_not_nil(object, desc=nil)
-      assert(!object.nil?, desc){ "Expected #{Assert::U.show(object)} to not be nil." }
+    def assert_not_nil(object, desc = nil)
+      assert(!object.nil?, desc) do
+        "Expected #{Assert::U.show(object, __assert_config__)} to not be nil."
+      end
     end
     alias_method :refute_nil, :assert_not_nil
 
+    def assert_true(object, desc = nil)
+      assert(object == true, desc) do
+        "Expected #{Assert::U.show(object, __assert_config__)} to be true."
+      end
+    end
+
+    def assert_not_true(object, desc = nil)
+      assert(object != true, desc) do
+        "Expected #{Assert::U.show(object, __assert_config__)} to not be true."
+      end
+    end
+    alias_method :refute_true, :assert_not_true
+
+    def assert_false(object, desc = nil)
+      assert(object == false, desc) do
+        "Expected #{Assert::U.show(object, __assert_config__)} to be false."
+      end
+    end
+
+    def assert_not_false(object, desc = nil)
+      assert(object != false, desc) do
+        "Expected #{Assert::U.show(object, __assert_config__)} to not be false."
+      end
+    end
+    alias_method :refute_false, :assert_not_false
+
     def assert_raises(*exceptions, &block)
       desc = exceptions.last.kind_of?(String) ? exceptions.pop : nil
       err = RaisedException.new(exceptions, &block)
@@ -150,33 +190,57 @@ module Assert
     alias_method :assert_not_raises, :assert_nothing_raised
     alias_method :assert_not_raise, :assert_nothing_raised
 
-    def assert_respond_to(method, object, desc=nil)
+    def assert_respond_to(method, object, desc = nil)
       assert(object.respond_to?(method), desc) do
-        "Expected #{Assert::U.show(object)} (#{object.class}) to respond to `#{method}`."
+        "Expected #{Assert::U.show(object, __assert_config__)} (#{object.class})"\
+        " to respond to `#{method}`."
       end
     end
     alias_method :assert_responds_to, :assert_respond_to
 
-    def assert_not_respond_to(method, object, desc=nil)
+    def assert_not_respond_to(method, object, desc = nil)
       assert(!object.respond_to?(method), desc) do
-        "#{Assert::U.show(object)} (#{object.class}) not expected to respond to `#{method}`."
+        "Expected #{Assert::U.show(object, __assert_config__)} (#{object.class})"\
+        " to not respond to `#{method}`."
       end
     end
     alias_method :assert_not_responds_to, :assert_not_respond_to
     alias_method :refute_respond_to, :assert_not_respond_to
     alias_method :refute_responds_to, :assert_not_respond_to
 
-    def assert_same(exp, act, desc=nil)
+    def assert_same(exp, act, desc = nil)
       assert(act.equal?(exp), desc) do
-        "Expected #{Assert::U.show(act)} (#{act.object_id})"\
-        " to be the same as #{Assert::U.show(exp)} (#{exp.object_id})."
+        c = __assert_config__
+        exp_show = Assert::U.show_for_diff(exp, c)
+        act_show = Assert::U.show_for_diff(act, c)
+        exp_id = "#<#{exp.class}:#{'0x0%x' % (exp.object_id << 1)}>"
+        act_id = "#<#{act.class}:#{'0x0%x' % (act.object_id << 1)}>"
+
+        if c.use_diff_proc.call(exp_show, act_show)
+          "Expected #{act_id} to be the same as #{exp_id}, diff:\n"\
+          "#{c.run_diff_proc.call(exp_show, act_show)}"
+        else
+          "Expected #{Assert::U.show(act, c)} (#{act_id}) to be the same as"\
+          " #{Assert::U.show(exp, c)} (#{exp_id})."
+        end
       end
     end
 
-    def assert_not_same(exp, act, desc=nil)
+    def assert_not_same(exp, act, desc = nil)
       assert(!act.equal?(exp), desc) do
-        "#{Assert::U.show(act)} (#{act.object_id})"\
-        " not expected to be the same as #{Assert::U.show(exp)} (#{exp.object_id})."
+        c = __assert_config__
+        exp_show = Assert::U.show_for_diff(exp, c)
+        act_show = Assert::U.show_for_diff(act, c)
+        exp_id = "#<#{exp.class}:#{'0x0%x' % (exp.object_id << 1)}>"
+        act_id = "#<#{act.class}:#{'0x0%x' % (act.object_id << 1)}>"
+
+        if c.use_diff_proc.call(exp_show, act_show)
+          "Expected #{act_id} to not be the same as #{exp_id}, diff:\n"\
+          "#{c.run_diff_proc.call(exp_show, act_show)}"
+        else
+          "Expected #{Assert::U.show(act, c)} (#{act_id}) to not be the same as"\
+          " #{Assert::U.show(exp, c)} (#{exp_id})."
+        end
       end
     end
     alias_method :refute_same, :assert_not_same