assert 2.0.0.rc.1 → 2.0.0

data/Gemfile

@@ -1,4 +1,4 @@
-source "http://rubygems.org"
+source "https://rubygems.org"
 
 # Specify dependencies in assert.gemspec
 gemspec

data/Rakefile

@@ -1,3 +1 @@
-require 'bundler'
-Bundler::GemHelper.install_tasks
-
+require "bundler/gem_tasks"

data/assert.gemspec

@@ -1,22 +1,22 @@
 # -*- encoding: utf-8 -*-
-$:.push File.expand_path("../lib", __FILE__)
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require "assert/version"
 
-Gem::Specification.new do |s|
-  s.name        = "assert"
-  s.version     = Assert::VERSION
-  s.platform    = Gem::Platform::RUBY
-  s.authors     = ["Kelly Redding", "Collin Redding"]
-  s.email       = ["kelly@kellyredding.com", "collin.redding@me.com"]
-  s.homepage    = "http://github.com/redding/assert"
-  s.summary     = %q{Test::Unit style testing framework, just better than Test::Unit.}
-  s.description = %q{Test::Unit style testing framework, just better than Test::Unit.}
+Gem::Specification.new do |gem|
+  gem.name        = "assert"
+  gem.version     = Assert::VERSION
+  gem.authors     = ["Kelly Redding", "Collin Redding"]
+  gem.email       = ["kelly@kellyredding.com", "collin.redding@me.com"]
+  gem.description = %q{Test::Unit style testing framework, just better than Test::Unit.}
+  gem.summary     = %q{Test::Unit style testing framework, just better than Test::Unit.}
+  gem.homepage    = "http://github.com/redding/assert"
 
-  s.files         = `git ls-files`.split("\n")
-  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
-  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
-  s.require_paths = ["lib"]
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
 
-  s.add_dependency("ansi", ["~> 1.3"])
+  gem.add_dependency("ansi", ["~> 1.3"])
 
 end

data/lib/assert.rb

@@ -1,6 +1,5 @@
 require 'singleton'
-
-module Assert; end
+require 'assert/version'
 
 require 'assert/view'
 require 'assert/suite'

data/lib/assert/assert_runner.rb

@@ -47,7 +47,8 @@ module Assert
 
     def test_files(test_paths)
       test_paths.inject(Set.new) do |paths, path|
-        paths += Dir.glob("#{path}*") + Dir.glob("#{path}*/**/*")
+        p = File.expand_path(path, Dir.pwd)
+        paths += Dir.glob("#{p}*") + Dir.glob("#{p}*/**/*")
       end.select{ |p| is_test_file?(p) }.sort
     end
 

data/lib/assert/assertions.rb

@@ -1,267 +1,231 @@
 module Assert
   module Assertions
 
-    def assert_block(fail_desc=nil)
-      what_failed_msg ||= "Expected block to return true value."
-      assert(yield, fail_desc, what_failed_msg)
+    def assert_block(desc=nil)
+      msg ||= "Expected block to return a true value."
+      assert(yield, desc, msg)
     end
 
-    def assert_not_block(fail_desc=nil)
-      what_failed_msg ||= "Expected block to return false value."
-      assert(!yield, fail_desc, what_failed_msg)
+    def assert_not_block(desc=nil)
+      msg ||= "Expected block to return a false value."
+      assert(!yield, desc, msg)
     end
     alias_method :refute_block, :assert_not_block
 
-
-
-    def assert_raises(*args, &block)
-      assertion, what_failed_msg = check_exception(args, :raises, &block)
-      assert(assertion, nil, what_failed_msg)
+    def assert_empty(collection, desc=nil)
+      msg = "Expected #{collection.inspect} to be empty."
+      assert(collection.empty?, desc, msg)
     end
-    alias_method :assert_raise, :assert_raises
 
-    def assert_nothing_raised(*args, &block)
-      assertion, what_failed_msg = check_exception(args, :not_raises, &block)
-      assert(!assertion, nil, what_failed_msg)
+    def assert_not_empty(collection, desc=nil)
+      msg = "Expected #{collection.inspect} to not be empty."
+      assert(!collection.empty?, desc, msg)
     end
-    alias_method :assert_not_raises, :assert_nothing_raised
-    alias_method :assert_not_raise, :assert_nothing_raised
-
-
+    alias_method :refute_empty, :assert_not_empty
 
-    def assert_kind_of(klass, instance, fail_desc=nil)
-      what_failed_msg = [
-        "Expected #{instance.inspect} to be a kind ",
-        "of #{klass}, not #{instance.class}."
-      ].join
-      assert(instance.kind_of?(klass), fail_desc, what_failed_msg)
+    def assert_equal(expected, actual, desc=nil)
+      msg = "Expected #{expected.inspect}, not #{actual.inspect}."
+      assert(actual == expected, desc, msg)
     end
 
-    def assert_not_kind_of(klass, instance, fail_desc=nil)
-      what_failed_msg = [
-        "#{instance.inspect} was not expected to be a ",
-        "kind of #{klass}."
-      ].join
-      assert(!instance.kind_of?(klass), fail_desc, what_failed_msg)
+    def assert_not_equal(expected, actual, desc=nil)
+      msg = "#{actual.inspect} not expected to equal #{expected.inspect}."
+      assert(actual != expected, desc, msg)
     end
-    alias_method :refute_kind_of, :assert_not_kind_of
-
-
+    alias_method :refute_equal, :assert_not_equal
 
-    def assert_instance_of(klass, instance, fail_desc=nil)
-      what_failed_msg = [
-        "Expected #{instance.inspect} to be an instance ",
-        "of #{klass}, not #{instance.class}."
-      ].join
-      assert(instance.instance_of?(klass), fail_desc, what_failed_msg)
+    def assert_file_exists(file_path, desc=nil)
+      msg = "Expected #{file_path.inspect} to exist."
+      assert(File.exists?(File.expand_path(file_path)), desc, msg)
     end
 
-    def assert_not_instance_of(klass, instance, fail_desc=nil)
-      what_failed_msg = [
-        "#{instance.inspect} was not expected to be an ",
-        "instance of #{klass}."
-      ].join
-      assert(!instance.instance_of?(klass), fail_desc, what_failed_msg)
+    def assert_not_file_exists(file_path, desc=nil)
+      msg = "Expected #{file_path.inspect} to not exist."
+      assert(!File.exists?(File.expand_path(file_path)), desc, msg)
     end
-    alias_method :refute_instance_of, :assert_not_instance_of
-
-
+    alias_method :refute_file_exists, :assert_not_file_exists
 
-    def assert_respond_to(method, object, fail_desc=nil)
-      what_failed_msg = [
-        "Expected #{object.inspect} (#{object.class}) to ",
-        "respond to ##{method}."
-      ].join
-      assert(object.respond_to?(method), fail_desc, what_failed_msg)
+    def assert_includes(object, collection, desc=nil)
+      msg = "Expected #{collection.inspect} to include #{object.inspect}."
+      assert(collection.include?(object), desc, msg)
     end
-    alias_method :assert_responds_to, :assert_respond_to
+    alias_method :assert_included, :assert_includes
 
-    def assert_not_respond_to(method, object, fail_desc=nil)
-      what_failed_msg = [
-        "#{object.inspect} (#{object.class}) not expected to ",
-        "respond to ##{method}."
-      ].join
-      assert(!object.respond_to?(method), fail_desc, what_failed_msg)
+    def assert_not_includes(object, collection, desc=nil)
+      msg = "Expected #{collection.inspect} to not include #{object.inspect}."
+      assert(!collection.include?(object), desc, msg)
     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
-
-
+    alias_method :assert_not_included, :assert_not_includes
+    alias_method :refute_includes, :assert_not_includes
+    alias_method :refute_included, :assert_not_includes
 
-    def assert_same(expected, actual, fail_desc=nil)
-      what_failed_msg = [
-        "Expected #{expected} (#{expected.object_id}) to be the same ",
-        "as #{actual} (#{actual.object_id})."
-      ].join
-      assert(actual.equal?(expected), fail_desc, what_failed_msg)
+    def assert_instance_of(klass, instance, desc=nil)
+      msg = "Expected #{instance.inspect} (#{instance.class}) to"\
+            " be an instance of #{klass}."
+      assert(instance.instance_of?(klass), desc, msg)
     end
 
-    def assert_not_same(expected, actual, fail_desc=nil)
-      what_failed_msg = [
-        "#{expected} (#{expected.object_id}) not expected to be the same ",
-        "as #{actual} (#{actual.object_id})."
-      ].join
-      assert(!actual.equal?(expected), fail_desc, what_failed_msg)
+    def assert_not_instance_of(klass, instance, desc=nil)
+      msg = "#{instance.inspect} not expected to be an instance of #{klass}."
+      assert(!instance.instance_of?(klass), desc, msg)
     end
-    alias_method :refute_same, :assert_not_same
-
-
+    alias_method :refute_instance_of, :assert_not_instance_of
 
-    def assert_equal(expected, actual, fail_desc=nil)
-      what_failed_msg = "Expected #{expected.inspect}, not #{actual.inspect}."
-      assert(actual == expected, fail_desc, what_failed_msg)
+    def assert_kind_of(klass, instance, desc=nil)
+      msg = "Expected #{instance.inspect} (#{instance.class}) to"\
+            " be a kind of #{klass}."
+      assert(instance.kind_of?(klass), desc, msg)
     end
 
-    def assert_not_equal(expected, actual, fail_desc=nil)
-      what_failed_msg = [
-        "#{expected.inspect} not expected to be equal ", "to #{actual.inspect}."
-      ].join
-      assert(actual != expected, fail_desc, what_failed_msg)
+    def assert_not_kind_of(klass, instance, desc=nil)
+      msg = "#{instance.inspect} not expected to be a kind of #{klass}."
+      assert(!instance.kind_of?(klass), desc, msg)
     end
-    alias_method :refute_equal, :assert_not_equal
-
-
+    alias_method :refute_kind_of, :assert_not_kind_of
 
-    def assert_match(expected, actual, fail_desc=nil)
-      what_failed_msg = "Expected #{actual.inspect} to match #{expected.inspect}."
+    def assert_match(expected, actual, desc=nil)
+      msg = "Expected #{actual.inspect} to match #{expected.inspect}."
       expected = /#{Regexp.escape(expected)}/ if String === expected && String === actual
-      assert(actual =~ expected, fail_desc, what_failed_msg)
+      assert(actual =~ expected, desc, msg)
     end
 
-    def assert_not_match(expected, actual, fail_desc=nil)
-      what_failed_msg = [
-        "#{actual.inspect} not expected to ", "match #{expected.inspect}."
-      ].join
+    def assert_not_match(expected, actual, desc=nil)
+      msg = "#{actual.inspect} not expected to match #{expected.inspect}."
       expected = /#{Regexp.escape(expected)}/ if String === expected && String === actual
-      assert(actual !~ expected, fail_desc, what_failed_msg)
+      assert(actual !~ expected, desc, msg)
     end
     alias_method :refute_match, :assert_not_match
     alias_method :assert_no_match, :assert_not_match
 
-
-
-    def assert_empty(collection, fail_desc=nil)
-      what_failed_msg = "Expected #{collection.inspect} to be empty."
-      assert(collection.empty?, fail_desc, what_failed_msg)
+    def assert_nil(object, desc=nil)
+      msg = "Expected nil, not #{object.inspect}."
+      assert(object.nil?, desc, msg)
     end
 
-    def assert_not_empty(collection, fail_desc=nil)
-      what_failed_msg = "Expected #{collection.inspect} to not be empty."
-      assert(!collection.empty?, fail_desc, what_failed_msg)
+    def assert_not_nil(object, desc=nil)
+      msg = "Expected #{object.inspect} to not be nil."
+      assert(!object.nil?, desc, msg)
     end
-    alias_method :refute_empty, :assert_not_empty
-
-
+    alias_method :refute_nil, :assert_not_nil
 
-    def assert_includes(object, collection, fail_desc=nil)
-      what_failed_msg = "Expected #{collection.inspect} to include #{object.inspect}."
-      assert(collection.include?(object), fail_desc, what_failed_msg)
+    def assert_raises(*exceptions, &block)
+      desc = exceptions.last.kind_of?(String) ? exceptions.pop : nil
+      err = RaisedException.new(exceptions, &block)
+      assert(err.raised?, desc, err.msg)
     end
-    alias_method :assert_included, :assert_includes
+    alias_method :assert_raise, :assert_raises
 
-    def assert_not_includes(object, collection, fail_desc=nil)
-      what_failed_msg = "Expected #{collection.inspect} to not include #{object.inspect}."
-      assert(!collection.include?(object), fail_desc, what_failed_msg)
+    def assert_nothing_raised(*exceptions, &block)
+      desc = exceptions.last.kind_of?(String) ? exceptions.pop : nil
+      err = NoRaisedException.new(exceptions, &block)
+      assert(!err.raised?, desc, err.msg)
     end
-    alias_method :assert_not_included, :assert_not_includes
-    alias_method :refute_includes, :assert_not_includes
-    alias_method :refute_included, :assert_not_includes
-
-
+    alias_method :assert_not_raises, :assert_nothing_raised
+    alias_method :assert_not_raise, :assert_nothing_raised
 
-    def assert_nil(object, fail_desc=nil)
-      what_failed_msg = "Expected nil, not #{object.inspect}."
-      assert(object.nil?, fail_desc, what_failed_msg)
+    def assert_respond_to(method, object, desc=nil)
+      msg = "Expected #{object.inspect} (#{object.class}) to"\
+            " respond to `#{method}`."
+      assert(object.respond_to?(method), desc, msg)
     end
+    alias_method :assert_responds_to, :assert_respond_to
 
-    def assert_not_nil(object, fail_desc=nil)
-      what_failed_msg = "Expected #{object.inspect} to not be nil."
-      assert(!object.nil?, fail_desc, what_failed_msg)
+    def assert_not_respond_to(method, object, desc=nil)
+      msg = "#{object.inspect} (#{object.class}) not expected to"\
+            " respond to `#{method}`."
+      assert(!object.respond_to?(method), desc, msg)
     end
-    alias_method :refute_nil, :assert_not_nil
-
-
+    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_file_exists(file_path, fail_desc=nil)
-      what_failed_msg = "Expected #{file_path.inspect} to exist."
-      assert(File.exists?(File.expand_path(file_path)), fail_desc, what_failed_msg)
+    def assert_same(expected, actual, desc=nil)
+      msg = "Expected #{actual} (#{actual.object_id}) to"\
+            " be the same as #{expected} (#{expected.object_id})."
+      assert(actual.equal?(expected), desc, msg)
     end
 
-    def assert_not_file_exists(file_path, fail_desc=nil)
-      what_failed_msg = "Expected #{file_path.inspect} to not exist."
-      assert(!File.exists?(File.expand_path(file_path)), fail_desc, what_failed_msg)
+    def assert_not_same(expected, actual, desc=nil)
+      msg = "#{actual} (#{actual.object_id}) not expected to"\
+            " be the same as #{expected} (#{expected.object_id})."
+      assert(!actual.equal?(expected), desc, msg)
     end
-    alias_method :refute_file_exists, :assert_not_file_exists
-
+    alias_method :refute_same, :assert_not_same
 
+    # ignored assertion helpers
 
-    IGNORED_ASSERTION_HELPERS = [ :assert_throws, :assert_nothing_thrown, :assert_send,
-      :assert_operator, :refute_operator, :assert_in_epsilon, :refute_in_epsilon,
-      :assert_in_delta, :refute_in_delta
+    IGNORED_ASSERTION_HELPERS = [
+      :assert_throws,     :assert_nothing_thrown,
+      :assert_operator,   :refute_operator,
+      :assert_in_epsilon, :refute_in_epsilon,
+      :assert_in_delta,   :refute_in_delta,
+      :assert_send
     ]
     def method_missing(method, *args, &block)
       if IGNORED_ASSERTION_HELPERS.include?(method.to_sym)
-        ignore([
-          "The assertion helper '#{method}' is not supported. Please use ",
-          "another helper or the basic assert."
-        ].join)
+        ignore "The assertion `#{method}` is not supported."\
+               " Please use another assertion or the basic `assert`."
       else
         super
       end
     end
 
-    private
+    # exception raised utility classes
+
+    class CheckException
+      attr_reader :msg, :exception
 
-    def check_exception(args, which, &block)
-      fail_desc = String === args.last ? args.pop : nil
-      exceptions = args
-      begin
-        yield
-      rescue Exception => exception
+      def initialize(exceptions, &block)
+        @exceptions = exceptions
+        begin; block.call; rescue Exception => @exception; end
+        @msg = "#{exceptions_sentence(@exceptions)} #{exception_details}"
       end
-      assertion, what_failed_msg = if exception
-        test = exceptions.empty? || exceptions.any? do |exp|
-          exp.instance_of?(Module) ? exception.kind_of?(exp) : exp == exception.class
+
+      def raised?
+        !@exception.nil? && is_one_of?(@exception, @exceptions)
+      end
+
+      private
+
+      def is_one_of?(exception, exceptions)
+        exceptions.empty? || exceptions.any? do |exp|
+          exp.instance_of?(Module) ? exception.kind_of?(exp) : exception.class == exp
         end
-        [ test, exception_details(exception, which) ]
-      else
-        [ false, exception_details(exception, which) ]
       end
-      what_failed_msg = "#{exceptions_sentence(exceptions)} #{what_failed_msg}"
-      fail_desc = [ fail_desc, what_failed_msg ].compact.join("\n")
-      [ assertion, fail_desc ]
-    end
 
-    def exception_details(exception, which)
-      if exception
-        what_failed_msg = case(which)
-          when :raises
-            "exception expected, not:"
-          when :not_raises
-            "exception was not expected, but was raised:"
+      def exceptions_sentence(exceptions)
+        if exceptions.size <= 1
+          (exceptions.first || "An").to_s
+        else
+          "#{exceptions[0..-2].join(", ")} or #{exceptions[-1]}"
         end
-        backtrace = Assert::Result::Backtrace.new(exception.backtrace)
-        [ what_failed_msg,
-          "Class: <#{exception.class}>",
-          "Message: <#{exception.message.inspect}>",
-          "---Backtrace---",
-          backtrace.filtered.to_s,
-          "---------------"
-        ].compact.join("\n")
-      else
-        case(which)
-        when :raises
-          "exception expected but nothing was raised."
+      end
+
+      def exception_details(raised_msg=nil, no_raised_msg=nil)
+        if @exception
+          backtrace = Assert::Result::Backtrace.new(@exception.backtrace)
+          [ raised_msg,
+            "Class: <#{@exception.class}>",
+            "Message: <#{@exception.message.inspect}>",
+            "---Backtrace---",
+            backtrace.filtered.to_s,
+            "---------------"
+          ].compact.join("\n")
+        else
+          no_raised_msg
         end
       end
     end
 
-    def exceptions_sentence(exceptions)
-      if exceptions.size <= 1
-        (exceptions.first || "An").to_s
-      else
-        "#{exceptions[0..-2].join(", ")} or #{exceptions[-1]}"
+    class RaisedException < CheckException
+      def exception_details
+        super("exception expected, not:", "exception expected but nothing raised.")
+      end
+    end
+
+    class NoRaisedException < CheckException
+      def exception_details
+        super("exception not expected, but raised:")
       end
     end