ae 1.8.2 → 1.9.0

data/demo/05_expect.md

@@ -0,0 +1,104 @@
+# Expect Method
+
+Expect is another assertion nomenclature available for use in your
+tests or specifications. Inspired by Jay Fields' Expectations library,
+it provides convenient syntax for creating exception and case equality
+assertions.
+
+    require 'ae/expect'
+
+
+## Underlying Comparison
+
+Expect uses `#===` for comparison. So providing an argument and a block
+to #expect we can test for a somewhat broader range of compassion
+than #assert. For example we can test for a subclass.
+
+    expect Numeric do
+      3
+    end
+
+  Assertion.assert.raised? do
+    expect Numeric do
+      "3"
+    end
+  end
+
+
+## Exception Expectation
+
+If the comparator is an Exception class or a instance of an Exception class,
+then #expect will check to see if the block raises that kind of exception.
+
+    expect StandardError do
+      some_undefined_method
+    end
+
+    expect Assertion do
+      expect(nil)
+    end
+
+This is an important distinction to note because it means `#expect` can not be used
+if verify instances of Exception classes.
+
+    Assertion.assert.raised? do
+      expect Exception do
+        Exception.new
+      end
+    end
+
+
+## Regex Expectations
+
+That #expect entails `#===` also means we can check for Regexp matches.
+
+    expect /x/ do
+      "oooxooo"
+    end
+
+
+## Expected Method
+
+We can use #expected to make the receiver the object of expectation.
+
+    x = "dummy"
+
+    /x/.expected do
+      "x"
+    end
+
+
+## Without Block
+
+Without a block, the receiver is compared to the argument.
+
+    x.expect String
+
+
+## Negative Forms
+
+Like #assert, `#expect` has a negated form called #expect!
+
+    expect! /x/ do
+      "o"
+    end
+
+The pure word form for those who do not like the clever use of the
+explimation mark is #forbid.
+
+    forbid /x/ do
+      "o"
+    end
+
+
+## Functor, or Higher Order Function
+
+Like #assert, #expect can be used used as a *fluid* notation.
+
+    10.expect == 10
+
+In which case it works just like `#assert`, including negative forms.
+
+    10.expect! == 11
+    10.forbid  == 11
+

data/demo/06_counts.md

@@ -0,0 +1,33 @@
+# Assertion Counts
+
+AE tracks the number of assertions made and the number that failed to pass.
+We can reset the count using the +recount+ class method.
+
+    old_counts = AE::Assertor.recount
+
+For example if we have one assertion pass and another fail.
+
+    assert(true)
+
+    expect Assertion do
+      assert(false)
+    end
+
+We will see that AE counted three assertions and one failure.
+
+    counts = AE::Assertor.counts.dup
+
+    counts[:total].assert == 3
+    counts[:pass].assert  == 2
+    counts[:fail].assert  == 1
+
+The #expect call is an assertion too, which is why the total count is 3
+rather than 2.
+
+Now that we are done checking counts we will restore them so that
+any other demos being run with this will tally correctly.
+
+    AE::Assertor.recount(old_counts)
+    AE::Assertor.counts[:total] += 3
+    AE::Assertor.counts[:pass]  += 3
+

data/demo/07_matchers.md

@@ -0,0 +1,34 @@
+# Matchers
+
+Matchers are simply Procs or objects with the proper interface that can be
+passed to #assert or #refute (or other Assertor) as an ecapsulated test.
+
+## Proc or #to_proc
+
+Passing a Proc object or an object that responds to `:to_proc`, will use it
+as if it were a block of the method. This allows for a simple way to quickly
+create reusable assertions.
+
+    palindrome = lambda{ |word| word == word.reverse }
+
+    "abracarba".assert palindrome
+
+## #matches?
+
+Additionally if an object responds to #matches? then the receiver
+will be passed to this method to determine if the assertion passes.
+
+    palindrome = Object.new
+
+    def palindrome.matches?(word)
+      word == word.reverse
+    end
+
+    "abracarba".assert palindrome
+
+## RSpec, Shoulda and other 3rd-Party Matchers 
+
+With tha addition of #matches?, AE supports the same interface for matchers
+as RSpec. Any matcher library designed for use with RSpec should therefore
+be usable with AE as well. This includes RSpecs own matchers and Shoulda's
+excellent Rails matchers.

data/demo/08_check.md

@@ -0,0 +1,61 @@
+## Check Ok/No
+
+The Check library is an optional library that can be used
+to conveniently speed-up construction of reptitive assertions.
+
+To use it, first require the library, then include the mixin
+into the namespace in which you will utilize it.
+
+    require 'ae/check'
+
+    include AE::Check
+
+Now we can define ok/no check procedures. A one-off procedure is
+defined with a block only.
+
+    check do |x, y|
+      x == y
+    end
+
+    ok 1,1
+    no 1,2
+
+To define reusable check procedures, give the procedure a name.
+
+    check :palindrome do |x|
+      x.reverse == x
+    end
+
+This will also cause the current check method to be set.
+Later in the code, the check procedure can be reset to this
+by just passing the name.
+
+    check :palindrome
+
+    ok 'abracarba'
+    no 'foolishness'
+
+The Check mixin comes preloaded with a few standard checks.
+By default the `:equality` procedure is used.
+
+    check :equality
+
+    ok 1=>1.0
+
+Notice the use of the hash argument here. This is a useful construct for
+many check procedures becuase it it akin to the `#=>` pattern we often
+see in code examples and it also allows for multiple assertions in one call.
+For instance, in the case of `:equality`, multiple entries convey a
+meaning of logical-or.
+
+    ok 1=>2, 1.0=>1
+
+This would pass because the second assertion of equality is true.
+
+Another built in check is `:case_equality` which uses `#===` instead of `#==`
+to make the comparison.
+
+    check :case_equality
+
+    ok 1=>Integer
+

data/demo/applique/ae.rb

@@ -0,0 +1 @@
+require 'ae'

data/lib/ae/adapters/minitest.rb

@@ -1,46 +1,41 @@
 require 'ae'
 
-AE.assertion_error = ::MiniTest::Assertion
+AE.assertion_error = ::Minitest::Assertion
 
-module MiniTest #:nodoc:
-  class Unit #:nodoc:
+module Minitest #:nodoc:
+  class Test #:nodoc:
+    # Override capture_exceptions to recognize AE assertion errors
+    # as test failures rather than errors.
+    alias_method :capture_exceptions_without_ae, :capture_exceptions
 
-    # MiniTest tracks assertion counts internally in it's Unit class via the 
-    # +assertion_count+ attribute. To work with AE we need add in AE's assertion
-    # total by overriding the +assertion_count+ method.
-    #
-    # @return [Integer] Number of assertions made.
-    def assertion_count
-      @assertion_count + AE::Assertor.counts[:total]
-    end
-
-    # To teach MiniTest to recognize AE's expanded concept of assertions
-    # we add in an extra capture clause to it's #puke method.
-    #
-    # @return [String] Status code is `S`, `F`, or `E`.
-    def puke k, m, e
-      case e
-      when MiniTest::Skip
-        @skips += 1
-        return "S" unless @verbose
-        e = "Skipped:\n#{m}(#{k}) [#{location e}]:\n#{e.message}\n"
-      when MiniTest::Assertion
-        @failures += 1
-        e = "Failure:\n#{m}(#{k}) [#{location e}]:\n#{e.message}\n"
+    def capture_exceptions
+      yield
+    rescue *PASSTHROUGH_EXCEPTIONS
+      raise
+    rescue Assertion => e
+      self.failures << e
+    rescue Exception => e
+      if e.respond_to?(:assertion?) && e.assertion?
+        failure = Assertion.new(e.message)
+        failure.set_backtrace(e.backtrace)
+        self.failures << failure
       else
-        if e.respond_to?(:assertion?) && e.assertion?
-          @failures += 1
-          e = "Failure:\n#{m}(#{c}) [#{location e}]:\n#{e.message}\n"
-        else
-          @errors += 1
-          b = MiniTest::filter_backtrace(e.backtrace).join "\n    "
-          e = "Error:\n#{m}(#{k}):\n#{e.class}: #{e.message}\n    #{b}\n"
-        end
+        self.failures << UnexpectedError.new(sanitize_exception(e))
       end
-      @report << e
-      e[0, 1]
     end
-
   end
 end
 
+class AE::Assertor #:nodoc:
+  # MiniTest tracks assertion counts internally. To work with AE we
+  # override increment_counts to also update AE's own counter.
+  def self.increment_counts(pass)
+    counts[:total] += 1
+    if pass
+      counts[:pass] += 1
+    else
+      counts[:fail] += 1
+    end
+    return counts
+  end
+end

data/lib/ae/adapters/testunit.rb

@@ -2,63 +2,33 @@ require 'ae'
 
 AE.assertion_error = ::Test::Unit::AssertionFailedError
 
-# TestUnit uses #add_assertion on it's +result+ object to track counts.
-# We capture the result object by overriding the TestCase#run method,
-# store it in a global variable and then use it when AE increments
-# assertion counts.
-#
-# In addition we teach #run to recognize any Exception class that
-# responds to #assertion? in the affirmative as an assertion
-# rather than an error.
-#
 module Test #:nodoc:
   module Unit #:nodoc:
-    class TestCase #:nodoc:
-      # These exceptions are not caught by #run.
-      PASSTHROUGH_EXCEPTIONS = [NoMemoryError, SignalException, Interrupt, SystemExit] 
-      # Runs the individual test method represented by this
-      # instance of the fixture, collecting statistics, failures
-      # and errors in result.
-      def run(result)
-        $_test_unit_result = result
-        yield(STARTED, name)
-        @_result = result
-        begin
-          setup
-          __send__(@method_name)
-        rescue AssertionFailedError => e
-          add_failure(e.message, e.backtrace)
-        rescue Exception => e
-          if e.respond_to?(:assertion?) && e.assertion?
-            add_failure(e.message, e.backtrace)
-          else
-            raise if PASSTHROUGH_EXCEPTIONS.include? $!.class
-            add_error($!)
-          end
-        ensure
-          begin
-            teardown
-          rescue AssertionFailedError => e
-            add_failure(e.message, e.backtrace)
-          rescue Exception => e
-            if e.respond_to?(:assertion?) && e.assertion?
-              add_failure(e.message, e.backtrace)
-            else
-              raise if PASSTHROUGH_EXCEPTIONS.include? $!.class
-              add_error($!)
-            end
-          end
+
+    module AEAssertionHandler
+      class << self
+        def included(base)
+          base.exception_handler(:handle_ae_assertion_error)
         end
-        result.add_run
-        yield(FINISHED, name)
-      end 
+      end
+
+      private
+      def handle_ae_assertion_error(exception)
+        return false unless exception.respond_to?(:assertion?) && exception.assertion?
+        problem_occurred
+        add_failure(exception.message, exception.backtrace)
+        true
+      end
+    end
+
+    class TestCase #:nodoc:
+      include AEAssertionHandler
     end
   end
 end
 
 class AE::Assertor #:nodoc:
   def self.increment_counts(pass)
-    $_test_unit_result.add_assertion if $_test_unit_result
     counts[:total] += 1
     if pass
       counts[:pass] += 1
@@ -68,4 +38,3 @@ class AE::Assertor #:nodoc:
     return counts
   end
 end
-

data/lib/ae/core_ext/helpers.rb

@@ -161,7 +161,7 @@ class Proc
   # TODO: wrong place, change yield?
   def change?
     pre_result = yield
-    called = call
+    call
     post_result = yield
     pre_result != post_result
   end

data/lib/ae/version.rb

@@ -1,21 +1,3 @@
 module AE
-  # Access project metadata.
-  #
-  # @return [Hash]
-  def self.metadata
-    @metadata ||= (
-      require 'yaml'
-      YAML.load(File.new(File.dirname(__FILE__) + '/../ae.yml'))
-    )
-  end
-
-  #
-  def self.const_missing(name)
-    key = name.to_s.downcase
-    metadata[key] || super(name)
-  end
-
-  # Becuase Ruby 1.8~ gets in the way :(
-  VERSION = metadata['version']
+  VERSION = '1.9.0'
 end
-

metadata

@@ -1,78 +1,78 @@
 --- !ruby/object:Gem::Specification
 name: ae
 version: !ruby/object:Gem::Version
-  version: 1.8.2
-  prerelease: 
+  version: 1.9.0
 platform: ruby
 authors:
 - Trans
-autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-02-18 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ansi
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: detroit
+  name: rake
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '13'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '13'
 - !ruby/object:Gem::Dependency
   name: qed
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '2.9'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
-description: ! "Assertive Expressive is an assertions library specifically designed
-  \nfor reuse by other test frameworks."
+        version: '2.9'
+description: Assertive Expressive is an assertions library specifically designed for
+  reuse by other test frameworks.
 email:
 - transfire@gmail.com
 executables: []
 extensions: []
-extra_rdoc_files:
-- DEMO.rdoc
+extra_rdoc_files: []
+files:
 - HISTORY.md
-- README.md
+- LICENSE.txt
 - NOTICE.md
-files:
-- .ruby
-- .yardopts
+- README.md
+- demo/01_overview.md
+- demo/02_assertion.md
+- demo/03_assert.md
+- demo/04_subjunctive.md
+- demo/05_expect.md
+- demo/06_counts.md
+- demo/07_matchers.md
+- demo/08_check.md
+- demo/applique/ae.rb
+- lib/ae.rb
 - lib/ae/adapter.rb
 - lib/ae/adapters/minitest.rb
 - lib/ae/adapters/rspec.rb
@@ -83,9 +83,9 @@ files:
 - lib/ae/assertor.rb
 - lib/ae/basic_object.rb
 - lib/ae/check.rb
+- lib/ae/core_ext.rb
 - lib/ae/core_ext/exception.rb
 - lib/ae/core_ext/helpers.rb
-- lib/ae/core_ext.rb
 - lib/ae/expect.rb
 - lib/ae/legacy.rb
 - lib/ae/must.rb
@@ -93,36 +93,25 @@ files:
 - lib/ae/should.rb
 - lib/ae/subjunctive.rb
 - lib/ae/version.rb
-- lib/ae.rb
-- lib/ae.yml
-- DEMO.rdoc
-- HISTORY.md
-- README.md
-- NOTICE.md
-homepage: http://rubyworks.github.com/ae
+homepage: https://github.com/rubyworks/ae
 licenses:
 - BSD-2-Clause
-post_install_message: 
+metadata: {}
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: '3.1'
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 1.8.24
-signing_key: 
-specification_version: 3
+rubygems_version: 3.6.9
+specification_version: 4
 summary: Assertive Expressive
 test_files: []
-has_rdoc: 

data/.yardopts

@@ -1,7 +0,0 @@
---title "AE API"
---protected
---private
-lib/
--
-[A-Z]*.*
-