visionmedia-jspec 2.3.1 → 2.4.0

data/History.rdoc

@@ -1,4 +1,16 @@
 
+=== 2.4.0 / 2009-06-30
+
+* Added hook() and hookImmutable()
+* Added support for matcher lists ('be enabled disabled selected') == be_enabled, be_disabled etc
+* Added JSpec.include()
+* Added several hooks
+* Added Module support
+* Added grammar conversion of Foo.stub('method') to stub(Foo, 'method') 
+* Added grammar conversion of Foo.destub() to destub(Foo) 
+* Require bind gem
+* Fixed `jspec` bin docs
+
 === 2.3.1 / 2009-06-25
 
 * Fixed; all stubs generated with stub() are restored

data/README.rdoc

@@ -10,6 +10,7 @@ and much more.
 
 * Highly readable
 * Framework / DOM independent
+* Modular via JSpec Module's and hooks
 * Rhino support
 * Async support
 * Ruby JavaScript testing server
@@ -226,6 +227,12 @@ If you would like to whipe an object clear of stubs simply pass it
 to destub() without an additional method argument:
 
   destub(person)
+  
+Alternatively both these utility functions may be called as methods
+on any object when using the JSpec grammar:
+
+  someObject.stub('method').and_return('whatever')
+  // Converted to stub(someObject, 'method').and_return('whatever')
 
 == Helpers
 
@@ -417,7 +424,81 @@ for you, how ever this can be explicitly defined:
       }
     }
   })
+  
+When defining matchers that are extremely similar in functionality, however
+require different names, you may use a prefixed list of words like below which
+defines be_disabled, be_selected, be_checked, and have_type, have_id, etc. Each
+function must return the matcher body which will be used.
+
+  JSpec.addMatchers({
+    'be disabled selected checked' : function(attr) {
+      return 'jQuery(actual).attr("' + attr + '")'
+    },
+
+    'have type id title alt href src sel rev name target' : function(attr) {
+      return function(actual, value) {
+        return value ? jQuery(actual).attr(attr) == value:
+                       jQuery(actual).attr(attr)
+      }
+    }
+  })
 
+== Extending Or Hooking Into JSpec
+
+JSpec provides a hook architecture for extending or analyzing various
+points in its execution, through the use of 'Modules'. For a Module
+example view lib/jspec.jquery.js. 
+
+The following methods or properties are utilized by JSpec:
+
+  - init      : called to initialize a module
+  - utilities : hash of utility functions merged with JSpec.defaultContext
+  - matchers  : hash of matchers merged with JSpec's core matchers via JSpec.addMatchers()
+
+Below is a list of hooks, descriptions, and valid return values which
+may simply be implemented as module methods.
+
+  - running(options)                 : started running JSpec with the options passed    : returning 'stop' will halt running
+  - loading(file)                    : loading a file                                   : returning 'stop' will prevent loading
+  - executing(file)                  : executing a file                                 : returning 'stop' will prevent execution 
+  - posting(data, url)               : posting data to a url                            : returning 'stop' will prevent request
+  - reportingToServer(url)           : reporting to server url                          : returning 'stop' will prevent reporting to server
+  - preprocessing(input)             : before input string is preprocessed              : return input string for next hook to preprocess
+  - stubbing(object, method, result) : called when stubbing an object's method, and return value (result). : (no return value)
+  - requiring(dependency, message)   : requiring a dependency                           : (no return value) 
+  - beforeAssertion(assertion)       : before an assertion has been made                : (no return value)
+  - afterAssertion(assertion)        : after an assertion has been made                 : (no return value)
+  - addingMatcher(name, body)        : unprocessed matcher name and body                : (no return value)
+  - addingSuite(suite)               : adding Suite instance to JSpec                   : (no return value)
+  - beforeSuite(suite)               : before running of suite                          : (no return value)
+  - afterSuite(suite)                : after running of suite                           : (no return value)
+  - beforeSpec(spec)                 : before running of spec                           : (no return value)
+  - afterSpec(spec)                  : after running of spec                            : (no return value)
+  - reporting(options)               : called before reporting                          : (no return value)
+  - evaluatingBody(dsl, matchers, context, contents) : evaluating body contents, with the given context, matchers and dsl. : (no return value)
+  
+For example you may wish to proxy files which are being executed, simply implement the 
+executing method like below. This example will stop execution of any file matching /matchers/.
+
+  MyModule = {
+    executing : function(file) {
+      if (file.match(/matchers/))
+        return 'stop'
+    }
+  }
+  JSpec.include(MyModule)
+  
+Immutable values may also be passed to hooks using hookImmutable() internally. This allows
+for simple numbers, strings, etc to be utilized or altered within a hook implementation. Below
+is an example module which adds functionality to the JSpec grammar by converting SomeObject.stub('method')
+to stub(SomeObject, 'method'):
+
+  JSpec.include({
+    preprocessing : function(input) {
+      return input.replace(/(\w+)\.(stub|destub)\((.*?)\)$/gm, '$2($1, $3)')
+    }
+  })
+  
 == JSpec Command-line Utility
 
 When installed as a Ruby Gem, the `jspec` executable will become available,

data/Rakefile

@@ -13,6 +13,7 @@ Echoe.new "jspec", version do |p|
   p.summary = "JavaScript BDD Testing Framework"
   p.url = "http://visionmedia.github.com/jspec"
   p.runtime_dependencies << "visionmedia-commander >=3.2.9"
+  p.runtime_dependencies << "visionmedia-bind >=0.2.6"
 end
 
 namespace :pkg do

data/bin/jspec

@@ -5,12 +5,13 @@ $:.unshift JSPEC_ROOT
  
 require 'rubygems'
 require 'commander'
+require 'bind'
 require 'fileutils'
 
 RHINO = 'java org.mozilla.javascript.tools.shell.Main'
 
 program :name, 'JSpec'
-program :version, '2.3.1'
+program :version, '2.4.0'
 program :description, 'JavaScript BDD Testing Framework'
 default_command :bind
 
@@ -58,20 +59,25 @@ end
 command :run do |c|
   c.syntax = 'jspec run [path] [options]'
   c.summary = 'Run specifications'
-  c.description = 'Run specifications, defaulting [path] to spec/spec.html. You will need 
-    supply [path] if your specs do not reside in this location. `run --bind` is
-    the default sub-command of jspec so you may simply execute `jspec` in order
-    to bind execution of your specs when a file is altered.
+  c.description = 'Run specifications, defaulting [path] to spec/spec.dom.html.
+    You will need to supply [path] if your specs do not reside 
+    in this location. `run --bind` is the default sub-command of
+    jspec so you may simply execute `jspec` in order to bind execution
+    of your specs when a file is altered.
     
-    JSpec supports Rhino execution when installed. The [path] is assumed to be 
-    spec/spec.js unless specified. See examples below for using the --rhino switch.'
+    JSpec supports Rhino execution when installed. The [path] is assumed
+    to be spec/spec.rhino.js unless specified. See examples below for
+    using the --rhino switch.
+    
+    JSpec\'s server is also available via --server, which defaults 
+    the [path] to spec/server.html'
   c.example 'Run once in Safari', 'jspec run'
   c.example 'Run once in Safari and Firefox', 'jspec run --browsers Safari,Firefox'
   c.example 'Run custom spec file', 'jspec run foo.html'
   c.example 'Auto-run browsers when a file is altered', 'jspec run --bind --browsers Safari,Firefox'
   c.example 'Shortcut for the previous example', 'jspec --browsers Safari,Firefox'
   c.example 'Auto-run rhino when a file is altered', 'jspec --rhino'
-  c.example 'Run Rhino specs once', 'jspec run --rhino'
+  c.example 'Run Rhino specs once', 'jspec run specs/something.js --rhino'
   c.option '-b', '--browsers BROWSERS', Array, 'Specify browsers to test, defaults to Safari'
   c.option '-p', '--paths PATHS', Array, 'Specify paths when binding, defaults to javascript within ./lib and ./spec'
   c.option '-B', '--bind', 'Auto-run specs when source files or specs are altered'
@@ -79,32 +85,26 @@ command :run do |c|
   c.option '-S', '--server', 'Run specs using the JSpec server'
   c.option '-s', '--server-only', 'Start JSpec server without running browsers'
   c.when_called do |args, options|
-    begin
-      require 'bind'
-      options.default :browsers => %w( Safari ), :paths => ['lib/**/*.js', 'spec/**/*.js']
-      
-      # Actions
-      if options.rhino
-        spec = args.shift || 'spec/spec.rhino.js'
-        action = lambda { rhino spec }
-      elsif options.server
-        spec = args.shift || 'spec/spec.server.html'
-        action = lambda { start_server options, spec }
-      else
-        spec = args.shift || 'spec/spec.dom.html'
-        action = Bind::Actions::RefreshBrowsers.new spec, *options.browsers
-      end
-      
-      # Binding
-      if options.bind
-        listener = Bind::Listener.new :paths => options.paths, :interval => 1, :actions => [action], :debug => $stdout
-        listener.run!
-      else
-        action.call File.new(spec)
-      end
-      
-    rescue LoadError
-      abort "jspec run requires the visionmedia-bind gem; http://visionmedia.github.com/bind/"
+    options.default :browsers => %w( Safari ), :paths => ['lib/**/*.js', 'spec/**/*.js']
+    
+    # Actions
+    if options.rhino
+      spec = args.shift || 'spec/spec.rhino.js'
+      action = lambda { rhino spec }
+    elsif options.server
+      spec = args.shift || 'spec/spec.server.html'
+      action = lambda { start_server options, spec }
+    else
+      spec = args.shift || 'spec/spec.dom.html'
+      action = Bind::Actions::RefreshBrowsers.new spec, *options.browsers
+    end
+    
+    # Binding
+    if options.bind
+      listener = Bind::Listener.new :paths => options.paths, :interval => 1, :actions => [action], :debug => $stdout
+      listener.run!
+    else
+      action.call File.new(spec)
     end
   end
 end

data/jspec.gemspec

@@ -2,11 +2,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{jspec}
-  s.version = "2.3.1"
+  s.version = "2.4.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 1.2") if s.respond_to? :required_rubygems_version=
   s.authors = ["TJ Holowaychuk"]
-  s.date = %q{2009-06-25}
+  s.date = %q{2009-06-30}
   s.default_executable = %q{jspec}
   s.description = %q{JavaScript BDD Testing Framework}
   s.email = %q{tj@vision-media.ca}
@@ -26,10 +26,13 @@ Gem::Specification.new do |s|
 
     if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
       s.add_runtime_dependency(%q<visionmedia-commander>, [">= 3.2.9"])
+      s.add_runtime_dependency(%q<visionmedia-bind>, [">= 0.2.6"])
     else
       s.add_dependency(%q<visionmedia-commander>, [">= 3.2.9"])
+      s.add_dependency(%q<visionmedia-bind>, [">= 0.2.6"])
     end
   else
     s.add_dependency(%q<visionmedia-commander>, [">= 3.2.9"])
+    s.add_dependency(%q<visionmedia-bind>, [">= 0.2.6"])
   end
 end

data/lib/jspec.jquery.js

@@ -1,25 +1,28 @@
 
 // JSpec - jQuery - Copyright TJ Holowaychuk <tj@vision-media.ca> (MIT Licensed)
 
-(function(){
-
-  // --- Dependencies
-
-  JSpec.requires('jQuery', 'when using jspec.jquery.js')
+JSpec.include({
+  
+  // --- Initialize
+  
+  init : function() {
+    this.requires('jQuery', 'when using jspec.jquery.js')
+    jQuery.ajaxSetup({ async : false })
+  },
+  
+  // --- Utilities
+  
+  utilities : {
+    element : jQuery,
+    elements : jQuery,
+    sandbox : function() {
+      return jQuery('<div class="sandbox"></div>')
+    }
+  },
   
-  // --- Async Support
-
-  jQuery.ajaxSetup({ async : false })
-
-  // --- Helpers
-
-  JSpec.defaultContext.element = jQuery
-  JSpec.defaultContext.elements = jQuery
-  JSpec.defaultContext.sandbox = function() { return jQuery('<div class="sandbox"></div>') }
-
   // --- Matchers
-
-  JSpec.addMatchers({
+  
+  matchers : {
     have_tag      : "jQuery(expected, actual).length == 1",
     have_one      : "alias have_tag",
     have_tags     : "jQuery(expected, actual).length > 1",
@@ -32,33 +35,27 @@
     be_hidden     : "jQuery(actual).is(':hidden')",
     be_enabled    : "!jQuery(actual).attr('disabled')",
     have_class    : "jQuery(actual).hasClass(expected)",
-    
+
     have_classes : function(actual) {
       return !JSpec.any(JSpec.argumentsToArray(arguments, 1), function(arg){
         return !JSpec.does(actual, 'have_class', arg)
       })
     },
-    
+
     have_attr : function(actual, attr, value) {
       return value ? jQuery(actual).attr(attr) == value:
                      jQuery(actual).attr(attr)
+    },
+    
+    'be disabled selected checked' : function(attr) {
+      return 'jQuery(actual).attr("' + attr + '")'
+    },
+    
+    'have type id title alt href src sel rev name target' : function(attr) {
+      return function(actual, value) {
+        return JSpec.does(actual, 'have_attr', attr, value)
+      }
     }
-  })
-  
-  // --- be_BOOLATTR
-  
-  JSpec.each('disabled selected checked', function(attr){
-    JSpec.addMatcher('be_' + attr, "jQuery(actual).attr('" + attr + "')")
-  })
-  
-  // --- have_ATTR
-  
-  JSpec.each('type id title alt href src rel rev name target', function(attr){
-    JSpec.addMatcher('have_' + attr, function(actual, value) {
-      return JSpec.matchers.have_attr.match(actual, attr, value)
-    })
-  })
-  
-})()
-
+  }
+})
 

data/lib/jspec.js

@@ -5,8 +5,9 @@
 
   JSpec = {
 
-    version   : '2.3.1',
+    version   : '2.4.0',
     suites    : [],
+    modules   : [],
     allSuites : [],
     matchers  : {},
     stubbed   : [],
@@ -431,7 +432,7 @@
         
         runDeferredAssertions : function() {
           each(this.assertions, function(assertion){
-            if (assertion.defer) assertion.run().report()
+            if (assertion.defer) assertion.run().report(), hook('afterAssertion', assertion)
           })
         },
         
@@ -473,6 +474,13 @@
       })
     },
     
+    Module : function(methods) {
+      extend(this, methods)
+      extend(this, {
+        requires : JSpec.requires
+      })
+    },
+    
     // --- DSLs
     
     DSLs : {
@@ -513,6 +521,72 @@
 
     // --- Methods
     
+    /**
+     * Check if _value_ is 'stop'. For use as a
+     * utility callback function.
+     *
+     * @param  {mixed} value
+     * @return {bool}
+     * @api public
+     */
+    
+    haveStopped : function(value) {
+      return value === 'stop'
+    },
+    
+    /**
+     * Include _object_ which may be a hash or Module instance.
+     *
+     * @param  {has, Module} object
+     * @api public
+     */
+    
+    include : function(object) {
+      var module = object.constructor == JSpec.Module ? object : new JSpec.Module(object)
+      this.modules.push(module)
+      if ('init' in module) module.init()
+      if ('utilities' in module) extend(this.defaultContext, module.utilities)
+      if ('matchers' in module) this.addMatchers(module.matchers)
+    },
+    
+    /**
+     * Add a module hook _name_, which is immediately
+     * called per module with the _args_ given. An array of
+     * hook return values is returned.
+     *
+     * @param  {name} string
+     * @param  {mixed} args ...
+     * @return {array}
+     * @api private
+     */
+    
+    hook : function(name, args) {
+      args = argumentsToArray(arguments, 1)
+      return inject(JSpec.modules, [], function(results, module){
+        if (typeof module[name] == 'function')
+          results.push(module[name].apply(module, args))
+      })
+    },
+    
+    /**
+     * Same as hook() however accepts only one _arg_ which is
+     * considered immutable. This function passes the arg
+     * to the first module, then passes the return value of the last
+     * module called, to the following module. 
+     *
+     * @param  {string} name
+     * @param  {mixed} arg
+     * @return {mixed}
+     * @api private
+     */
+    
+    hookImmutable : function(name, arg) {
+      return inject(JSpec.modules, arg, function(result, module){
+        if (typeof module[name] == 'function')
+          return module[name].call(module, result)
+      })
+    },
+    
     /**
      * Find a suite by its description or name.
      *
@@ -768,6 +842,9 @@
       *   does('foo', 'eql', 'foo')
       *   does([1,2], 'include', 1, 2)
       *
+      * External hooks are not run for internal assertions
+      * performed by does().
+      *
       * @param  {mixed} actual
       * @param  {string} matcher
       * @param  {...} expected
@@ -794,11 +871,11 @@
 
     expect : function(actual) {
       assert = function(matcher, args, negate) {
-        var expected = []
-        for (i = 1; i < args.length; i++) expected.push(args[i])        
+        var expected = argumentsToArray(args, 1)        
         assertion = new JSpec.Assertion(matcher, actual, expected, negate)
+        hook('beforeAssertion', assertion)
         if (matcher.defer) assertion.run()
-        else JSpec.currentSpec.assertions.push(assertion.run().report())
+        else JSpec.currentSpec.assertions.push(assertion.run().report()), hook('afterAssertion', assertion)
         return assertion.result
       }
       
@@ -857,9 +934,9 @@
       */
      
      extend : function(object, other) {
-      each(other, function(property, value){
-        object[property] = value
-      })
+       each(other, function(property, value){
+         object[property] = value
+       })
      },
      
      /**
@@ -942,6 +1019,7 @@
      stub : function(object, method) {
        return {
          and_return : function(result) {
+           hook('stubbing', object, method, result)
            JSpec.stubbed.push(object)
            var type = object.hasOwnProperty(method) ? '__original__' : '__prototype__'
            object[type + method] = object[method]
@@ -976,9 +1054,8 @@
          
     any : function(object, callback) {
       return inject(object, null, function(state, key, value){
-        return state ? state : 
-                 callIterator(callback, key, value) ? 
-                   value : state
+        if (state == undefined)
+          return callIterator(callback, key, value) ? value : state
       })
     },
     
@@ -993,9 +1070,9 @@
      */
     
     select : function(object, callback) {
-      return inject(object, [], function(memo, key, value){
+      return inject(object, [], function(selected, key, value){
         if (callIterator(callback, key, value))
-          memo.push(value)
+          selected.push(value)
       })
     },
 
@@ -1021,6 +1098,14 @@
      */
     
     addMatcher : function(name, body) {
+      hook('addingMatcher', name, body)
+      if (name.indexOf(' ') != -1) {
+        var matchers = name.split(/\s+/)
+        var prefix = matchers.shift()
+        each(matchers, function(name) {
+          JSpec.addMatcher(prefix + '_' + name, body(name))
+        })
+      }
       this.matchers[name] = this.normalizeMatcherMessage(this.normalizeMatcherBody(body))
       this.matchers[name].name = name
     },
@@ -1035,6 +1120,7 @@
     
     describe : function(description, body) {
       var suite = new JSpec.Suite(description, body)
+      hook('addingSuite', suite)
       this.allSuites.push(suite)
       this.suites.push(suite)
     },
@@ -1065,6 +1151,7 @@
       var matchers = this.matchers
       var context = this.context || this.defaultContext
       var contents = this.contentsOf(body)
+      hook('evaluatingBody', dsl, matchers, context, contents)
       try { eval('with (dsl){ with (context) { with (matchers) { ' + contents + ' }}}') }
       catch(e) { error(errorMessage, e) }
     },
@@ -1078,7 +1165,9 @@
      */
 
     preprocess : function(input) {
+      input = hookImmutable('preprocessing', input)
       return input.
+        replace(/(\w+)\.(stub|destub)\((.*?)\)$/gm, '$2($1, $3)').
         replace(/describe\s+(.*?)$/gm, 'describe($1, function(){').
         replace(/\sit\s+(.*?)$/gm, ' it($1, function(){').
         replace(/^(?: *)(before_each|after_each|before|after)(?= |\n|$)/gm, 'JSpec.currentSuite.addHook("$1", function(){').
@@ -1114,9 +1203,8 @@
      */
 
     report : function() {
-      JSpec.options.formatter ? 
-        new JSpec.options.formatter(JSpec, JSpec.options):
-          new JSpec.formatters.DOM(JSpec, JSpec.options)
+      hook('reporting', JSpec.options)
+      new (JSpec.options.formatter || JSpec.formatters.DOM)(JSpec, JSpec.options)
     },
 
     /**
@@ -1129,6 +1217,7 @@
      */
 
     run : function(options) {
+      if (any(hook('running'), haveStopped)) return this
       if (options) extend(this.options, options)
       if (option('profile')) console.group('Profile')
       each(this.suites, function(suite) { JSpec.runSuite(suite) })
@@ -1147,18 +1236,18 @@
       this.currentSuite = suite
       this.evalBody(suite.body)
       suite.ran = true
-      suite.hook('before')
+      suite.hook('before'), hook('beforeSuite', suite)
       each(suite.specs, function(spec) {
-        suite.hook('before_each')
+        suite.hook('before_each'), hook('beforeSpec', spec)
         JSpec.runSpec(spec)
-        suite.hook('after_each')
+        suite.hook('after_each'), hook('afterSpec', spec)
       })
       if (suite.hasSuites()) {
         each(suite.suites, function(suite) {
           JSpec.runSuite(suite)
         })
       }
-      suite.hook('after')
+      suite.hook('after'), hook('afterSuite', suite)
       this.stats.suitesFinished++
     },
          
@@ -1202,8 +1291,9 @@
      */
 
     requires : function(dependency, message) {
+      hook('requiring', dependency, message)
       try { eval(dependency) }
-      catch (e) { error('JSpec depends on ' + dependency + ' ' + message) }
+      catch (e) { throw 'JSpec depends on ' + dependency + ' ' + message }
     },
 
     /**
@@ -1246,6 +1336,7 @@
      */
     
     post : function(url, data) {
+      if (any(hook('posting', url, data), haveStopped)) return
       var request = this.xhr()
       request.open('POST', url, false)
       request.setRequestHeader('Content-Type', 'application/x-www-form-urlencoded')
@@ -1260,6 +1351,7 @@
      */
     
     reportToServer : function(url) {
+      if (any(hook('reportingToServer', url), haveStopped)) return
       JSpec.post(url || 'http://localhost:4444', 'passes=' + JSpec.stats.passes + '&failures=' + JSpec.stats.failures)
 			if ('close' in main) main.close()
     },
@@ -1297,6 +1389,7 @@
      */
 
     load : function(file) {
+      if (any(hook('loading', file), haveStopped)) return
       if (this.hasXhr()) {
         var request = this.xhr()
         request.open('GET', file, false)
@@ -1318,6 +1411,7 @@
      */
 
     exec : function(file) {
+      if (any(hook('executing', file), haveStopped)) return this
       eval('with (JSpec){' + this.preprocess(this.load(file)) + '}')
       return this
     }
@@ -1325,31 +1419,11 @@
 
   // --- Utility functions
 
-  var main   = this
-  var stub   = JSpec.stub
-  var destub = JSpec.destub
-  var map    = JSpec.map
-  var any    = JSpec.any
-  var find   = JSpec.any
-  var last   = JSpec.last
-  var fail   = JSpec.fail
-  var range  = JSpec.range
-  var each   = JSpec.each
-  var option = JSpec.option
-  var inject = JSpec.inject
-  var select = JSpec.select
-  var error  = JSpec.error
-  var escape = JSpec.escape
-  var extend = JSpec.extend
-  var puts   = JSpec.puts
-  var hash   = JSpec.hash
-  var query  = JSpec.query
-  var strip  = JSpec.strip
-  var color  = JSpec.color
-  var does   = JSpec.does
-  var addMatchers = JSpec.addMatchers
-  var callIterator = JSpec.callIterator
-  var argumentsToArray = JSpec.argumentsToArray
+  var main = this
+  var find = JSpec.any
+  var utils = 'haveStopped stub hookImmutable hook destub map any last fail range each option inject select error escape \
+               extend puts hash query strip color does addMatchers callIterator argumentsToArray'.split(/\s+/)
+  while (utils.length) util = utils.shift(), eval('var ' + util + ' = JSpec.' + util)
   if (!main.setTimeout) main.setTimeout = function(callback){ callback() }
 
   // --- Matchers

data/spec/spec.jquery.js

@@ -1,6 +1,6 @@
 
 describe 'jQuery'
-  describe 'sandbox'
+  describe 'sandbox()'
     before
       dom = sandbox()
     end
@@ -11,6 +11,13 @@ describe 'jQuery'
     end
   end
   
+  describe 'element() / elements()'
+    it 'should alias jQuery'
+      element.should.be jQuery
+      elements.should.be jQuery
+    end
+  end
+  
   describe 'async'
     it 'should load mah cookies (textfile)'
       $.post('async', function(text){

data/spec/spec.utils.js

@@ -13,6 +13,14 @@ describe 'Utility'
         object.stubby().should.eql 'Im stubbed'
         object.toString().should.eql '<No im not>'
       end
+      
+      it 'should allow being called as a core prototype method'
+        foo = { bar : function(){ return 'baz' }}
+        foo.stub('bar').and_return('something else')
+        foo.bar().should.eql 'something else'
+        foo.destub()
+        foo.bar().should.eql 'baz'
+      end
     end
     
     describe 'destub()'
@@ -140,6 +148,14 @@ describe 'Utility'
       })
       result.should.eql 'some'
     end
+    
+    describe 'haveStopped'
+      it 'should check if "stop" has been returned by a callback hook'
+        any([true, 'stop'], haveStopped).should.eql 'stop'
+        any([true, true], haveStopped).should.be_null
+        any([true, null], haveStopped).should.be_null
+      end
+    end
   end
   
   describe 'select()'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: visionmedia-jspec
 version: !ruby/object:Gem::Version 
-  version: 2.3.1
+  version: 2.4.0
 platform: ruby
 authors: 
 - TJ Holowaychuk
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-06-25 00:00:00 -07:00
+date: 2009-06-30 00:00:00 -07:00
 default_executable: jspec
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -22,6 +22,16 @@ dependencies:
       - !ruby/object:Gem::Version 
         version: 3.2.9
     version: 
+- !ruby/object:Gem::Dependency 
+  name: visionmedia-bind
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.2.6
+    version: 
 description: JavaScript BDD Testing Framework
 email: tj@vision-media.ca
 executables: