ae 1.3.0 → 1.4.0

data/{HISTORY → HISTORY.rdoc}

@@ -1,9 +1,43 @@
 = RELEASE HISTORY
 
+== 1.4.0 / 2010-09-02
+
+Version 1.4 brings Ruby 1.9 compatibility. The Assertor class is now a
+subclass of BasicObject. This fixes an issues Assertor would had
+applying to methods defined both in a class and Kernel.
+
+Changes:
+
+* Assertor is a subclass of BasicObject.
+* Use custom BasicObject when using Ruby 1.8.
+* Add #assert= which works like `assert ==`.
+* Add #refute= which works like `refute ==`.
+
+
+== 1.3.0 / 2010-06-17
+
+New release of AE adds support for RSpec-style matchers. This means
+it should be usable with Shoulda 3.0 and any other matchers library.
+This release also cleans up the underlying code, which is now
+extremely clean. Lastly a smal API change allows #asser to compare
+it's argument to the return of it's block using #==, just as #expect
+does using #===.
+
+Changes:
+
+* Add RSpec-style matchers support.
+* Move #expect code to Assertor.
+* #assert method can do equality camparison.
+
+
 == 1.2.3 / 2010-06-07
 
 This release is a quick fix, which adds a missing `require 'yaml'`.
 
+Changes:
+
+* Add missing require 'yaml'.
+
 
 == 1.2.2 / 2010-06-06
 

data/NOTICE

@@ -0,0 +1,14 @@
+= COPYRIGHT NOTICES
+
+== BasicObject
+
+BasicObject is based on Jim Weirich's BlankSlate.
+
+    BlankSlate
+    Copyright 2004, 2006 by Jim Weirich (jim@weirichhouse.org).
+    All rights reserved.
+
+    Permission is granted for use, copying, modification, distribution,
+    and distribution of modified versions of this work as long as the
+    above copyright notice is included.
+

data/expo/cucumber/features/cucumber.feature

@@ -0,0 +1,10 @@
+Feature: Cucumber SUpport
+  In order to please people who like Cucumber
+  As an AE user
+  I want to be able to use assert in my step definitions
+
+  Scenario: assert
+    Given x = 5
+    And y = 5
+    Then I can assert that x.assert == y
+

data/expo/cucumber/features/step_definitions/cucumber_steps.rb

@@ -0,0 +1,11 @@
+
+Given /^(\w+) = (\w+)$/ do |var, value|
+  instance_variable_set("@#{var}", value)
+end
+
+Then /^I can assert that (\w+).assert == (\w+)$/ do |var_a, var_b|
+  a = instance_variable_get("@#{var_a}")
+  b = instance_variable_get("@#{var_b}")
+  a.assert == b
+end
+

data/expo/cucumber/features/support/env.rb

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

data/lib/ae.rb

@@ -3,21 +3,15 @@ require 'yaml'
 module AE
   DIRECTORY = File.dirname(__FILE__) + '/ae'
 
-  PROFILE = YAML.load(File.new(DIRECTORY + '/profile.yml')) rescue {}
-  PACKAGE = YAML.load(File.new(DIRECTORY + '/package.yml')) rescue {}
+  PROFILE = YAML.load(File.new(DIRECTORY + '/meta/profile')) rescue {}
+  PACKAGE = YAML.load(File.new(DIRECTORY + '/meta/package')) rescue {}
 
-  VERSION = PACKAGE.values_at('major','minor','patch','build').compact.join('.')
+  VERSION = PACKAGE['version']
 
   #
   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
+    PACAKGE[key] || PROFILE[key] || super(name)
   end
 end
 

data/lib/ae/assert.rb

@@ -28,29 +28,33 @@ module AE
 
     # Same as 'object.assert == other'.
     def assert=(cmp)
-      Assertor.new(self, :backtrace=>caller).assert(*args, &block) == cmp
+      Assertor.new(self, :backtrace=>caller).assert == cmp
     end
 
     # Assert not an operational relationship.
     # Read it as "assert not".
     #
-    #   4.assert! == 4
+    #   4.refute == 4  #=> Assertion Error
     #
     # See #assert.
-    #
-    # AUHTOR'S NOTE: This method would not be necessary if Ruby would allow
-    # +!=+ to be define as a method, or at least +!+ as a unary method. This
-    # may be possible in Ruby 1.9.
-    #
-    def assert!(*args, &block)
+    def refute(*args, &block)
       Assertor.new(self, :backtrace=>caller).not.assert(*args, &block)
     end
 
+    # Same as 'object.assert == other'.
+    def refute=(cmp)
+      Assertor.new(self, :backtrace=>caller).not.assert == cmp
+    end
+
     # Alias for #assert!.
     #
-    # 4.refute == 4  #=> Assertion Error
+    #   4.assert! == 4
     #
-    alias_method :refute, :assert!
+    # NOTE: This method would not be necessary if Ruby would allow
+    # +!=+ to be define as a method, or at least +!+ as a unary method.
+    # This may be possible in Ruby 1.9.
+    alias_method :assert!, :refute
+   
   end
 
 end

data/lib/ae/assertor.rb

@@ -1,4 +1,5 @@
 require 'ae/assertion'
+require 'ae/basic_object'
 
 # = Assertor (Assertion Functor)
 #
@@ -10,13 +11,17 @@ require 'ae/assertion'
 # in most respects, but is conditioned on the operation applied,
 # rather then simply passing-off to an alternate reciever.
 #
-class Assertor
+class Assertor < AE::BasicObject
 
   $assertions = 0
   $failures   = 0
 
   #
-  instance_methods.each{ |m| protected m unless /^__/ =~ m.to_s }
+  #instance_methods.each{ |m| protected m unless /^(__|object_id$)/ =~ m.to_s }
+
+  if ::RUBY_VERSION >= '1.9'
+    eval "private :==, :!, :!="  # using eval here b/c it's a syntax error in 1.8-
+  end
 
   # New Assertor.
   #
@@ -50,11 +55,11 @@ class Assertor
   #   assert something, parameter
   #
   def assert(*args, &block)
-    return self if args.empty? && !block_given?
+    return self if args.empty? && !block
 
     target = block || args.shift
 
-    if Proc === target || target.respond_to?(:to_proc)
+    if ::Proc === target || target.respond_to?(:to_proc)
       block  = target.to_proc
       match  = args.shift
       result = block.arity > 0 ? block.call(@delegate) : block.call
@@ -86,15 +91,15 @@ class Assertor
   # 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?
+    return self if args.empty? && !block_given?  # same as #assert
 
     target = block || args.shift
 
-    if Proc === target || target.respond_to?(:to_proc)
+    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))
+      if ::Exception === match || (::Class===match && match.ancestors.include?(::Exception))
+        $DEBUG, debug = false, $DEBUG  # b/c it always spits-out a NameError
         begin
           block.arity > 0 ? block.call(@delegate) : block.call
           pass = false
@@ -105,6 +110,8 @@ class Assertor
         rescue Exception => error
           pass = false
           msg  = "#{match} expected but #{error.class} was raised"
+        ensure
+          $DEBUG = debug
         end
       else
         result = block.arity > 0 ? block.call(@delegte) : block.call
@@ -126,7 +133,7 @@ class Assertor
   #
   def flunk(msg=nil)
     $failures += 1
-    fail Assertion.new(msg || @message, :backtrace=>@backtrace)
+    fail ::Assertion.new(msg || @message, :backtrace=>@backtrace)
   end
 
   # Ruby seems to have a quark in it's implementation whereby
@@ -136,12 +143,18 @@ class Assertor
     method_missing(:"=~", match)
   end
 
+  #
+  def send(op, *a, &b)
+    method_missing(op, *a, &b)
+  end
+
   private
 
   # Converts a missing methods into an Assertion.
   #
   def method_missing(sym, *a, &b)
     pass = @delegate.__send__(sym, *a, &b)
+    #pass = @delegate.public_send(sym, *a, &b)
     __assert__(pass, @message || __msg__(sym, *a, &b))
     #Assertor.count += 1
     #if (@negated ? pass : !pass)
@@ -154,10 +167,11 @@ class Assertor
   # Puts together a suitable error message.
   #
   def __msg__(m, *a, &b)
+    inspection = @delegate.send(:inspect)
     if @negated
-      "! #{@delegate.inspect} #{m} #{a.collect{|x| x.inspect}.join(',')}"
+      "! #{inspection} #{m} #{a.collect{|x| x.inspect}.join(',')}"
     else
-      "#{@delegate.inspect} #{m} #{a.collect{|x| x.inspect}.join(',')}"
+      "#{inspection} #{m} #{a.collect{|x| x.inspect}.join(',')}"
     end
     #self.class.message(m)[@delegate, *a] )
   end
@@ -194,4 +208,10 @@ class Assertor
   #message(:==){ |*a| "Expected #{a[0].inspect} to be equal to #{a[1].inspect}" }
 end
 
+# DO WE MAKE THESE EXCEPTIONS?
+#class BasicObject
+#  def assert ;
+#  end
+#end
+
 # Copyright (c) 2008,2009 Thomas Sawyer

data/lib/ae/basic_object.rb

@@ -0,0 +1,116 @@
+#--
+# Copyright 2004, 2006 by Jim Weirich (jim@weirichhouse.org).
+# All rights reserved.
+#
+# Permission is granted for use, copying, modification, distribution,
+# and distribution of modified versions of this work as long as the
+# above copyright notice is included.
+#++
+
+if RUBY_VERSION >= '1.9'
+
+  module AE
+    BasicObject = ::BasicObject
+  end
+
+else
+
+  module AE
+    # BasicObject provides an abstract base class with no predefined
+    # methods (except for <tt>\_\_send__</tt> and <tt>\_\_id__</tt>).
+    # BlankSlate is useful as a base class when writing classes that
+    # depend upon <tt>method_missing</tt> (e.g. dynamic proxies).
+    #
+    class BasicObject
+
+      # Hide the method named +name+ in the BlankSlate class.  Don't
+      # hide +instance_eval+ or any method beginning with "__".
+      def self.hide(name)
+        name = name.to_s
+        if instance_methods.include?(name) and
+          name !~ /^(__|instance_eval|instance_exec)/
+          @hidden_methods ||= {}
+          @hidden_methods[name.to_sym] = instance_method(name)
+          undef_method name
+        end
+      end
+
+      def self.find_hidden_method(name)
+        @hidden_methods ||= {}
+        @hidden_methods[name.to_sym] || superclass.find_hidden_method(name)
+      end
+
+      # Redefine a previously hidden method so that it may be called on a blank
+      # slate object.
+      def self.reveal(name)
+        hidden_method = find_hidden_method(name)
+        fail "Don't know how to reveal method '#{name}'" unless hidden_method
+        define_method(name, hidden_method)
+      end
+
+      #  
+      instance_methods.each { |m| hide(m) }
+    end
+  end
+
+  # Since Ruby is very dynamic, methods added to the ancestors of
+  # BlankSlate <em>after BlankSlate is defined</em> will show up in the
+  # list of available BlankSlate methods.  We handle this by defining a
+  # hook in the Object and Kernel classes that will hide any method
+  # defined after BlankSlate has been loaded.
+  #
+  module Kernel
+    class << self
+      alias_method :basic_object_method_added, :method_added
+
+      # Detect method additions to Kernel and remove them in the
+      # BasicObject class.
+      def method_added(name)
+        result = basic_object_method_added(name)
+        return result if self != Kernel
+        AE::BasicObject.hide(name)
+        result
+      end
+    end
+  end
+
+  # Same as above, except in Object.
+  #
+  class Object
+    class << self
+      alias_method :basic_object_method_added, :method_added
+
+      # Detect method additions to Object and remove them in the
+      # BlankSlate class.
+      def method_added(name)
+        result = basic_object_method_added(name)
+        return result if self != Object
+        AE::BasicObject.hide(name)
+        result
+      end
+
+      def find_hidden_method(name)
+        nil
+      end
+    end
+  end
+
+  # Also, modules included into Object need to be scanned and have their
+  # instance methods removed from blank slate.  In theory, modules
+  # included into Kernel would have to be removed as well, but a
+  # "feature" of Ruby prevents late includes into modules from being
+  # exposed in the first place.
+  #
+  class Module
+    alias basic_object_original_append_features append_features
+    def append_features(mod)
+      result = basic_object_original_append_features(mod)
+      return result if mod != Object
+      instance_methods.each do |name|
+        AE::BasicObject.hide(name)
+      end
+      result
+    end
+  end
+
+end

data/lib/ae/core_ext.rb

@@ -68,7 +68,7 @@ module Kernel
     begin
       __send__(method, *args, &block)
       true
-    rescue
+    rescue NoMethodError
       false
     end
   end
@@ -77,6 +77,14 @@ module Kernel
   #def returns?(value) #:yield:
   #  value == yield
   #end
+
+  unless method_defined?(:public_send)
+    #
+    def public_send(m,*a,&b)
+      raise NoMethodError unless respond_to?(m)
+      __send__(m,*a,&b)
+    end
+  end
 end
 
 
@@ -198,4 +206,9 @@ class Exception
   end
 end
 
+# We need BasicObject for Assertor.
+unless defined?(BasicObject)
+  require 'ae/basic_object'
+end
+
 # Copyright (c) 2008,2009 Thomas Sawyer

data/lib/ae/dot.rb

@@ -0,0 +1,21 @@
+# Expiremental Concept
+
+class TrueClass
+  def true
+    true
+  end
+  def false
+    fail Assertion.new('true', :backtrace=>caller)
+    #raise Assertion
+  end
+end
+
+class FalseClass
+  def true
+    fail Assertion.new('false', :backtrace=>caller)
+  end
+  def false
+    true
+  end
+end
+

data/lib/ae/meta/data.rb

@@ -0,0 +1,29 @@
+Object.__send__(:remove_const, :VERSION) if Object.const_defined?(:VERSION)      # becuase Ruby 1.8~ gets in the way
+
+module AE
+
+  def self.__DIR__
+    File.dirname(__FILE__)
+  end
+
+  def self.package
+    @package ||= (
+      require 'yaml'
+      YAML.load(File.new(__DIR__ + '/package'))
+    )
+  end
+
+  def self.profile
+    @profile ||= (
+      require 'yaml'
+      YAML.load(File.new(__DIR__ + '/profile'))
+    )
+  end
+
+  def self.const_missing(name)
+    key = name.to_s.downcase
+    package[key] || profile[key] || super(name)
+  end
+
+end
+

data/lib/ae/meta/package

@@ -0,0 +1,8 @@
+name    : ae
+date    : 2010-06-17
+version : 1.4.0
+
+requires:
+  - syckle (build)
+  - qed    (test)
+

data/lib/ae/pry.rb

@@ -0,0 +1,35 @@
+require 'ae/basic_object'
+
+module Kernel
+
+  $PRY_TABLE = {}
+
+  # Pry allows you to test private and protected methods,
+  # via a public-only interface.
+  #
+  # Generally one should avoid testing private and protected
+  # method directly, instead relying on tests of public methods to
+  # indirectly test them, because private and protected methods are
+  # considered implementation details. But sometimes is necessary
+  # to test them directly, or if you wish to achieve *absolute
+  # coverage*, say in mission critical systems.
+
+  def pry
+    $PRY_TABLE[self] ||= Pry.new do |op, *a, &b|
+      __send__(op, *a, &b)
+    end
+  end
+
+  # Pry Functor
+  class Pry < BasicObject
+    #instance_methods.each{ |m| private m unless m.to_s =~ /^__/ }
+    def initialize(&function)
+      @function = function
+    end
+    def method_missing(op, *a, &b)
+      @function.call(op, *a, &b)
+    end
+  end
+
+end
+

data/lib/ae/subjunctive.rb

@@ -20,7 +20,7 @@ module AE
     #
     def be(*args, &block)
       return self if args.empty? && !block
-      block = args.shift if !block_given? && Proc === args.first
+      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
@@ -43,7 +43,7 @@ module AE
     #
     def a(*args, &block)
       return self if args.empty? && !block
-      block = args.shift if !block_given? && Proc === args.first
+      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
@@ -60,7 +60,7 @@ module AE
 end#module AE
 
 class Assertor
-  include AE::Subjunctive
+  include ::AE::Subjunctive
 end
 
 # Copyright (c) 2008,2009 Thomas Sawyer

data/lib/ae/subjunctive/should.rb

@@ -11,7 +11,7 @@ module AE
   # THIS IS AN OPTIONAL LIBRARY.
   #
   module Should
-    # The #must method is functionaly the same as #should.
+    # Make an assertion in subjunctive tense.
     #
     #   4.should == 3  #=> Assertion Error
     #
@@ -24,7 +24,7 @@ module AE
     end
 
     # Designate a negated expectation via a *functor*.
-    # Read this as "must not".
+    # Read this as "should not".
     #
     #   4.should! == 4  #=> Assertion Error
     #

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

@@ -60,7 +60,7 @@ Another way to get the opposite inference, is to use +not+.
 
 == Matchers & Lambda Assertions
 
-Passing a Proc object or an objec that responds to :to_prco, will use it
+Passing a Proc object or an objec 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.
 
@@ -72,6 +72,7 @@ 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
@@ -81,7 +82,7 @@ will be passed to this method to determine passage.
 
 == Identity Assertions
 
-Rather then the general form:
+Rather then the general form.
 
   x = 10
   x.assert.object_id == x.object_id

data/{demo → qed}/06_counts.rdoc

@@ -5,7 +5,7 @@ We can reset the count using the +recount+ class method.
 
   Assertion.recount
 
-For example if we one assertion fails and another fails:
+For example if we one assertion fails and another fails.
 
   assert(true)
   assert(false)

data/qed/07_matchers.rdoc

@@ -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.

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: ae
 version: !ruby/object:Gem::Version 
-  hash: 27
+  hash: 7
   prerelease: false
   segments: 
   - 1
-  - 3
+  - 4
   - 0
-  version: 1.3.0
+  version: 1.4.0
 platform: ruby
 authors: 
 - Thomas Sawyer
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-06-17 00:00:00 -04:00
+date: 2010-09-02 00:00:00 -04:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -55,36 +55,42 @@ extensions: []
 extra_rdoc_files: 
 - README.rdoc
 files: 
-- demo/01_overview.rdoc
-- demo/02_assertion.rdoc
-- demo/03_assert.rdoc
-- demo/04_subjunctive.rdoc
-- demo/05_expect.rdoc
-- demo/06_counts.rdoc
+- expo/cucumber/features/cucumber.feature
+- expo/cucumber/features/step_definitions/cucumber_steps.rb
+- expo/cucumber/features/support/env.rb
+- qed/01_overview.rdoc
+- qed/02_assertion.rdoc
+- qed/03_assert.rdoc
+- qed/04_subjunctive.rdoc
+- qed/05_expect.rdoc
+- qed/06_counts.rdoc
+- qed/07_matchers.rdoc
 - lib/ae/assert.rb
 - lib/ae/assertion.rb
 - lib/ae/assertor.rb
+- lib/ae/basic_object.rb
 - lib/ae/core_ext.rb
+- lib/ae/dot.rb
 - lib/ae/expect.rb
 - lib/ae/legacy.rb
+- lib/ae/meta/data.rb
+- lib/ae/meta/package
+- lib/ae/meta/profile
 - lib/ae/must.rb
-- lib/ae/package.yml
-- lib/ae/profile.yml
+- lib/ae/pry.rb
 - lib/ae/should.rb
 - lib/ae/subjunctive/must.rb
 - lib/ae/subjunctive/should.rb
 - lib/ae/subjunctive.rb
 - lib/ae.rb
-- PROFILE
-- PACKAGE
+- HISTORY.rdoc
 - LICENSE
 - README.rdoc
-- HISTORY
-- REQUIRE
+- NOTICE
 has_rdoc: true
 homepage: http://proutils.github.com/ae
-licenses: []
-
+licenses: 
+- MIT
 post_install_message: 
 rdoc_options: 
 - --title

data/PACKAGE

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

data/REQUIRE

@@ -1,5 +0,0 @@
-development:
-  - syckle
-
-development/test:
-  - qed

data/lib/ae/package.yml

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

data/lib/ae/profile.yml

@@ -1,18 +0,0 @@
---- 
-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