ae 1.7.0 → 1.7.1

data/.ruby

@@ -1,33 +1,45 @@
 --- 
 spec_version: 1.0.0
+replaces: []
+
+loadpath: 
+- lib
 name: ae
-title: AE
-engine_check:
+repositories: 
+  public: git://github.com/rubyworks/ae.git
+conflicts: []
+
+engine_check: 
 - ruby 1.8.7 (2010-08-16 patchlevel 302) [x86_64-linux]
+- ruby 1.9.2p0 (2010-08-18 revision 29036) [x86_64-linux]
+title: AE
 contact: trans <transfire@gmail.com>
 resources: 
-  repo: git://github.com/rubyworks/ae.git
   code: http://github.com/rubyworks/ae
   mail: http://groups.google.com/group/rubyworks-mailinglist
   docs: http://wiki.github.com/rubyworks/ae/docs/qed
-  bugs: http://github.com/rubyworks/ae/issues
   wiki: http://wiki.github.com/rubyworks/ae
+  bugs: http://github.com/rubyworks/ae/issues
   home: http://rubyworks.github.com/ae
+maintainers: []
+
 requires: 
 - group: 
   - build
-  name: syckle
+  name: redline
   version: 0+
 - group: 
   - test
   name: qed
   version: 0+
-suite: rubyworks
-manifest: Manifest.txt
-version: 1.7.0
+manifest: MANIFEST
+version: 1.7.1
+licenses: 
+- Apache 2.0
 copyright: Copyright (c) 2008 Thomas Sawyer
-description: Assertive Expressive is an assertions library specifically designed for reuse by other test frameworks.
 authors: 
 - Thomas Sawyer
+organization: Rubyworks
+description: Assertive Expressive is an assertions library specifically designed for reuse by other test frameworks.
 summary: Assertive Expressive
 created: 2008-08-17

data/{History.rdoc → HISTORY.rdoc}

@@ -1,5 +1,16 @@
 = RELEASE HISTORY
 
+== 1.7.1 / 2011-05-06
+
+This release adds a specialized message for certain comparision
+operators to allow them have a more forensic output. This is done
+via ANSI::Diff library.
+
+Changes:
+
+* Add special message for comparison assertions.
+
+
 == 1.7.0 / 2011-04-28
 
 AE now uses proper namespace for all classes. In particular, the `Assertor`

data/README.rdoc

@@ -1,5 +1,9 @@
 = Assertive Expressive
 
+Author:: Thomas Sawyer
+License:: Apache 2.0
+
+
 == DESCRIPTION
 
 Assertive Expressive (AE) is an assertions framework
@@ -19,8 +23,12 @@ intended for reuse by any TDD, BDD or similar system.
 
 == RESOURCES
 
-* home: http://rubyworks.github.com/ae/
-* code: http://github.com/rubyworks/ae/
+* home: http://rubyworks.github.com/ae
+* code: http://github.com/rubyworks/ae
+* docs: http://wiki.github.com/rubyworks/ae/docs/qed
+* wiki: http://wiki.github.com/rubyworks/ae
+* bugs: http://github.com/rubyworks/ae/issues
+* mail: http://googlegroups.com/group/rubyworks-mailinglist
 
 
 == SYNOPSIS
@@ -82,24 +90,54 @@ counts are correct, a little extra interfacing code may be necessary.
 Lucky for you AE has already done the leg work for the most common
 test frameworks:
 
-* require 'ae/adapters/testunit'
-* require 'ae/adapters/minitest'
-* require 'ae/adapters/rspec'
+  require 'ae/adapters/testunit'
+  require 'ae/adapters/minitest'
+  require 'ae/adapters/rspec'
 
-Note that Cucumber does not need an adapter.
+(Note that Cucumber does not need an adapter.)
 
+AE also includes a script that will automatically detect the current
+test framework by checking for the existence of their respective 
+namespace modules.
 
-== HOW TO INSTALL
+  require 'ae/adapter'
+
+
+== NOMENCLATURE
+
+With AE, defining assertions centers around the #assert method. So
+*assert* can be thought of as AE's primary _nomenclature_. However, variant
+nomenclatures have been popularized by other test frameworks, in particular
+*should* and *must*. If you prefer one of them terms, AE provides optional
+libraries that can loaded for utilizing them.
+
+  require 'ae/should'
+  require 'ae/must'
+
+By loading one of these scripts (or both) into your test system (e.g. via a test
+helper script) you gain access to subjunctive terminology. See the API documentation
+for the Subjunctive module for details.
 
-=== Gem Installs
 
-AE releases it's gems via Gemcutter. If you don't have Gemcutter
-installed do:
+== LEGACY
 
-  $ gem install gemcutter
-  $ gem tumble
+To ease transition from TestUnit style assertion methods, AE provides
+a TestUnit legacy module.
 
-Then you can install AE with:
+  require 'ae/legacy'
+
+This provides a module AE::Legacy::Assertions which is included in AE::World
+and can be mixed into your test environment to provide old-school assertion
+methods. E.g.
+
+  assert_equal(foo, bar, "it failed")
+
+
+== INSTALLATION
+
+=== Gem Installs
+
+Install AE in the usual fashion:
 
   $ gem install ae
 
@@ -129,6 +167,8 @@ Unless otherwise provided for by the originating author, this
 program is distributed under the terms of the Apache 2.0 license.
 See the Apache2.txt for details.
 
-Protions of this program may be copyrighted by others. See the 
+Portions of this program may be copyrighted by others. See the 
 NOTICE.rdoc file for details.
 
+AE is a Rubyworks[http://rubyworks.github.com] project.
+

data/{Syckfile → Redfile}

@@ -22,11 +22,11 @@ stats:
 rdoc:
   service : rdoc
   format  : redfish
-  exclude : [Syckfile, Profile, Manifest.txt]
+  exclude : [Redfile, Profile, MANIFEST, Version]
   output  : site/doc/api
 
-ridoc:
-  service: RIDoc
+ri:
+  service: RI
   include: ~
   exclude: ~
   output : .ri

data/lib/ae.rb

@@ -12,7 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-# AE's namespace.
+# AE namespace.
 module AE
 
   # Set Assertion class. This is a convenience method

data/lib/ae.yml

@@ -1,33 +1,45 @@
 --- 
 spec_version: 1.0.0
+replaces: []
+
+loadpath: 
+- lib
 name: ae
-title: AE
-engine_check:
+repositories: 
+  public: git://github.com/rubyworks/ae.git
+conflicts: []
+
+engine_check: 
 - ruby 1.8.7 (2010-08-16 patchlevel 302) [x86_64-linux]
+- ruby 1.9.2p0 (2010-08-18 revision 29036) [x86_64-linux]
+title: AE
 contact: trans <transfire@gmail.com>
 resources: 
-  repo: git://github.com/rubyworks/ae.git
   code: http://github.com/rubyworks/ae
   mail: http://groups.google.com/group/rubyworks-mailinglist
   docs: http://wiki.github.com/rubyworks/ae/docs/qed
-  bugs: http://github.com/rubyworks/ae/issues
   wiki: http://wiki.github.com/rubyworks/ae
+  bugs: http://github.com/rubyworks/ae/issues
   home: http://rubyworks.github.com/ae
+maintainers: []
+
 requires: 
 - group: 
   - build
-  name: syckle
+  name: redline
   version: 0+
 - group: 
   - test
   name: qed
   version: 0+
-suite: rubyworks
-manifest: Manifest.txt
-version: 1.7.0
+manifest: MANIFEST
+version: 1.7.1
+licenses: 
+- Apache 2.0
 copyright: Copyright (c) 2008 Thomas Sawyer
-description: Assertive Expressive is an assertions library specifically designed for reuse by other test frameworks.
 authors: 
 - Thomas Sawyer
+organization: Rubyworks
+description: Assertive Expressive is an assertions library specifically designed for reuse by other test frameworks.
 summary: Assertive Expressive
 created: 2008-08-17

data/lib/ae/adapter.rb

@@ -1,7 +1,8 @@
-if defined?(::Test::Unit)
-  require 'ae/adapters/testunit'
-elsif defined?(::MiniTest)
+if defined?(::MiniTest)
   require 'ae/adapters/minitest'
-elsif defined?(::Spec)
+elsif defined?(::Test::Unit)
+  require 'ae/adapters/testunit'
+elsif defined?(::RSpec)
   require 'ae/adapters/rspec'
 end
+

data/lib/ae/adapters/minitest.rb

@@ -2,16 +2,35 @@ require 'ae'
 
 AE.assertion_error = ::MiniTest::Assertion
 
-# 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.
-
 module MiniTest #:nodoc:
   class Unit #:nodoc:
+    # 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.
     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 the it's #puke method.
+    def puke c, m, x
+      case x
+      when MiniTest::Skip
+        @skips = @skips + 1
+        x = "Skipped:\n#{m}(#{c}) [#{location x}]:\n#{x.message}\n"
+      when MiniTest::Assertion
+        @failures = @failures + 1
+        x = "Failure:\n#{m}(#{c}) [#{location x}]:\n#{x.message}\n"
+      when x.respond_to?(:assertion?) && x.assertion?
+        @failures = @failures + 1
+        x = "Failure:\n#{m}(#{c}) [#{location x}]:\n#{x.message}\n"
+      else
+        @errors = @errors + 1
+        b = MiniTest::filter_backtrace(x.backtrace).join("\n ")
+        x = "Error:\n#{m}(#{c}):\n#{x.class}: #{x.message}\n #{b}\n"
+      end
+      @report << x
+      x[0, 1]
+    end
   end
 end
 
-

data/lib/ae/adapters/rspec.rb

@@ -2,3 +2,6 @@ require 'ae'
 
 AE.assertion_error = ::RSpec::Expectations::ExpectationNotMetError
 
+# TODO: Teach RSpec the expanded concept of assertions, as Exception
+# classes that respond to `#assertion?` in the affirmative.
+

data/lib/ae/adapters/testunit.rb

@@ -6,15 +6,52 @@ AE.assertion_error = ::Test::Unit::AssertionFailedError
 # 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:
-      alias_method :_run, :run
-      def run(result, &block)
+      # 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
-        _run(result, &block)
-      end
+        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
+        end
+        result.add_run
+        yield(FINISHED, name)
+      end 
     end
   end
 end

data/lib/ae/assert.rb

@@ -59,7 +59,7 @@ module AE
     # Directly raise an Assertion failure.
     def flunk(message=nil, backtrace=nil)
       #Assertor.new(self, :backtrace=>caller).assert(false, message)
-      Assertor.assert(false, message, caller)
+      Assertor.assert(false, message, backtrace || caller)
     end
 
   end

data/lib/ae/assertion.rb

@@ -1,5 +1,3 @@
-# Copyright (c) 2008,2010 Thomas Sawyer
-
 require 'ae/core_ext'
 
 module AE

data/lib/ae/assertor.rb

@@ -27,17 +27,17 @@ module AE
 
     # Reset assertion counts.
     #
-    # reset - Hash which will be used to set counts manually (optional).
+    # reset - Hash which can be used to set counts manually (optional).
     #
     # Returns the Hash of previous counts.
-    def self.recount(reset={})
+    def self.recount(reset=nil)
       old_counts = counts.dup
-      if reset.empty?
-        counts.replace(ZERO_COUNTS.dup)
-      else
+      if reset
         reset.each do |type, value|
           counts[type.to_sym] = value
         end
+      else
+        counts.replace(ZERO_COUNTS.dup)
       end
       return old_counts
     end
@@ -57,25 +57,25 @@ module AE
 
     # Basic assertion. This method by-passes all the Assertor fluent
     # constructs and performs the underlying assertion procedure. It
-    # is used by Assertor as the end result of an assertion.
-    def self.assert(pass, message=nil, backtrace=nil)
+    # is used by Assertor as the end call of an assertion.
+    def self.assert(pass, error=nil, negated=nil, backtrace=nil)
+      pass = negated ^ !!pass
       increment_counts(pass)
       if !pass
         backtrace = backtrace || caller
-        message   = message   || 'flunk'
-        raise_assertion(message, backtrace)
+        raise_assertion(error, negated, backtrace)
       end
       return pass
     end
 
-    # This method can be replaced to support alternate frameworks.
-    # The intent of the method is to raise the assertion failure
-    # class that the framework uses.
-    def self.raise_assertion(message, backtrace=nil)
-      backtrace = backtrace || caller
-
-      error = assertion_error.new(message)
-      error.set_backtrace(backtrace)
+    # The intent of the method is to raise an assertion failure
+    # class that the test framework supports.
+    def self.raise_assertion(error, negated, backtrace=nil)
+      if not Exception === error
+        error = assertion_error.new(error)
+      end
+      error.set_negative(negated)
+      error.set_backtrace(backtrace || caller)
       error.set_assertion(true)
       fail error
     end
@@ -85,6 +85,22 @@ module AE
       ::Assertion
     end
 
+    # NOT HAPPENING
+    ## Is ::Assay defined. This is used for integration of the Assay library.
+    #def self.assay?
+    #  @_assay ||= defined?(::Assay)
+    #end
+
+    #
+    #def self.message(sym, neg, *args, &blk)
+    #  if method = Message.lookup(sym) 
+    #    method = "non_#{method}" if neg
+    #    Message.send(method, *args, &blk)
+    #  else
+    #    nil
+    #  end
+    #end
+
     #
     if ::RUBY_VERSION >= '1.9'
       eval "private :==, :!, :!="  # using eval here b/c it's a syntax error in 1.8-
@@ -124,31 +140,45 @@ module AE
     #   assert something, parameter
     #
     # Returns +true+ or +false+ based on assertions success.
+    #--
+    # The use of #to_proc and #matches? as sepcial cases is not
+    # a robust solution.
+    #++
     def assert(*args, &block)
       return self if args.empty? && !block
 
       target = block || args.shift
+      error  = nil
 
+      # Lambda
       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}"
+          pass  = (match == result)
+          error = @message || "#{match.inspect} == #{result.inspect}"
         else
-          pass = result
-          msg  = @message || block.inspect  # "#{result.inspect}"
+          pass  = result
+          error = @message || block.inspect  # "#{result.inspect}"
         end
-      elsif target.respond_to?(:matches?)
-        pass   = target.matches?(@delegate)
-        msg    = @message || matcher_message(target) || target.inspect
+
+      # Matcher
+      elsif target.respond_to?(:matches?) # Matchers
+        pass  = target.matches?(@delegate)
+        error = @message || matcher_message(target) #|| target.inspect
+        if target.respond_to?(:exception)
+          #error_class = target.failure_class
+          error = target.exception #(:backtrace=>@backtrace, :negated=>@negated)
+        end
+
+      # Truthiness
       else
-        pass   = target     # truthiness
-        msg    = args.shift # optional mesage for TestUnit compatiability
+        pass  = target     # truthiness
+        error = args.shift # optional message for TestUnit compatiability
       end
 
-      __assert__(pass, msg)
+      __assert__(pass, error)
     end
 
     # Internal expect, provides all functionality associated
@@ -162,7 +192,9 @@ module AE
       return self if args.empty? && !block  # same as #assert
 
       target = block || args.shift
+      error  = nil
 
+      # Lambda
       if ::Proc === target #|| target.respond_to?(:to_proc)
         #block = target.to_proc
         match = args.shift || @delegate
@@ -170,31 +202,39 @@ module AE
           $DEBUG, debug = false, $DEBUG  # b/c it always spits-out a NameError
           begin
             block.arity > 0 ? block.call(@delegate) : block.call
-            pass = false
-            msg  = "#{match} not raised"
+            pass  = false
+            error = "#{match} not raised"
           rescue match => error
-            pass = true
-            msg  = "#{match} raised"
+            pass  = true
+            error = "#{match} raised"
           rescue ::Exception => error
-            pass = false
-            msg  = "#{match} expected but #{error.class} was raised"
+            pass  = false
+            error = "#{match} expected but #{error.class} was raised"
           ensure
             $DEBUG = debug
           end
         else
           result = block.arity > 0 ? block.call(@delegte) : block.call
           pass   = (match === result)
-          msg    = @message || "#{match.inspect} === #{result.inspect}"
+          error  = @message || "#{match.inspect} === #{result.inspect}"
         end
+
+      # Matcher
       elsif target.respond_to?(:matches?)
-        pass = target.matches?(@delegate)
-        msg  = @message || matcher_message(target) || target.inspect
+        pass  = target.matches?(@delegate)
+        error = @message || matcher_message(target) #|| target.inspect
+        if target.respond_to?(:exception)
+          #error_class = target.failure_class
+          error = target.exception #failure(:backtrace=>@backtrace, :negated=>@negated)
+        end
+
+      # Case Equals
       else
-        pass = (target === @delegate)
-        msg  = @message || "#{target.inspect} === #{@delegate.inspect}"
+        pass  = (target === @delegate)
+        error = @message || "#{target.inspect} === #{@delegate.inspect}"
       end
 
-      __assert__(pass, msg)
+      __assert__(pass, error)
     end
 
     #
@@ -233,30 +273,21 @@ module AE
     # Converts a missing method into an Assertion.
     #
     # TODO: In future should probably be `@delegate.public_send(sym, *a, &b)`.
-    def method_missing(sym, *a, &b)
-      pass = @delegate.__send__(sym, *a, &b)
-      __assert__(pass, @message || __msg__(sym, *a, &b))
-    end
+    def method_missing(sym, *args, &block)
+      error = @message || compare_message(sym, *args, &block) || generic_message(sym, *args, &block)
 
-    # Puts together a suitable error message.
-    #
-    def __msg__(m, *a, &b)
-      inspection = @delegate.send(:inspect)
-      if @negated
-        "! #{inspection} #{m} #{a.collect{|x| x.inspect}.join(',')}"
-      else
-        "#{inspection} #{m} #{a.collect{|x| x.inspect}.join(',')}"
-      end
-      #self.class.message(m)[@delegate, *a] )
+      pass = @delegate.__send__(sym, *args, &block)
+
+      __assert__(pass, error)
     end
 
+
     # Simple assert.
     #--
     # TODO: Can the handling of the message be simplified/improved?
     #++
-    def __assert__(pass, message=nil)
-      pass = @negated ^ pass
-      Assertor.assert(pass, message, @backtrace)
+    def __assert__(pass, error=nil)
+      Assertor.assert(pass, error, @negated, @backtrace)
     end
 
     #
@@ -265,21 +296,49 @@ module AE
         if matcher.respond_to?(:negative_failure_message)
           return matcher.failure_message
         end
+      else
+        if matcher.respond_to?(:failure_message)
+          return matcher.failure_message
+        end
       end
-      if matcher.respond_to?(:failure_message)
-        return matcher.failure_message
+      return nil
+    end
+
+    COMPARISON_OPERATORS = { :"==" => :"!=" }
+
+    # Message to use when making a comparion assertion.
+    def compare_message(operator, *args, &blk)
+      return nil unless COMPARISON_OPERATORS.key?(operator)
+      prefix = ""
+      a, b   = @delegate, args.first
+      if @negated
+        op = COMPARISON_OPERATORS[operator]
+        if op
+          operator = op
+        else
+          prefix   = "NOT "
+        end
+      end
+      if a.size > 13 or b.size > 13
+        diff = ANSI::Diff.new(a,b)
+        prefix + "a #{operator} b\na) " + diff.diff1 + "\nb) " + diff.diff2
+      else
+        prefix + "#{a.inspect} #{operator} #{b.inspect}"
       end
-      false
     end
 
-    # TODO: Ultimately better messages might be nice.
-    #
-    #def self.message(op,&block)
-    #  @message ||= {}
-    #  block ? @message[op.to_sym] = block : @message[op.to_sym]
-    #end
+    # Puts together a suitable error message.
     #
-    #message(:==){ |*a| "Expected #{a[0].inspect} to be equal to #{a[1].inspect}" }
+    def generic_message(op, *a, &b)
+      inspection = @delegate.send(:inspect)
+      if @negated
+        "! #{inspection} #{op} #{a.collect{|x| x.inspect}.join(',')}"
+      else
+        "#{inspection} #{op} #{a.collect{|x| x.inspect}.join(',')}"
+      end
+      #self.class.message(m)[@delegate, *a] )
+    end
+
   end
 
 end

data/lib/ae/core_ext/exception.rb

@@ -1,7 +1,7 @@
 class Exception
   # Is this exception the result of an assertion?
   def assertion?
-    @assertion ||= false
+    @assertion || false
   end
 
   # Set +true+/+false+ if the this exception is 
@@ -9,5 +9,15 @@ class Exception
   def set_assertion(boolean)
     @assertion = !!boolean
   end
+
+  #
+  def negative?
+    @negative || false
+  end
+
+  #
+  def set_negative(boolean)
+    @negative = !!boolean
+  end
 end
 

data/lib/ae/legacy.rb

@@ -275,13 +275,6 @@ module AE
 
   end #module Legacy
 
-#  # This could be in Object, but since they will only be needed in
-#  # the context of a, well, Context...
-#  #
-#  class Context #:nodoc:
-#    include Legacy::Assertions
-#  end
-
   module World
     include AE::Legacy::Assertions
   end

data/lib/ae/must.rb

@@ -33,7 +33,7 @@ module AE
 
     # Perhaps not literally the counter-term to *must* (rather *will*),
     # it is close enough for our purposes and conveys the appropriate
-    # semantics, and I think more sightly than *mustnt*.
+    # semantics, and I think is more sightly than *mustnt*.
     #
     # This method may be deprecated in the future when Ruby 1.9 becomes
     # mainstream, as it allows for redefining *#!* as a method.

data/lib/ae/pry.rb

@@ -13,7 +13,10 @@ module Kernel
   # considered implementation details. But sometimes is necessary
   # to test them directly, or if you wish to achieve *absolute
   # coverage*, say in mission critical systems.
-
+  #
+  #--
+  # TODO: Is th cache really neccessry?
+  #++
   def pry
     $PRY_TABLE[self] ||= Pry.new do |op, *a, &b|
       __send__(op, *a, &b)

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: ae
 version: !ruby/object:Gem::Version 
-  hash: 11
+  hash: 9
   prerelease: false
   segments: 
   - 1
   - 7
-  - 0
-  version: 1.7.0
+  - 1
+  version: 1.7.1
 platform: ruby
 authors: 
 - Thomas Sawyer
@@ -15,11 +15,11 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-04-28 00:00:00 -04:00
+date: 2011-05-07 00:00:00 -04:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
-  name: syckle
+  name: redline
   prerelease: false
   requirement: &id001 !ruby/object:Gem::Requirement 
     none: false
@@ -75,8 +75,6 @@ files:
 - lib/ae/core_ext/exception.rb
 - lib/ae/core_ext/helpers.rb
 - lib/ae/core_ext.rb
-- lib/ae/detest.rb
-- lib/ae/dot.rb
 - lib/ae/expect.rb
 - lib/ae/legacy.rb
 - lib/ae/must.rb
@@ -86,10 +84,10 @@ files:
 - lib/ae/version.rb
 - lib/ae.rb
 - lib/ae.yml
+- HISTORY.rdoc
+- APACHE2.txt
 - README.rdoc
-- Apache2.txt
-- Syckfile
-- History.rdoc
+- Redfile
 - NOTICE.rdoc
 has_rdoc: true
 homepage: http://rubyworks.github.com/ae

data/lib/ae/detest.rb

@@ -1,68 +0,0 @@
-require 'ae/assertion'
-
-class AE
-  # Given that x is "tom" then we can assert it
-  # is using an asseretion pipe.
-  #
-  #  x = "tom"
-  #
-  #  T x == "tom"
-  #
-  # We can assert the opposite using F.
-  #
-  #  F x == "tom"
-  #
-  # These can be used at any point of return.
-  #
-  #  T case x
-  #     when 'tom' then true
-  #     else false
-  #     end
-  #
-  module Detest
-
-    # Test for true.
-    #
-    #   T 1 == 1
-    #
-    def T(x=nil, &b)
-      Assertion.test(x || b.call, :backtrace=>caller)
-    end
-
-    # Test for not.
-    #
-    #   F 1 == 2
-    #
-    def F(x=nil, &b)
-      Assertion.test(!(x || b.call), :backtrace=>caller)
-    end
-
-    # Test for nil?.
-    #
-    #   N nil
-    #
-    def N(x=nil,&b)
-      Assertion.test(nil == (x || b.call), :backtrace=>caller)
-    end
-
-    # Expect and error.
-    #
-    #   E { raise }
-    #
-    # Unless #T, #F and #N, the #E method only supports block notation.
-    def E(&b)
-      expect(Exception, &b)
-    end
-
-    # Catch a symbol.
-    #def C
-    #end
-  end
-
-  module World
-    include AE::Detest
-  end
-
-end
-
-

data/lib/ae/dot.rb

@@ -1,45 +0,0 @@
-# Expiremental Concept
-
-#
-class TrueClass
-  # Assert true.
-  #
-  #   (x == y).true!
-  #
-  def true!(msg=nil)
-    true
-  end
-  # Assert false.
-  #
-  #   (x == y).false!
-  #
-  def false!(err="not false")
-    if Exception === err
-      fail err
-    else
-      fail Assertion.new(err.to_s, :backtrace=>caller)
-    end
-  end
-end
-
-class FalseClass
-  # Assert true.
-  #
-  #   (x == y).true!
-  #
-  def true!(err="not true")
-    if Exception === err
-      fail err
-    else
-      fail Assertion.new(err.to_s, :backtrace=>caller)
-    end
-  end
-  # Assert false.
-  #
-  #   (x == y).false!
-  #
-  def false!(msg=nil)
-    true
-  end
-end
-