ae 1.8.1 → 1.8.2

data/lib/ae/assertor.rb

@@ -9,7 +9,7 @@ module AE
   #
   # An Assertor is an Assertion Functor. A Functor is a succinct name for what
   # is also known as Higher Order Function. In other words, it is a function
-  # that acts on a function. It is very similiar  to a delegator in most
+  # that acts on a function. It is very similiar to a delegator in most
   # respects, but is conditioned on the operation applied, rather then simply
   # passing-off to an alternate reciever.
   #
@@ -19,11 +19,11 @@ module AE
     ZERO_COUNTS = {:total=>0,:pass=>0,:fail=>0}
 
     # Initialize assertion counts global variable.
-    $assertion_counts = ZERO_COUNTS.dup
+    $ASSERTION_COUNTS = ZERO_COUNTS.dup
 
     # Returns Hash used to track assertion counts.
     def self.counts
-      $assertion_counts
+      $ASSERTION_COUNTS
     end
 
     # Reset assertion counts.

data/lib/ae/legacy.rb

@@ -335,6 +335,18 @@ module AE
         __assert__(test, msg)
       end
 
+      # Assert that an Array, or any other object the responds to #include?
+      # thus contains the given element.
+      #
+      # @raise [Assertion] if test fails
+      #
+      # @return nothing
+      def assert_includes(elem, array, msg=nil)
+        test = array.include?(elem)
+        msg = "Expected #{elem.inspect} is not found in #{array.inspect}" unless msg
+        __assert__(test, msg)
+      end
+
       # Flunk always fails.
       #
       # @example

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ae
 version: !ruby/object:Gem::Version
-  version: 1.8.1
+  version: 1.8.2
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2011-11-04 00:00:00.000000000 Z
+date: 2013-02-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ansi
-  requirement: &31611960 !ruby/object:Gem::Requirement
+  requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -21,10 +21,15 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *31611960
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: detroit
-  requirement: &31611420 !ruby/object:Gem::Requirement
+  requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -32,10 +37,15 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *31611420
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: qed
-  requirement: &31610920 !ruby/object:Gem::Requirement
+  requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -43,7 +53,12 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *31610920
+  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."
 email:
@@ -51,10 +66,10 @@ email:
 executables: []
 extensions: []
 extra_rdoc_files:
-- HISTORY.rdoc
-- README.rdoc
-- QED.rdoc
-- NOTICE.rdoc
+- DEMO.rdoc
+- HISTORY.md
+- README.md
+- NOTICE.md
 files:
 - .ruby
 - .yardopts
@@ -80,18 +95,10 @@ files:
 - lib/ae/version.rb
 - lib/ae.rb
 - lib/ae.yml
-- 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
-- qed/08_check.rdoc
-- HISTORY.rdoc
-- README.rdoc
-- QED.rdoc
-- NOTICE.rdoc
+- DEMO.rdoc
+- HISTORY.md
+- README.md
+- NOTICE.md
 homepage: http://rubyworks.github.com/ae
 licenses:
 - BSD-2-Clause
@@ -113,8 +120,9 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.10
+rubygems_version: 1.8.24
 signing_key: 
 specification_version: 3
 summary: Assertive Expressive
 test_files: []
+has_rdoc: 

data/qed/01_overview.rdoc

@@ -1,92 +0,0 @@
-= Introduction
-
-AE is an assertions framework for Ruby. It's designed
-around the concept of an Assertor. The Assertor is an
-Assertion Functor, or Higher-Order Function, which 
-reroutes method calls while monitoring them for failing
-conditions.
-
-
-== What AE Provides
-
-Requiring the AE library.
-
-  require 'ae'
-
-Loads two classes, +Assertion+ and +Assertor+, the Kernel
-method +assert+ and it's antonyms +assert!+ and +refute+
-and a set of core extensions that make writing certain types
-of assertions easier.
-
-
-== Assertion and Assertor Classes
-
-The +Assertion+ class is at the heart of AE. All other AE
-methods depend on it. The +Assertion+ class is a subclass
-of Exception. When an assertion is made and fails, it is
-an instance of Assertion that is raised.
-
-  expect Assertion do
-    msg = "my failure message"
-    assert false, msg
-  end
-
-Like any raised exception, the last Assertion message is available
-via <tt>$!</tt>.
-
-(FYI, in Test::Unit the equivalent class was called +AssertionFailedError+.)
-
-Assertions themselves are not generally used in creating tests or
-behavior specifications. Rather they are used to create additional
-types of assertion methods.
-
-As mentioned above the +Assertor+ class is a type of Higher-Order
-function, or Functor, which intercedes with a normal message
-invocation to monitor for failed conditions, upon which is raises
-Assertion exceptions.
-
-
-== Assertion Methods
-
-The three methods, +assert+, <tt>assert!</tt> and +refute+ all
-return an Assertor instance when used fluidly, i.e. magic-dot
-notation, higher-order notation, functor notation, whatever you
-prefer to call it.
-
-  assert(AE::Assertor === assert)
-
-Through the use of +method_missing+, the Assertor allows us to write
-statements like:
-
-  1.assert == 1
-
-If the operation evaluates to false or nil, then an Assertion error
-is raised.
-
-  expect Assertion do
-    1.assert == 2
-  end
-
-The methods <tt>assert!</tt> and +refute+ are just like +assert+
-expect they purport the negative condition. Patterned after Ruby's
-own use of "<tt>!</tt>" as meaning +not+, <tt>assert!</tt> should be
-read "assert not". While +refute+ exists for the sake of those who
-find the use of a bang method for this purpose unsuited to them.
-
-
-== How It Works
-
-An Assertor essentially sits in wait for a method call (via
-method_missing). When that happens it applies the method to the
-original receiver, but wrapped in a clause that raises an
-Assertion should the statement fail. If we wanted to be 
-pedantic, we could write our assertions like:
-
-  raise Assertion.new("1 != 1") unless 1 == 1
-
-Instead of 
-
-  1.assert == 1
-
-Obviously using Assertor methods are whole lot more concise.
-

data/qed/02_assertion.rdoc

@@ -1,4 +0,0 @@
-= Assertion Class
-
-The Assertion class is a subclass of Exception and is the error raised when
-and assertion fails.

data/qed/03_assert.rdoc

@@ -1,298 +0,0 @@
-= Assert Method
-
-== Compatible with Test::Unit
-
-The +assert+ method is designed to be backward compatible
-with the same method in <tt>Test::Unit</tt>.
-
-Using an argument, +assert+ will check that an argument evaluates
-to true. Optionally one can send along a meaningful message should
-the assertion fail.
-
-  assert(true, "Not true!")
-
-  expect Assertion do
-    assert(false, "Not true!")
-  end
-
-
-== Assert with a Block
-
-In addition +assert+ has been extended to accept a block. Like the case of the
-argument, the block is expected to return something that evaluates as true.
-
-  assert do
-    true
-  end
-
-  Assertion.assert.raised? do
-    assert do
-      false
-    end
-  end
-
-We should also mention that, while probably not very useful, since
-the arity of a block can be checked, one can also pass the receiver
-into the block as a block argument.
-
-  "hi".assert do |s|
-    /h/ =~ s
-  end
-
-
-== Antonyms for Assert
-
-We can state the opposite assertion using <tt>assert!</tt>.
-
-  10.assert! == 9
-
-Or, because some people do not like the use of a bang method, +refute+.
-
-  10.refute == 9
-
-These terms can be used just as +assert+ is used in all examples,
-but with the opposite inference.
-
-Another way to get the opposite inference, is to use +not+.
-
-  10.assert.not == 9
-
-== Lambda Assertions
-
-Passing  +assert+ a `Proc` object, or any object that responds to `#call`,
-will be used as if it were a block. This allows for a simple way to quickly
-create reusable assertions.
-
-  palindrome = lambda{ |word| word == word.reverse }
-
-  "abracarba".assert palindrome
-
-The message for a failed assertion will come from calling `#to_s` on the
-object.
-
-== RSpec-style Assertion Matchers
-
-If an object passed to assert responds to `#matches?` then AE will handle
-the object as an RSpec-style mather, the receiver will be passed to the
-`#matches?` method to determine if the assertion passes and RSpec matcher
-message methods will be used if they are defined.
-
-  palindrome = Object.new
-
-  def palindrome.matches?(word)
-    word == word.reverse
-  end
-
-  "abracarba".assert palindrome
-
-
-== Identity Assertions
-
-Rather then the general form.
-
-  x = 10
-  x.assert.object_id == x.object_id
-
-We can use Ruby's own <tt>equal?</tt> method.
-
-  x.assert.equal?(x)
-
-AE provides <tt>identical?</tt> method as an alternative
-to make it a bit more clear.
-
-  x.assert.identical?(x)
-
-
-== Equality Assertions
-
-The most common assertion is that of value equality (<tt>==</tt>),
-as we have seen throughout this document. But other forms of
-equality can be verified as easily. We have already mentioned 
-identity. In addition there is <i>type equality</i>.
-
-  17.assert.eql? 17
-
-  Assertion.assert.raised? do
-    17.assert.eql? 17.0
-  end
-
-And there is <i>case equality</i>.
-
-  Numeric.assert === 3
-
-
-== Checking Equality with a Block
-
-Because operators can not take blocks, and at times blocks can
-be convenient means of supplying a value to an assertion,
-AE has defined alternate renditions of the equality methods.
-For equal? and eql?, the method names are the same, they simply
-can take a block in place of an argument if need be.
-
-For <i>value equality</i> (<tt>==</tt>), the method is called <tt>eq?</tt>.
-
-  10.assert.eq? do
-    10.0
-  end
-
-And should it fail...
-
-  Assertion.assert.raised? do
-    10.assert.eq? do
-      20
-    end
-  end
-
-== Case Equality
-
-For <i>case equality</i> (<tt>===</tt>), it is <tt>case?</tt>.
-
-  Numeric.assert.case? do
-    "3".to_i
-  end
-
-  Assertion.assert.raised? do
-    Numeric.assert.case? do
-      "3"
-    end
-  end
-
-
-== Regular Expressions
-
-Regular Expressions can be used to make assertions in much the same way as equality.
-
-  /i/.assert =~ "i"
-
-  Assertion.assert.raised? do
-    /i/.assert =~ "g"
-  end
-
-Conversely the String class recognizes the #=~ method as well.
-
-  "i".assert =~ /i/
-
-  Assertion.assert.raised? do
-    "i".assert =~ /g/
-  end
-
-
-== Exception Assertions
-
-Validating errors is easy too, as has already been shown
-in the document to verify assertion failures.
-
-  StandardError.assert.raised? do
-    unknown_method
-  end
-
-
-== Assertions on Object State
-
-While testing or specifying the internal state of an object is
-generally considered poor form, there are times when it is 
-necessary. Assert combined with +instance_eval+ makes it easy too.
-
-  class X
-    attr :a
-    def initialize(a); @a = a; end
-  end
-
-  x = X.new(1)
-
-  x.assert.instance_eval do
-    @a == 1
-  end
-
-
-== Catch/Try Assertions
-
-Catch/Try throws can be tested via <tt>Symbol#thrown?</tt>.
-
-  :hookme.assert.thrown? do
-    throw :hookme
-  end
-
-Alternatively, a lambda containing the potential throw
-can be the receiver using <tt>throws?</tt>.
-
-  hook = lambda{ throw :hookme }
-  
-  hook.assert.throws?(:hookme)
-
-
-== Assertions on Proc Changes
-
-I have to admit I'm not sure how this is useful,
-but I found it in the Bacon API and ported it over
-just for sake of thoroughness.
-
-  a = 0
-
-  l = lambda{ a }
-
-  l.assert.change?{ a +=1 }
-
-
-== Assertion on literal True, False and Nil
-
-Ruby already provides the #nil? method.
-
-  nil.assert.nil?
-
-AE adds <tt>true?</tt> and <tt>false?</tt> which acts accordingly.
-
-  true.assert.true?
-  false.assert.false?
-
-
-== Send Assertions
-
-Assert that a method can be successfully called.
-
-  "STRING".assert.send?(:upcase)
-
-
-== Numeric Delta and Epsilon
-
-You may wish to assert that a numeric value is with some
-range.
-
-  3.in_delta?(1,5)
-
-Or minimum range.
-
-  3.in_epsilon?(3,5)
-
-
-== Verifying Object State
-
-Not surprisingly if underlying object state needs to be verified, +instance_eval+
-can be used in conjunction with +assert+.
-
-  class X
-    attr :a
-    def initialize(a); @a = a; end
-  end
-
-  x = X.new(4)
-
-  x.instance_eval do
-    @a.assert == 4
-  end
-
-However #instance_eval is a reserved method for the underlying Assertor class,
-so it cannot be used on #assert, e.g.
-
-  x.assert.instance_eval do
-    @a == "obvisouly wrong"
-  end
-
-AE offers an optional helper method for times when testing underlying private
-or protected methods is important, called #pry. See the QED on pry for more
-information.
-
-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 needed.