Changeset 276

Timestamp:

07/12/07 12:01:34 (17 months ago)

Author:

ged

Message:

source:trunk/Rakefile

• Moved the default spec task into the toplevel namespace.

source:trunk/spec/hookable.tests.rb
source:trunk/spec/hookable_spec.rb

• Converted Hookable unit test suite to RSpec specification

source:trunk/spec/gameobject_spec.rb

• Fixed a bug in the spec for FaerieMUD::GameObject?

source:trunk/tests/entity.tests.rb
source:trunk/tests/event.tests.rb
source:trunk/tests/hookable.tests.rb
source:trunk/tests/developmentalobject.tests.rb
source:trunk/tests/commandparser.tests.rb
source:trunk/tests/character.tests.rb
source:trunk/tests/composedobject.tests.rb
source:trunk/tests/gameobject.tests.rb
source:trunk/tests/area.tests.rb
source:trunk/tests/animatedobject.tests.rb

• Deleting unit tests that have already been converted to RSpec specifications

source:trunk/lib/fm/mixins.rb

• Fixed spelling mistake

Location:

trunk

Files:

• Rakefile (modified) (4 diffs)
• lib/fm/mixins.rb (modified) (1 diff)
• spec/gameobject_spec.rb (modified) (1 diff)
• spec/hookable_spec.rb (moved) (moved from trunk/spec/hookable.tests.rb) (2 diffs)
• tests/animatedobject.tests.rb (deleted)
• tests/area.tests.rb (deleted)
• tests/character.tests.rb (deleted)
• tests/commandparser.tests.rb (deleted)
• tests/composedobject.tests.rb (deleted)
• tests/developmentalobject.tests.rb (deleted)
• tests/entity.tests.rb (deleted)
• tests/event.tests.rb (deleted)
• tests/gameobject.tests.rb (deleted)
• tests/hookable.tests.rb (deleted)

trunk/Rakefile

@@ -42 +42 @@
                 LIB_FILES
 
-task :default  => 'spec:normal'
+task :default  => :spec
 
 ###########################
@@ -49 +49 @@
 
 # Task: rdoc
-Rake::RDocTask.new { |rdoc|
+Rake::RDocTask.new do |rdoc|
     rdoc.rdoc_dir = 'doc'
     rdoc.title    = "FaerieMUD"
@@ -55 +55 @@
     rdoc.rdoc_files.include TEXT_FILES
     rdoc.rdoc_files.include LIB_FILES
-}
+end
 
 
@@ -62 +62 @@
 ###########################
 
+desc "Run specs outputting to STDOUT"
+Spec::Rake::SpecTask.new( :spec ) do |task|
+    task.ruby_opts << '-rubygems'
+    task.libs << 'lib'
+    task.spec_files = SPEC_FILES
+    task.spec_opts = ['-f s', '-r fm', '-c']
+end
+
 ### Task: spec
 namespace :spec do
-    desc "Run specs outputting to STDOUT"
-    Spec::Rake::SpecTask.new( :normal ) do |task|
-        task.ruby_opts << '-rubygems'
-        task.libs << 'lib'
-        task.spec_files = SPEC_FILES
-        task.spec_opts = ['-f s', '-r fm', '-c']
-    end
-
     desc "Generate plaintext output"
     Spec::Rake::SpecTask.new( :text ) do |task|

trunk/lib/fm/mixins.rb

@@ -445 +445 @@
                 name = symbol.id2name
 
-                # If the caller hasn't speicifed a method, just pop the last one
+                # If the caller hasn't specified a method, just pop the last one
                 # off the stack. If the caller specified a Proc, subtract it
                 # from the stack after making sure it's there for the return

trunk/spec/gameobject_spec.rb

@@ -96 +96 @@
 
 
+class RevClass < FaerieMUD::GameObject
+    SVNRev = 'Rev: 270'
+end
+
 describe FaerieMUD::GameObject do
-    before( :all ) do
-        @class = Class.new( FaerieMUD::GameObject ) do
-            SVNRev = 'Rev: 270 '
-        end
-    end
-    
-    
     it "can extract a numeric version from its subversion rev number" do
-        @class.rev.should == 270
+        RevClass.rev.should == 270
     end
 end

trunk/spec/hookable_spec.rb

@@ -1 +1 @@
 #!/usr/bin/ruby -w
 #
-# Unit test for the FaerieMUD::Hookable mixin.
+# Specification for the FaerieMUD::GameObject class
 # $Id$
 #
-# Copyright (c) 2004 The FaerieMUD Consortium. Most rights reserved.
-# 
-# This work is licensed under the Creative Commons Attribution-ShareAlike
-# License. To view a copy of this license, visit
-# http://creativecommons.org/licenses/by-sa/1.0/ or send a letter to Creative
-# Commons, 559 Nathan Abbott Way, Stanford, California 94305, USA.
-#
+# Copyright (c) 2003-2007 The FaerieMUD Consortium.
 # 
 
@@ -18 +12 @@
     $LOAD_PATH.unshift "#{basedir}/lib" unless
         $LOAD_PATH.include?( "#{basedir}/lib" )
-    $LOAD_PATH.unshift "#{basedir}/tests/lib" unless
-        $LOAD_PATH.include?( "#{basedir}/tests/lib" )
-
-    require 'fmtestcase'
+    $LOAD_PATH.unshift "#{basedir}/spec/lib" unless
+        $LOAD_PATH.include?( "#{basedir}/spec/lib" )
 end
 
+require 'spec/runner'
 require 'fm/mixins'
 
-### Test case for the FaerieMUD::Hookable mixin.
-class HookableTestCase < FaerieMUD::TestCase
+# Hooked class
+class HookableObject < FaerieMUD::GameObject
+    include FaerieMUD::Hookable
 
-    WarkMessage = "Wark! Wark! Some tasty %s greens!"
-
-    TestedHooks = {
-        :tripling       => Proc::new {|arg| arg * 3},
-        :reversing      => Proc::new {|arg| arg.reverse},
-        :uppercasing    => Proc::new {|arg| arg.upcase},
-        :novowels       => :extractVowels,
-    }
+    # By default, just return the first argument unmodified
+    def test( msg )
+        return msg
+    end
+end
 
 
-    ### Setup method (aliased for older versions of Test::Unit)
-    def setup 
+describe "An instance of a class which has included FaerieMUD::Hookable" do
 
-        # Hooked class
-        @hclass = Class::new( Object ) {
-            include FaerieMUD::Hookable
-            def wark( thing )
-                msg = WarkMessage % thing
-                debug_msg( msg + "\n" )
-                return msg
-            end
-        }
-
-        # Derived hooked class
-        @dhclass = Class::new( @hclass ) {
-            include FaerieMUD::Hookable
-        }
-
-        super
-    end
-    alias_method :set_up, :setup
-
-
-    ### Teardown method (aliased for older version of Test::Unit)
-    def teardown 
-        @hclass = nil
-        @dhclass = nil
-
-        super
-    end
-    alias_method :tear_down, :teardown
-
-
-    ### Hook method to test method hooks
-    def extractVowels( arg )
-        arg.gsub( /[aeiou]+/, '' )
+    before( :each ) do
+        @hookableobj = HookableObject.new
     end
 
 
-
-
-    #################################################################
-    ### E X A M P L E S
-    #################################################################
-
-    ### Test inclusion
-    def test_00_included
-        hobj, dhobj = nil, nil
-
-        assert_nothing_raised { hobj = @hclass::new }
-        assert_nothing_raised { dhobj = @dhclass::new }
-
-        [ :hooks, :hook, :unhook ].each {|sym|
-            assert_respond_to hobj, sym, "Hooked class instance"
-            assert_respond_to dhobj, sym, "Hooked class derivative instance"
-        }
-
-        self.class::addSetupBlock {
-            @hobj, @dhobj = @hclass::new, @dhclass::new
-        }
-        self.class::addTeardownBlock {
-            @hobj = nil
-            @dhobj = nil
-        }
+    it "allows a public method to be intercepted via a hook" do
+        @hookableobj.test( 'thing' ).should == 'thing'
+        @hookableobj.hook( :test ) {|arg| arg.reverse }
+        @hookableobj.test( 'thing' ).should == 'gniht'
     end
 
 
-    ### Test methods with no hooks
-    def test_01_emptyhooks
-        {
-            @hobj => "Hooked class instance",
-            @dhobj => "Hooked class derivative instance"
-        }.each {|obj, objtype|
-            rval = nil
-            assert_nothing_raised { rval = obj.hooks }
-            assert_equal Hash::new, rval,
-                "#{objtype} #hooks method did not return a Hash."
-        }
+    it "s hooks don't interfere with any other instances of the same class" do
+        @hookableobj2 = HookableObject.new
+        @hookableobj.hook( :test ) {    }
     end
+    
+    it "knows about any hooks which are applied to it" do
+        # Starts out with no hooks...
+        @hookableobj.hooks.should be_a_kind_of( Hash )
+        @hookableobj.hooks.should be_empty()
 
+        # Hook the #test methodq
+        @hookableobj.hook( :test ) {|arg| arg.reverse }
 
-    ### Unhooked method call
-    def test_02_prehook
-        printTestHeader "Unhooked method call"
-        rval = nil
-        greensType = "Tantal"
+        # ...then it should have hooks. The original method should be the first thing 
+        # in the list, then a Proc for each hook
+        @hookableobj.hooks.should have(1).keys
+        @hookableobj.hooks[ :test ].should be_an_instance_of( Array )
+        @hookableobj.hooks[ :test ].should have(2).members
+        @hookableobj.hooks[ :test ].first.should be_an_instance_of( Method )
+        @hookableobj.hooks[ :test ].last.should be_an_instance_of( Proc )
+    end
+    
+    
+    it "allows the last-applied hook to be removed from a method" do
+        hookproc = Proc.new {|arg| :noop }
+        @hookableobj.hook( :test, &hookproc ) 
+        @hookableobj.unhook( :test ).should == hookproc
+    end
+    
+    
+    it "allows a chain of hooks to be applied to a single method, which are called " +
+       "in reverse of the order they are applied" do
+        
+        @hookableobj.hook( :test ) {|arg| arg.reverse + '1' }
+        @hookableobj.hook( :test ) {|arg| arg.upcase + '2' }
+        @hookableobj.hook( :test ) {|arg| arg.gsub(/[aeiou]+/i, '') + '3' }
+        
+        @hookableobj.test( 'thingerything' ).should == '23GNHTYRGNHT1'
+    end
+    
+    
+    it "allows a hook to be removed from an arbitrary point in a chain via reference" do
+        @hookableobj.hook( :test ) {|arg| arg.reverse + '1' }
+        upcasehook = @hookableobj.hook( :test ) {|arg| arg.upcase + '2' }
+        @hookableobj.hook( :test ) {|arg| arg.gsub(/[aeiou]+/i, '') + '3' }
+        
+        @hookableobj.unhook( :test, upcasehook )
 
-        assert_nothing_raised { rval = @hobj.wark(greensType) }
-        assert_equal WarkMessage % greensType, rval
+        @hookableobj.test( 'thingerything' ).should == '3gnhtyrgnht1'
     end
+    
+    
+    it "allows all hooks to be removed from a method" do
+        @hookableobj.hook( :test ) {|arg| arg.reverse + '1' }
+        @hookableobj.hook( :test ) {|arg| arg.upcase + '2' }
+        @hookableobj.hook( :test ) {|arg| arg.gsub(/[aeiou]+/i, '') + '3' }
+
+        @hookableobj.unhook_all( :test )
         
+        @hookableobj.test( 'thingerything' ).should == 'thingerything'
+    end
+    
+    
+    it "sets up an alias for the unhooked version of a hooked method" do
+        @hookableobj.hook( :test ) {|arg| arg.reverse + '1' }
+        @hookableobj.hook( :test ) {|arg| arg.upcase + '2' }
+        @hookableobj.hook( :test ) {|arg| arg.gsub(/[aeiou]+/i, '') + '3' }
 
-    ### Test hooks
-    def test_03_hooks
-        printTestHeader "Hooked method calls"
-        hook, msg = nil, nil
-        greensType = "Tantal"
-        procs = []
-        count = 0
-
-        # For each hook in TestedHooks, add the proc as a hook and test the object
-        TestedHooks.sort {|a,b| a[0].to_s <=> b[0].to_s}.each {|name,proc|
-            count += 1
-            proc = method( proc ).to_proc if proc.is_a?( Symbol )
-            procs.push( proc )
-
-            assert_nothing_raised {
-                hook = @hobj.hook( :wark, &proc )
-            }
-            assert_instance_of Proc, hook
-            assert_equal proc.to_proc, hook
-            
-            assert_nothing_raised { msg = @hobj.wark(greensType) }
-            debug_msg "Wark, after #{count} hook/s: #{msg.inspect}"
-            expectedMsg = greensType
-            procs.each {|proc| expectedMsg.replace( proc.call(expectedMsg) )}
-            assert_equal WarkMessage % expectedMsg, msg
-        }
-
-        # Add setup to to hook @hobj for each successive test
-        self.class::addSetupBlock {
-            @hooks = []
-            TestedHooks.sort {|a,b| a[0].to_s <=> b[0].to_s}.each {|name,proc|
-                proc = method( proc ).to_proc if proc.is_a?( Symbol )
-                @hooks.push( proc )
-                @hobj.hook( :wark, &proc )
-            }
-        }
-        self.class::addTeardownBlock {
-            @hooks = nil
-        }
-    end
-
-    ### Test second instance of the same class as the hooked object
-    def test_04_second_instance
-        printTestHeader "Testing second instance of the hooked object's class"
-        msg = nil
-
-        assert_nothing_raised {
-            msg = @hclass::new.wark( "Gysal" )
-        }
-        debug_msg msg.inspect
-        assert_equal WarkMessage % "Gysal", msg
-    end
-
-
-    ### Test the instance of the derivative class
-    def test_05_derivative_instance
-        printTestHeader "Testing the derivative class instance"
-        msg = nil
-
-        assert_nothing_raised {
-            msg = @dhobj.wark( "Pahsana" )
-        }
-        debug_msg msg.inspect
-        assert_equal WarkMessage % "Pahsana", msg
-    end
-
-    ### Test to make sure the unhooked method can still be called through the
-    ### __unhooked_ alias.
-    def test_06_unhooked_variant
-        debug_msg "Trying @hobj's unhooked alias"
-        msg = nil
-
-        assert_nothing_raised {
-            msg = @hobj.__unhooked_wark( "Reagan" )
-        }
-        debug_msg msg.inspect
-        assert_equal WarkMessage % "Reagan", msg
-    end
-
-    ### Test removal of last hook.
-    def test_07_unhook_onearg
-        printTestHeader "Testing unhook( symbol )"
-        hook, msg = nil, nil
-        greensType = "Curiel"
-
-        # Last hook
-        debug_msg "Removing last hook added:"
-        assert_nothing_raised {
-            hook = @hobj.unhook( :wark )
-        }
-        assert_equal @hooks.last, hook
-        @hooks.pop
-
-        debug_msg "Hooks: %s" % @hobj.hooks.inspect
-
-        debug_msg "First wark after unhook: "
-        assert_nothing_raised {
-            msg = @hobj.wark( greensType )
-        }
-        debug_msg msg.inspect
-        expectedMsg = greensType
-        @hooks.each {|proc| expectedMsg.replace( proc.call(expectedMsg) )}
-        assert_equal WarkMessage % expectedMsg, msg
-    end
-
-
-    ### Test removal of a specific hook, out of order.
-    def test_08_unhook_twoargs
-        printTestHeader "Testing unhook( symbol, hook )"
-        hook, msg = nil, nil
-        greensType = "Curiel"
-
-        # First hook (out of order)
-        debug_msg "Removing first hook (out of order):"
-        assert_nothing_raised {
-            hook = @hobj.unhook( :wark, @hooks.first )
-        }
-        assert_equal @hooks.first, hook
-        @hooks.shift
-
-        debug_msg "Hooks: %s" % @hobj.hooks.inspect
-
-        assert_nothing_raised {
-            msg = @hobj.wark( greensType )
-        }
-        debug_msg msg.inspect
-        expectedMsg = greensType
-        @hooks.each {|proc| expectedMsg.replace( proc.call(expectedMsg) )}
-        assert_equal WarkMessage % expectedMsg, msg
-    end
-
-
-    ### Test removing all hooks
-    def test_09_unhook_all
-        printTestHeader "Testing behaviour after all hooks are unhooked"
-        hook, msg = nil, nil
-        greensType = "Curiel"
-
-        # Remaining hook
-        debug_msg "Removing all hooks:"
-        assert_nothing_raised {
-            @hobj.unhook_all( :wark )
-        }
-
-        debug_msg "Hooks: %s" % @hobj.hooks.inspect
-
-        debug_msg "Wark after unhook all: "
-        assert_nothing_raised {
-            msg = @hobj.wark( greensType )
-        }
-        debug_msg msg.inspect
-        assert_equal WarkMessage % greensType, msg
-
-        # Test to be sure #wark is unhooked
-        debug_msg "Should be completely unhooked now:"
-        assert_equal @hobj.method(:__unhooked_wark), @hobj.method( :wark )
+        @hookableobj.__unhooked_test( 'thingerything' ).should == 'thingerything'
     end