ae 1.2.3 → 1.3.0

data/PACKAGE

@@ -0,0 +1,5 @@
+name : ae
+major: 1
+minor: 3
+patch: 0
+date : 2010-06-17

data/{qed → demo}/03_assert.rdoc

@@ -58,6 +58,27 @@ Another way to get the opposite inference, is to use +not+.
   10.assert.not == 9
 
 
+== Matchers & Lambda Assertions
+
+Passing a Proc object or an objec that responds to :to_prco, 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
+
+Additionally is the object responds to #matches? then the receiver
+will be passed to this method to determine passage.
+
+  palindrome = Object.new
+  def palindrome.matches?(word)
+    word == word.reverse
+  end
+
+  "abracarba".assert palindrome
+
+
 == Identity Assertions
 
 Rather then the general form:
@@ -237,26 +258,10 @@ Or minimum range.
   3.in_epsilon?(3,5)
 
 
-== Custom Lambda Assertions
-
-Passing a lambda to the subjunctive method, 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{ |x| x == x.reverse }
-
-  "abracarba".assert palindrome
-
-
 == Verifying Object State
 
-NOTE: <i>This functionality is not currently supported, but is being
-considered for a future version.</i>
-
-If no block parameter is designated and the receiver differs from +self+
-in scope of the given block, then the block is evaluated in the scope of
-the receiver via +instance_eval+. This can be also be used to verify the
-state of an object.
+Not surprisingly if underlying object state needs to be verified, +instance_eval+
+can be used in conjunction with +assert+.
 
   class X
     attr :a
@@ -265,20 +270,20 @@ state of an object.
 
   x = X.new(4)
 
-  x.assert do
+  x.assert.instance_eval do
     4 == @a
   end
 
-And should it fail...
+And should it fail
 
   Assertion.assert.raised? do
-    x.assert do
+    x.assert.instance_eval do
       5 == @a
     end
   end
 
-For some this might be considered poor form, i.e. to test underlying
-implementation. You will get no argument here. It should be used
-thoughtfully, but I would not bet against there being occasions
-when such validations might be handy.
+For some testing underlying implementation might be considered poor
+form. You will get no argument here. It should be used thoughtfully,
+but I would not bet against there being occasions when such validations
+might be handy.
 

data/{qed → demo}/05_expect.rdoc

@@ -1,12 +1,13 @@
 = Expect Method
 
-Expect is another optional 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.
+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
@@ -67,18 +68,38 @@ We can use #expected to make the receiver the object of expectation.
   end
 
 
-== Function without Block
+== 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.
+In which case it works just like #assert, including negative forms.
+
+  10.expect! == 11
+  10.forbid  == 11
+
 

data/lib/ae.rb

@@ -1,8 +1,24 @@
 require 'yaml'
 
 module AE
-  vers = YAML.load(File.read(File.dirname(__FILE__) + '/ae/version.yml'))
-  VERSION = vers.values_at('major', 'minor', 'patch', 'state', 'build').compact.join('.')
+  DIRECTORY = File.dirname(__FILE__) + '/ae'
+
+  PROFILE = YAML.load(File.new(DIRECTORY + '/profile.yml')) rescue {}
+  PACKAGE = YAML.load(File.new(DIRECTORY + '/package.yml')) rescue {}
+
+  VERSION = PACKAGE.values_at('major','minor','patch','build').compact.join('.')
+
+  #
+  def self.const_missing(name)
+    key = name.to_s.downcase
+    if PACKAGE.key?(key)
+      PACKAGE[key]
+    elsif PROFILE.key?(key)
+      PROFILE[key]
+    else
+      super(name)
+    end
+  end
 end
 
 require 'ae/assert'

data/lib/ae/assert.rb

@@ -23,12 +23,12 @@ module AE
     #   assert{ 4==3 }
     #
     def assert(*args, &block)
-      return Assertor.new(self, :backtrace=>caller).assert(*args, &block)
+      Assertor.new(self, :backtrace=>caller).assert(*args, &block)
     end
 
     # Same as 'object.assert == other'.
     def assert=(cmp)
-      return Assertor.new(self, :backtrace=>caller).assert(*args, &block) == cmp
+      Assertor.new(self, :backtrace=>caller).assert(*args, &block) == cmp
     end
 
     # Assert not an operational relationship.
@@ -43,7 +43,7 @@ module AE
     # may be possible in Ruby 1.9.
     #
     def assert!(*args, &block)
-      return Assertor.new(self, :backtrace=>caller).not(*args, &block)
+      Assertor.new(self, :backtrace=>caller).not.assert(*args, &block)
     end
 
     # Alias for #assert!.

data/lib/ae/assertor.rb

@@ -27,42 +27,101 @@ class Assertor
     @negated   = !!opts[:negated]
   end
 
+  # Negate the meaning of the assertion.
   #
-  def not(msg=nil, &block)
+  # TODO: Should this return a new Assertor instead of inplace negation?
+  def not(msg=nil)
     @negated = !@negated
-    block ? assert(msg, &block) : self
+    @message = msg if msg
+    self
   end
 
   # Internal assert, provides all functionality associated
-  # with external #assert Object method.
+  # with external #assert method. (See Assert#assert)
+  #
+  # NOTE: I'm calling YAGNI on using extra arguments to pass
+  # to the block. The interface is much nicer if a macro is
+  # created to handle any neccessry arguments. Eg.
+  #
+  #   assert something(parameter)
+  #
+  # instead of
+  #
+  #   assert something, parameter
   #
-  # TODO: I'm calling YAGNI on any extra arguments to the block.
   def assert(*args, &block)
     return self if args.empty? && !block_given?
-    block = args.shift if !block_given? && Proc === args.first
-    if block
-      pass = block.arity > 0 ? block.call(@delegate) : block.call  #@delegate.instance_eval(&block)
-      msg = args.shift || @message || block.inspect
+
+    target = block || args.shift
+
+    if Proc === target || target.respond_to?(:to_proc)
+      block  = target.to_proc
+      match  = args.shift
+      result = block.arity > 0 ? block.call(@delegate) : block.call
+      if match
+        pass = (match == result)
+        msg  = @message || "#{match.inspect} == #{result.inspect}"
+      else
+        pass = result
+        msg  = @message || block.inspect  # "#{result.inspect}"
+      end
+    elsif target.respond_to?(:matches?)
+      pass   = target.matches?(@delegate)
+      msg    = @message || matcher_message(target) || target.inspect
     else
-      pass = args.shift  # truthiness
-      msg  = args.shift
+      pass   = target     # truthiness
+      msg    = args.shift # optional mesage for TestUnit compatiability
     end
+
     __assert__(pass, msg)
   end
 
+  # Internal expect, provides all functionality associated
+  # with external #expect method. (See Expect#expect)
   #
-  #def expect(*args, &block)
-  #  return self if args.empty? && !block_given?
-  #  block = args.shift if !block_given? && Proc === args.first
-  #  if block
-  #    pass = block.arity > 0 ? block.call(@delegate) : block.call  #@delegate.instance_eval(&block)
-  #    msg = args.shift || @message || block.inspect
-  #  else
-  #    pass = args.shift  # truthiness
-  #    msg  = args.shift
-  #  end
-  #  __assert__(pass, msg)
-  #end
+  #--
+  # TODO: Should we deprecate the receiver matches in favor of #expected ?
+  # In other words, should the <code>|| @delegate</code> be dropped?
+  #
+  # TODO: respond_to?(:exception) && match = exception if Exception === match
+  #++
+  def expect(*args, &block)
+    # same as #assert if no arguments of block given
+    return self if args.empty? && !block_given?
+
+    target = block || args.shift
+
+    if Proc === target || target.respond_to?(:to_proc)
+      block = target.to_proc
+      match = args.shift || @delegate
+      if Exception === match || (Class===match && match.ancestors.include?(Exception))
+        begin
+          block.arity > 0 ? block.call(@delegate) : block.call
+          pass = false
+          msg  = "#{match} not raised"
+        rescue match => error
+          pass = true
+          msg  = "#{match} raised"
+        rescue Exception => error
+          pass = false
+          msg  = "#{match} expected but #{error.class} was raised"
+        end
+      else
+        result = block.arity > 0 ? block.call(@delegte) : block.call
+        pass   = (match === result)
+        msg    = @message || "#{match.inspect} === #{result.inspect}"
+      end
+    elsif target.respond_to?(:matches?)
+      pass = target.matches?(@delegate)
+      msg  = @message || matcher_message(target) || target.inspect
+    else
+      pass = (target === @delegate)
+      msg  = @message || "#{target.inspect} === #{@delegate.inspect}"
+    end
+
+    #flunk(msg, caller) unless pass
+    __assert__(pass, msg)
+  end
 
   #
   def flunk(msg=nil)
@@ -112,6 +171,19 @@ class Assertor
     @negated ? !pass : !!pass
   end
 
+  #
+  def matcher_message(matcher)
+    if @negated
+      if matcher.respond_to?(:negative_failure_message)
+        return matcher.failure_message
+      end
+    end
+    if matcher.respond_to?(:failure_message)
+      return matcher.failure_message
+    end
+    false
+  end
+
   # TODO: Ultimately better messages might be nice.
   #
   #def self.message(op,&block)

data/lib/ae/expect.rb

@@ -39,65 +39,16 @@ module AE
     #
     #   4.expect == 3
     #
-    #
     def expect(*args, &block)
-      return Assertor.new(self, :backtrace=>caller) if args.empty? && !block
-      block = args.shift if !block_given? && Proc === args.first
-      if block
-        exp = args.empty? ? self : args.shift
-        if Exception === exp || (Class===exp && exp.ancestors.include?(Exception))
-          begin
-            block.call
-            pass = false
-            msg  = "#{exp} not raised"
-          rescue exp => error
-            pass = true
-          rescue Exception => error
-            pass = false
-            msg  = "#{exp} expected but #{error.class} was raised"
-          end
-        else
-          res  = block.call
-          pass = (exp === res)
-          msg  = "#{exp} === #{res}"
-        end
-      else
-        pass = (exp === self)
-        msg  = "#{exp} === #{self}"
-      end
-      flunk(msg, caller) unless pass
+      Assertor.new(self, :backtrace=>caller).expect(*args, &block)
     end
 
     # Designate a negated expectation. Read this as "expect not".
     #
     # See #expect.
     #
-    def expect!(exp=NoArgument, &block)
-      return Assertor.new(self, :backtrace=>caller) if args.empty? && !block
-      block = args.shift if !block_given? && Proc === args.first
-      if block
-        exp = args.empty? ? self : args.shift
-        if Exception === exp || (Class===exp && exp.is?(Exception))
-          begin
-            block.call
-            pass = true
-          rescue exp => error
-            pass = false
-            msg  = "#{exp} raised"
-          rescue Exception => error
-            pass = true
-            #msg  = "#{exp} expected but #{error.class} was raised"
-          end
-        else
-          res  = block.call
-          pass = !(exp === res)
-          msg  = "not #{exp} === #{res}"
-        end
-      else
-        pass = !(exp === self)
-        msg  = "not #{exp} === #{self}"
-      end
-      flunk(msg, caller) unless pass
+    def expect!(*args, &block)
+      Assertor.new(self, :backtrace=>caller).not.expect(*args, &block)
     end
 
     # Alias for #expect! method.

data/lib/ae/package.yml

@@ -0,0 +1,5 @@
+name : ae
+major: 1
+minor: 3
+patch: 0
+date : 2010-06-17

data/lib/ae/profile.yml

@@ -0,0 +1,18 @@
+--- 
+title  : AE
+summary: Assertive Expressive
+suite  : proutils
+contact: trans <transfire@gmail.com>
+created: 2008-08-17 09:00:06
+authors: Thomas Sawyer
+license: MIT
+
+description:
+  Assertive Expressive is an assertions library intended for reuse
+  by any TDD, BDD or the like system.
+
+resources:
+  homepage: http://proutils.github.com/ae
+  repository: git://github.com/proutils/ae.git
+
+copyright: Copyright (c) 2008 Thomas Sawyer

data/lib/ae/subjunctive.rb

@@ -12,13 +12,6 @@ module AE
   #
   module Subjunctive
 
-    #
-    #def not(&block)
-    #  @negated = !@negated
-    #  return self if !block_given?
-    #  be(*args, &block)
-    #end
-
     # Like #assert, except if an argument if provided and no block,
     # uses #equate? to compare the argument to the receiver. This
     # allows for statements of the form:

data/lib/ae/subjunctive/must.rb

@@ -28,7 +28,7 @@ module AE
     #   4.must! == 4  #=> Assertion Error
     #
     def must!(*args, &block)
-      Assertor.new(self, :backtrace=>caller).not(*args, &block)
+      Assertor.new(self, :backtrace=>caller).not.be(*args, &block)
     end
 
     # Perhaps not literally the counter-term to *must* (rather *will*),

data/lib/ae/subjunctive/should.rb

@@ -29,7 +29,7 @@ module AE
     #   4.should! == 4  #=> Assertion Error
     #
     def should!(*args, &block)
-      Assertor.new(self, :backtrace=>caller).not(*args, &block)
+      Assertor.new(self, :backtrace=>caller).not.be(*args, &block)
     end
 
     # Not quite the literally the counter-term to *should* (rather *shall*), but

metadata

@@ -1,12 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: ae
 version: !ruby/object:Gem::Version 
+  hash: 27
   prerelease: false
   segments: 
   - 1
-  - 2
   - 3
-  version: 1.2.3
+  - 0
+  version: 1.3.0
 platform: ruby
 authors: 
 - Thomas Sawyer
@@ -14,16 +15,18 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-06-08 00:00:00 -04:00
+date: 2010-06-17 00:00:00 -04:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: syckle
   prerelease: false
   requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
+        hash: 3
         segments: 
         - 0
         version: "0"
@@ -33,9 +36,11 @@ dependencies:
   name: qed
   prerelease: false
   requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
+        hash: 3
         segments: 
         - 0
         version: "0"
@@ -50,12 +55,12 @@ extensions: []
 extra_rdoc_files: 
 - README.rdoc
 files: 
-- qed/01_overview.rdoc
-- qed/02_assertion.rdoc
-- qed/03_assert.rdoc
-- qed/04_subjunctive.rdoc
-- qed/05_expect.rdoc
-- qed/06_counts.rdoc
+- demo/01_overview.rdoc
+- demo/02_assertion.rdoc
+- demo/03_assert.rdoc
+- demo/04_subjunctive.rdoc
+- demo/05_expect.rdoc
+- demo/06_counts.rdoc
 - lib/ae/assert.rb
 - lib/ae/assertion.rb
 - lib/ae/assertor.rb
@@ -63,18 +68,19 @@ files:
 - lib/ae/expect.rb
 - lib/ae/legacy.rb
 - lib/ae/must.rb
+- lib/ae/package.yml
+- lib/ae/profile.yml
 - lib/ae/should.rb
 - lib/ae/subjunctive/must.rb
 - lib/ae/subjunctive/should.rb
 - lib/ae/subjunctive.rb
-- lib/ae/version.yml
 - lib/ae.rb
 - PROFILE
+- PACKAGE
 - LICENSE
 - README.rdoc
 - HISTORY
 - REQUIRE
-- VERSION
 has_rdoc: true
 homepage: http://proutils.github.com/ae
 licenses: []
@@ -88,23 +94,27 @@ rdoc_options:
 require_paths: 
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      hash: 3
       segments: 
       - 0
       version: "0"
 required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      hash: 3
       segments: 
       - 0
       version: "0"
 requirements: []
 
 rubyforge_project: ae
-rubygems_version: 1.3.6
+rubygems_version: 1.3.7
 signing_key: 
 specification_version: 3
 summary: Assertive Expressive

data/VERSION

@@ -1,6 +0,0 @@
-name : ae
-major: 1
-minor: 2
-patch: 3
-date : 2010-06-07
-

data/lib/ae/version.yml

@@ -1,6 +0,0 @@
-name : ae
-major: 1
-minor: 2
-patch: 3
-date : 2010-06-07
-