visionmedia-jspec 1.1.1

data/Rakefile

@@ -0,0 +1,70 @@
+
+require 'rubygems'
+require 'rake'
+require 'echoe'
+
+def version
+  $1 if File.read('lib/jspec.js').match /version *: *'(.*?)'/
+end
+
+Echoe.new "jspec", version do |p|
+  p.author = "TJ Holowaychuk"
+  p.email = "tj@vision-media.ca"
+  p.summary = "JavaScript BDD Testing Framework"
+  p.url = "http://visionmedia.github.com/jspec"
+  p.runtime_dependencies << "visionmedia-commander >=3.2.9"
+end
+
+desc 'Package'
+task :package => [:clear] do
+  begin
+    sh 'mkdir pkg'
+    sh 'cp -fr lib/* pkg'
+    minify 'lib/jspec.js', 'pkg/jspec.min.js'
+    minify 'lib/jspec.jquery.js', 'pkg/jspec.jquery.min.js'
+    compress 'lib/jspec.css', 'pkg/jspec.min.css'
+    sh 'git add pkg/.'
+  rescue Exception => e
+    puts "Failed to package: #{e}."
+  else 
+    puts "Packaging of JSpec-#{version} completed."
+  end
+end
+
+desc 'Clear packaging'
+task :clear do
+  if File.directory? 'pkg'
+    sh 'rm -fr pkg/*'
+    sh 'rmdir pkg'
+  end
+end
+
+desc 'Display compression savings of last release'
+task :savings do
+  totals = Hash.new { |h, k|  h[k] = 0 }
+  format = '%-20s : %0.3f kb'
+  totals = %w( pkg/jspec.min.js pkg/jspec.jquery.min.js pkg/jspec.min.css ).inject totals do |total, file|
+    uncompressed = File.size(file.sub('.min', '')).to_f / 1024
+    compressed = File.size(file).to_f / 1024
+    saved = uncompressed - compressed
+    puts format % [file.sub('pkg/', ''), saved]
+    totals[:saved] += saved
+    totals[:uncompressed] += uncompressed
+    totals[:compressed] += compressed
+    totals
+  end
+  puts
+  puts format % ['total uncompressed', totals[:uncompressed]]
+  puts format % ['total compressed', totals[:compressed]]
+  puts format % ['total saved', totals[:saved]]
+end
+
+def minify from, to
+  sh "jsmin < #{from} > #{to}"
+end
+
+def compress from, to
+  File.open(to, 'w+') do |file|
+    file.write File.read(from).gsub(/(^[\t ]*)|\n/, '')
+  end
+end

data/bin/jspec

@@ -0,0 +1,64 @@
+#!/usr/bin/env ruby
+
+require 'rubygems'
+require 'commander'
+require 'fileutils'
+
+JSPEC_ROOT = File.expand_path(File.join(File.dirname(__FILE__), '..'))
+
+program :name, 'JSpec'
+program :version, '1.1.1'
+program :description, 'JavaScript BDD Testing Framework'
+default_command :bind
+
+command :init do |c|
+  c.syntax = 'jspec init [dest] [options]'
+  c.summary = 'Initialize a JSpec project template'
+  c.description = 'Initialize a JSpec project template. Defaults to the current directory when <dest> is not specified.'
+  c.example 'Create a directory foo, initialized with a jspec template', 'jspec init foo'
+  c.when_called do |args, options|
+    dest = args.shift || '.'
+    unless Dir[dest + '/*'].empty?
+      abort unless agree "'#{dest}' is not empty; continue? "
+    end
+    FileUtils.mkdir_p dest
+    FileUtils.cp_r File.join(JSPEC_ROOT, 'templates', 'default', '.'), dest
+    spec = File.join dest, 'spec', 'spec.html'
+    contents = File.read spec
+    File.open(spec, 'w') { |file| file.write contents.gsub('JSPEC_ROOT', JSPEC_ROOT) }
+    say "Template initialized at '#{dest}'."
+  end
+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.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-refresh browsers when a file is altered', 'jspec run --bind --browsers Safari,Firefox'
+  c.example 'Shortcut for the previous example', 'jspec --browsers Safari,Firefox'
+  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'
+  c.when_called do |args, options|
+    begin
+      require 'bind'
+      spec = args.shift || 'spec/spec.html'
+      options.default :browsers => %w( Safari ), :paths => ['lib/**/*.js', 'spec/**/*.js']
+      action = Bind::Actions::RefreshBrowsers.new spec, *options.browsers
+      if options.bind
+        listener = Bind::Listener.new :paths => options.paths, :interval => 1, :actions => [action], :debug => $stdout
+        listener.run!
+      else
+        action.call spec
+      end
+    rescue LoadError
+      abort "jspec run requires the visionmedia-bind gem; http://visionmedia.github.com/bind/"
+    end
+  end
+end
+alias_command :bind, :run, '--bind'

data/jspec.gemspec

@@ -0,0 +1,36 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{jspec}
+  s.version = "1.1.1"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 1.2") if s.respond_to? :required_rubygems_version=
+  s.authors = ["TJ Holowaychuk"]
+  s.date = %q{2009-04-12}
+  s.default_executable = %q{jspec}
+  s.description = %q{JavaScript BDD Testing Framework}
+  s.email = %q{tj@vision-media.ca}
+  s.executables = ["jspec"]
+  s.extra_rdoc_files = ["bin/jspec", "lib/images/bg.png", "lib/images/hr.png", "lib/images/sprites.bg.png", "lib/images/sprites.png", "lib/images/vr.png", "lib/jspec.css", "lib/jspec.jquery.js", "lib/jspec.js", "README.rdoc"]
+  s.files = ["bin/jspec", "History.rdoc", "jspec.gemspec", "lib/images/bg.png", "lib/images/hr.png", "lib/images/sprites.bg.png", "lib/images/sprites.png", "lib/images/vr.png", "lib/jspec.css", "lib/jspec.jquery.js", "lib/jspec.js", "Manifest", "Rakefile", "README.rdoc", "spec/async", "spec/jquery-1.3.1.js", "spec/spec.core.dom.js", "spec/spec.core.js", "spec/spec.grammar.js", "spec/spec.html", "spec/spec.jquery.js", "templates/default/History.rdoc", "templates/default/lib/yourlib.core.js", "templates/default/README.rdoc", "templates/default/spec/spec.core.js", "templates/default/spec/spec.html"]
+  s.has_rdoc = true
+  s.homepage = %q{http://visionmedia.github.com/jspec}
+  s.rdoc_options = ["--line-numbers", "--inline-source", "--title", "Jspec", "--main", "README.rdoc"]
+  s.require_paths = ["lib"]
+  s.rubyforge_project = %q{jspec}
+  s.rubygems_version = %q{1.3.1}
+  s.summary = %q{JavaScript BDD Testing Framework}
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 2
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<visionmedia-commander>, [">= 3.2.9"])
+    else
+      s.add_dependency(%q<visionmedia-commander>, [">= 3.2.9"])
+    end
+  else
+    s.add_dependency(%q<visionmedia-commander>, [">= 3.2.9"])
+  end
+end

data/lib/jspec.css

@@ -0,0 +1,129 @@
+body.jspec {
+  margin: 45px 0;
+  text-align: center;
+  font: 12px "Helvetica Neue Light", "Lucida Grande", "Calibri", "Arial", sans-serif;
+  background: #efefef url(images/bg.png) top left repeat-x;
+}
+#jspec {
+  margin: 0 auto;
+  padding-top: 25px;
+  width: 1008px;
+  background: url(images/vr.png) top left repeat-y;
+  text-align: left;
+}
+#jspec-top {
+  position: relative;
+  margin: 0 auto;
+  width: 1008px;
+  height: 40px;
+  background: url(images/sprites.bg.png) top left no-repeat;
+}
+#jspec-bottom {
+  margin: 0 auto;
+  width: 1008px;
+  height: 15px;
+  background: url(images/sprites.bg.png) bottom left no-repeat;
+}
+#jspec-title {
+  position: relative;
+  top: 35px;
+  left: 20px;
+  width: 160px;
+  font-size: 22px;
+  font-weight: normal;
+  background: url(images/sprites.png) 0 -126px no-repeat;
+}
+#jspec-title em {
+  font-size: 10px;
+  font-style: normal;
+  color: #BCC8D1;
+}
+#jspec-report * {
+	margin: 0;
+	padding: 0;
+	background: none;
+	border: none;
+}
+#jspec-report {
+  padding: 15px 40px;
+	font: 11px "Helvetica Neue Light", "Lucida Grande", "Calibri", "Arial", sans-serif;
+	color: #7B8D9B;
+}
+#jspec-report.has-failures {
+  padding-bottom: 30px;
+}
+#jspec-report .hidden {
+  display: none;
+}
+#jspec-report .heading {
+  margin-bottom: 15px;
+}
+#jspec-report .heading span {
+  padding-right: 10px;
+}
+#jspec-report .heading .passes em {
+  color: #0ea0eb;
+}
+#jspec-report .heading .failures em {
+  color: #FA1616;
+}
+#jspec-report table {
+  width: 100%;
+  font-size: 11px;
+  border-collapse: collapse;
+}
+#jspec-report td {
+  padding: 8px;
+  text-indent: 30px;
+  color: #7B8D9B;
+}
+#jspec-report tr td:first-child em {
+  font-style: normal;
+  font-weight: normal;
+  color: #7B8D9B;
+}
+#jspec-report tr:not(.description):hover {
+  text-shadow: 1px 1px 1px #fff;
+  background: #F2F5F7;
+}
+#jspec-report td + td {
+  padding-right: 0;
+  width: 15px;
+}
+#jspec-report td.pass {
+  background: url(images/sprites.png) 3px -7px no-repeat;
+}
+#jspec-report td.fail {
+  background: url(images/sprites.png) 3px -47px no-repeat;
+  font-weight: bold;
+  color: #FC0D0D;
+}
+#jspec-report td.requires-implementation {
+  background: url(images/sprites.png) 3px -87px no-repeat;
+}
+#jspec-report tr.description td {
+  margin-top: 25px;
+  padding-top: 25px;
+  font-size: 12px;
+  font-weight: bold;
+  text-indent: 0;
+  color: #1a1a1a;
+}
+#jspec-report tr.description:first-child td {
+  border-top: none;  
+}
+#jspec-report .assertion {
+  display: block;
+  float: left;
+  margin: 0 0 0 1px;
+  padding: 0;
+  width: 1px;
+  height: 5px;
+  background: #7B8D9B;
+}
+#jspec-report .assertion.failed {
+  background: red;
+}
+.jspec-sandbox {
+  display: none;
+}

data/lib/jspec.jquery.js

@@ -0,0 +1,68 @@
+
+// JSpec - jQuery - Copyright TJ Holowaychuk <tj@vision-media.ca> (MIT Licensed)
+
+(function($, $$){
+
+  // --- Dependencies
+
+  $$.requires('jQuery', 'when using jspec.jquery.js')
+  
+  // --- Async Support
+
+  $.ajaxSetup({ async : false })
+
+  // --- Helpers
+
+  $$.defaultContext.element = $
+  $$.defaultContext.elements = $
+  $$.defaultContext.defaultSandbox = $$.defaultContext.sandbox
+  $$.defaultContext.sandbox = function() { return $($$.defaultContext.defaultSandbox()) }
+
+  // --- Matchers
+
+  $$.addMatchers({
+    have_tag      : "jQuery(expected, actual).length == 1",
+    have_one      : "alias have_tag",
+    have_tags     : "jQuery(expected, actual).length > 1",
+    have_many     : "alias have_tags",
+    have_child    : "jQuery(actual).children(expected).length == 1",
+    have_children : "jQuery(actual).children(expected).length > 1",
+    have_class    : "jQuery(actual).hasClass(expected)",
+    have_text     : "jQuery(actual).text() == expected",
+    have_value    : "jQuery(actual).val() == expected",
+    be_visible    : "!jQuery(actual).is(':hidden')",
+    be_hidden     : "jQuery(actual).is(':hidden')",
+    be_enabled    : "!jQuery(actual).attr('disabled')",
+    
+    have_attr : { match : function(actual, attr, value) {
+        if (value) return $(actual).attr(attr) == value
+        else return $(actual).attr(attr)
+      }
+    }
+  })
+  
+  // --- be_BOOLATTR
+  
+  $$.each('disabled selected checked', function(attr){
+    $$.matchers['be_' + attr] = "jQuery(actual).attr('" + attr + "')"
+  })
+  
+  // --- have_ATTR
+  
+  $$.each('type id title alt href src rel rev name target', function(attr){
+    $$.matchers['have_' + attr] = { match : function(actual, value) {
+        return $$.matchers.have_attr.match(actual, attr, value)
+      }
+    }
+  })
+  
+  // --- be_a_TYPE_input (deprecated)
+  
+  $$.each('checkbox radio file password submit image text reset button', function(type){
+    console.warn("be_a_" + type + "_input is deprected; use have_type('" + type + "')");
+    JSpec.matchers['be_a_' + type + '_input'] = "jQuery(actual).get(0).type == '" + type + "'"
+  })
+  
+})(jQuery, JSpec)
+
+

data/lib/jspec.js

@@ -0,0 +1,912 @@
+
+// JSpec - Core - Copyright TJ Holowaychuk <tj@vision-media.ca> (MIT Licensed)
+
+(function(){
+
+  JSpec = {
+
+    version  : '1.1.1',
+    main     : this,
+    suites   : [],
+    matchers : {},
+    stats    : { specs : 0, assertions : 0, failures : 0, passes : 0 },
+    options  : { profile : false },
+
+    /**
+     * Default context in which bodies are evaluated.
+     * This allows specs and hooks to use the 'this' keyword in
+     * order to store variables, as well as allowing the context
+     * to provide helper methods or properties.
+     *
+     * Replace context simply by setting JSpec.context
+     * to your own like below:
+     *
+     * JSpec.context = { foo : 'bar' }
+     *
+     * Contexts can be changed within any body, this can be useful
+     * in order to provide specific helper methods to specific suites.
+     *
+     * To reset (usually in after hook) simply set to null like below:
+     *
+     * JSpec.context = null
+     */
+
+    defaultContext : {
+      sandbox : function(name) {
+        sandbox = document.createElement('div')
+        sandbox.setAttribute('class', 'jspec-sandbox')
+        document.body.appendChild(sandbox)
+        return sandbox
+      }
+    },
+
+    // --- Objects
+
+    /**
+     * Matcher.
+     *
+     * There are many ways to define a matcher within JSpec. The first being
+     * a string that is less than 4 characters long, which is considered a simple
+     * binary operation between two expressions. For example the matcher '==' simply
+     * evaluates to 'actual == expected'.
+     *
+     * The second way to create a matcher is with a larger string, which is evaluated,
+     * and then returned such as 'actual.match(expected)'.
+     *
+     * You may alias simply by starting a string with 'alias', such as 'be' : 'alias eql'.
+     *
+     * Finally an object may be used, and must contain a 'match' method, which is passed
+     * both the expected, and actual values. Optionally a 'message' method may be used to
+     * specify a custom message. Example:
+     *
+     * match : function(actual, expected) {
+     *   return typeof actual == expected
+     * }
+     *
+     * @param  {string} name
+     * @param  {hash, string} matcher
+     * @param  {object} actual
+     * @param  {array} expected
+     * @param  {bool} negate
+     * @return {Matcher}
+     * @api private
+     */
+
+    Matcher : function (name, matcher, actual, expected, negate) {
+      self = this
+      this.name = name
+      this.message = ''
+      this.passed = false
+      
+      // Define matchers from strings
+
+      if (typeof matcher == 'string') {
+        if (matcher.match(/^alias (\w+)/)) matcher = JSpec.matchers[matcher.match(/^alias (\w+)/)[1]]
+        if (matcher.length < 4) body = 'actual ' + matcher + ' expected'
+        else body = matcher
+        matcher = { match : function(actual, expected) { return eval(body) } }
+      }
+
+      // Generate matcher message
+
+      function generateMessage() {
+         // TODO: clone expected instead of unshifting in this.match()
+        expectedMessage = print.apply(this, expected.slice(1))
+        return 'expected ' + print(actual) + ' to ' + (negate ? ' not ' : '') + name.replace(/_/g, ' ') + ' ' + expectedMessage
+      }
+
+      // Set message to matcher callback invocation or auto-generated message
+
+      function setMessage() {
+        self.message = typeof matcher.message == 'function' ?
+          matcher.message(actual, expected, negate):
+          generateMessage()
+      }
+
+      // Pass the matcher
+
+      function pass() {
+        setMessage()
+        JSpec.stats.passes += 1
+        self.passed = true
+      }
+
+      // Fail the matcher
+
+      function fail() {
+        setMessage()
+        JSpec.stats.failures += 1
+      }
+
+      // Return result of match
+
+      this.match = function() {
+        expected.unshift(actual == null ? null : actual.valueOf())
+        return matcher.match.apply(JSpec, expected)
+      }
+
+      // Boolean match result
+
+      this.passes = function() {
+        this.result = this.match()
+        return negate? !this.result : this.result
+      }
+
+      // Performs match, and passes / fails the matcher
+
+      this.exec = function() {
+        this.passes() ? pass() : fail()
+        return this
+      }
+    },
+
+
+    formatters : {
+
+      /**
+       * Default formatter, outputting to the DOM.
+       *
+       * Options:
+       *   - reportToId    id of element to output reports to, defaults to 'jspec'
+       *   - failuresOnly  displays only suites with failing specs
+       *
+       * @api public
+       */
+
+      DOM : function(results, options) {
+        id = option('reportToId') || 'jspec'
+        report = document.getElementById(id)
+        classes = results.stats.failures ? 'has-failures' : ''
+        if (!report) error('requires the element #' + id + ' to output its reports')
+
+        markup =
+        '<div id="jspec-report" class="' + classes + '"><div class="heading">           \
+        <span class="passes">Passes: <em>' + results.stats.passes + '</em></span>       \
+        <span class="failures">Failures: <em>' + results.stats.failures + '</em></span> \
+        </div><table class="suites">'
+          
+        function renderSuite(suite) {
+          failuresOnly = option('failuresOnly')
+          displaySuite = failuresOnly ? suite.ran && !suite.passed() : suite.ran
+          if (displaySuite && suite.hasSpecs()) {
+            markup += '<tr class="description"><td colspan="2">' + suite.description + '</td></tr>'
+            each(suite.specs, function(i, spec){
+              markup += '<tr class="' + (i % 2 ? 'odd' : 'even') + '">'
+              if (spec.requiresImplementation() && !failuresOnly) {
+                markup += '<td class="requires-implementation" colspan="2">' + spec.description + '</td>'
+              }
+              else if (spec.passed() && !failuresOnly) {
+                markup += '<td class="pass">' + spec.description+ '</td><td>' + spec.assertionsGraph() + '</td>'
+              }
+              else if(!spec.passed()) {
+                markup += '<td class="fail">' + spec.description + ' <em>' + spec.failure().message + '</em>' + '</td><td>' + spec.assertionsGraph() + '</td>'
+              }
+              markup += '<tr class="body" style="display: none;"><td colspan="2">' + spec.body + '</td></tr>'
+            })
+            markup += '</tr>'
+          }
+        }  
+        
+        function renderSuites(suites) {
+          each(suites, function(suite){
+            renderSuite(suite)
+            if (suite.hasSuites()) renderSuites(suite.suites)
+          })
+        }
+        
+        renderSuites(results.suites)
+
+        markup += '</table></div>'
+
+        report.innerHTML = markup
+      },
+
+      /**
+       * Console formatter, tested with Firebug and Safari 4.
+       *
+       * @api public
+       */
+
+      Console : function(results, options) {
+        console.log('')
+        console.log('Passes: ' + results.stats.passes + ' Failures: ' + results.stats.failures)
+        
+        function renderSuite(suite) {
+          if (suite.ran) {
+            console.group(suite.description)
+            results.each(suite.specs, function(spec){
+              assertionCount = spec.assertions.length + ':'
+              if (spec.requiresImplementation())
+                console.warn(spec.description)
+              else if (spec.passed())
+                console.log(assertionCount + ' ' + spec.description)
+              else 
+                console.error(assertionCount + ' ' + spec.description + ', ' + spec.failure().message)
+            })
+            console.groupEnd()
+          }          
+        }
+        
+        function renderSuites(suites) {
+          each(suites, function(suite){
+            renderSuite(suite)
+            if (suite.hasSuites()) renderSuites(suite.suites)
+          })
+        }
+        
+        renderSuites(results.suites)
+      }
+    },
+
+    /**
+     * Specification Suite block object.
+     *
+     * @param {string} description
+     * @param {function} body
+     * @api private
+     */
+
+    Suite : function(description, body) {
+      this.body = body, this.suites = [], this.specs = []
+      this.description = description, this.ran = false
+      this.hooks = { 'before' : [], 'after' : [], 'before_each' : [], 'after_each' : [] }
+
+      // Add a spec to the suite
+
+      this.addSpec = function(description, body) {
+        spec = new JSpec.Spec(description, body)
+        this.specs.push(spec)
+        spec.suite = this
+      }
+      
+      // Add a hook to the suite
+      
+      this.addHook = function(hook, body) {
+        this.hooks[hook].push(body)
+      }
+      
+      // Add a nested suite
+      
+      this.addSuite = function(description, body) {
+        suite = new JSpec.Suite(description, body)
+        suite.description = this.description + ' ' + suite.description
+        this.suites.push(suite)
+        suite.suite = this
+      }
+
+      // Invoke a hook in context to this suite
+
+      this.hook = function(hook) {
+        each(this.hooks[hook], function(body) {
+          JSpec.evalBody(body, "Error in hook '" + hook + "', suite '" + this.description + "': ")
+        })
+      }
+      
+      // Check if nested suites are present
+      
+      this.hasSuites = function() {
+        return this.suites.length  
+      }
+      
+      // Check if this suite has specs
+      
+      this.hasSpecs = function() {
+        return this.specs.length
+      }
+      
+      // Check if the entire suite passed
+
+      this.passed = function() {
+        var passed = true
+        each(this.specs, function(spec){
+          if (!spec.passed()) passed = false
+        })
+        return passed
+      }
+    },
+    
+    /**
+     * Specification block object.
+     *
+     * @param {string} description
+     * @param {function} body
+     * @api private
+     */
+
+    Spec : function(description, body) {
+      this.body = body, this.description = description, this.assertions = []
+
+      // Find first failing assertion
+
+      this.failure = function() {
+        return inject(this.assertions, null, function(failure, assertion){
+          return !assertion.passed && !failure ? assertion : failure
+        })
+      }
+      
+      // Find all failing assertions
+      
+      this.failures = function() {
+        return inject(this.assertions, [], function(failures, assertion){
+          if (!assertion.passed) failures.push(assertion)
+          return failures
+        })
+      }
+
+      // Weither or not the spec passed
+
+      this.passed = function() {
+        return !this.failure()
+      }
+
+      // Weither or not the spec requires implementation (no assertions)
+
+      this.requiresImplementation = function() {
+        return this.assertions.length == 0
+      }
+      
+      // Sprite based assertions graph
+      
+      this.assertionsGraph = function() {
+        return map(this.assertions, function(assertion){
+          return '<span class="assertion ' + (assertion.passed ? 'passed' : 'failed') + '"></span>'
+        }).join('')
+      }
+    },
+
+    // --- Methods
+    
+    /**
+     * Get option value. This method first checks if
+     * the option key has been set via the query string,
+     * otherwise returning the options hash value.
+     *
+     * @param  {string} key
+     * @return {mixed}
+     * @api public
+     */
+     
+     option : function(key) {
+       if ((value = query(key)) !== null) return value
+       else return JSpec.options[key] || null
+     },
+
+    /**
+     * Generates a hash of the object passed.
+     *
+     * @param  {object} object
+     * @return {string}
+     * @api private
+     */
+
+    hash : function(object) {
+      serialize = function(prefix) {
+        return inject(object, prefix + ':', function(buffer, key, value){
+          return buffer += hash(value)
+        })
+      }
+      switch (object.constructor) {
+        case Array:  return serialize('a')
+        case Object: return serialize('o')
+        case RegExp: return 'r:' + object.toString()
+        case Number: return 'n:' + object.toString()
+        case String: return 's:' + object.toString()
+        default: return object.toString()
+      }
+    },
+
+    /**
+     * Return last element of an array.
+     *
+     * @param  {array} array
+     * @return {object}
+     * @api public
+     */
+
+    last : function(array) {
+      return array[array.length - 1]
+    },
+
+    /**
+     * Convert object(s) to a print-friend string.
+     *
+     * @param  {object, ...} object
+     * @return {string}
+     * @api public
+     */
+
+    print : function(object) {
+      if (arguments.length > 1) {
+        list = []
+        for (i = 0; i < arguments.length; i++) list.push(print(arguments[i]))
+        return list.join(', ')
+      }
+      if (object === undefined) return ''
+      if (object === null) return 'null'
+      if (object === true) return 'true'
+      if (object === false) return 'false'
+      if (object.jquery && object.selector.length > 0) return 'selector ' + print(object.selector) + ''
+      if (object.jquery) return escape(object.html())
+      if (object.nodeName) return escape(object.outerHTML)
+      switch (object.constructor) {
+        case String: return "'" + escape(object) + "'"
+        case Number: return object
+        case Array :
+          buff = '['
+          each(object, function(v){ buff += ', ' + print(v) })
+          return buff.replace('[,', '[') + ' ]'
+        case Object:
+          buff = '{'
+          each(object, function(k, v){ buff += ', ' + print(k) + ' : ' + print(v)})
+          return buff.replace('{,', '{') + ' }'
+        default: 
+          return escape(object.toString())
+      }
+    },
+
+    /**
+     * Escape HTML.
+     *
+     * @param  {string} html
+     * @return {string}
+     * @api public
+     */
+
+     escape : function(html) {
+       if (typeof html != 'string') return html
+       return html.
+         replace(/&/gmi, '&amp;').
+         replace(/"/gmi, '&quot;').
+         replace(/>/gmi, '&gt;').
+         replace(/</gmi, '&lt;')
+     },
+
+    /**
+     * Invoke a matcher.
+     *
+     * this.match('test', 'should', 'be_a', [String])
+     *
+     * @param  {object} actual
+     * @param  {bool, string} negate
+     * @param  {string} name
+     * @param  {array} expected
+     * @return {bool}
+     * @api private
+     */
+
+    match : function(actual, negate, name, expected) {
+      if (typeof negate == 'string') negate = negate == 'should' ? false : true
+      matcher = new this.Matcher(name, this.matchers[name], actual, expected, negate)
+      this.currentSpec.assertions.push(matcher.exec())
+      return matcher.result
+    },
+
+    /**
+     * Iterate an object, invoking the given callback.
+     *
+     * @param  {hash, array, string} object
+     * @param  {function} callback
+     * @return {JSpec}
+     * @api public
+     */
+
+    each : function(object, callback) {
+      if (typeof object == 'string') object = object.split(' ')
+      for (key in object) {
+        if (object.hasOwnProperty(key))
+          callback.length == 1 ?
+            callback.call(JSpec, object[key]):
+            callback.call(JSpec, key, object[key])
+      }
+      return JSpec
+    },
+
+    /**
+     * Iterate with memo.
+     *
+     * @param  {hash, array} object
+     * @param  {object} initial
+     * @param  {function} callback
+     * @return {object}
+     * @api public
+     */
+
+    inject : function(object, initial, callback) {
+      each(object, function(key, value){
+        initial = callback.length == 2 ?
+          callback.call(JSpec, initial, value):
+          callback.call(JSpec, initial, key, value) || initial
+      })
+      return initial
+    },
+    
+    /**
+     * Strim whitespace or chars.
+     *
+     * @param  {string} string
+     * @param  {string} chars
+     * @return {string}
+     * @api public
+     */
+
+     strip : function(string, chars) {
+       return string.
+         replace(new RegExp('['  + (chars || '\\s') + ']*$'), '').
+         replace(new RegExp('^[' + (chars || '\\s') + ']*'),  '')
+     },
+    
+    /**
+     * Map callback return values.
+     *
+     * @param  {hash, array} object
+     * @param  {function} callback
+     * @return {array}
+     * @api public
+     */
+
+    map : function(object, callback) {
+      return inject(object, [], function(memo, key, value){
+        memo.push(callback.length == 1 ?
+          callback.call(JSpec, value):
+          callback.call(JSpec, key, value))
+      })
+    },
+    
+    /**
+     * Returns true if the callback returns true at least once.
+     *
+     * @param  {hash, array} object
+     * @param  {function} callback
+     * @return {bool}
+     * @api public
+     */
+         
+    any : function(object, callback) {
+      return inject(object, false, function(state, key, value){
+        if (state) return true
+        return callback.length == 1 ?
+          callback.call(JSpec, value):
+          callback.call(JSpec, key, value)
+      })
+    },
+
+    /**
+     * Define matchers.
+     *
+     * @param  {hash} matchers
+     * @return {JSpec}
+     * @api public
+     */
+
+    addMatchers : function(matchers) {
+      each(matchers, function(name, body){ this.matchers[name] = body })
+      return this
+    },
+    
+    /**
+     * Add a root suite to JSpec.
+     *
+     * @param  {string} description
+     * @param  {body} function
+     * @return {JSpec}
+     * @api public
+     */
+    
+    addSuite : function(description, body) {
+      this.suites.push(new JSpec.Suite(description, body))
+      return this
+    },
+
+    /**
+     * Evaluate a JSpec capture body.
+     *
+     * @param  {function} body
+     * @param  {string} errorMessage (optional)
+     * @return {Type}
+     * @api private
+     */
+
+    evalBody : function(body, errorMessage) {
+      try { body.call(this.context || this.defaultContext) }
+      catch(e) { error(errorMessage, e) }
+    },
+
+    /**
+     * Pre-process a string of JSpec.
+     *
+     * @param  {string} input
+     * @return {string}
+     * @api private
+     */
+
+    preprocess : function(input) {
+      return input.
+        replace(/describe (.*?)$/m, 'JSpec.addSuite($1, function(){').
+        replace(/describe (.*?)$/gm, 'this.addSuite($1, function(){').
+        replace(/it (.*?)$/gm, 'this.addSpec($1, function(){').
+        replace(/^(?: *)(before_each|after_each|before|after)(?= |\n|$)/gm, 'this.addHook("$1", function(){').
+        replace(/end(?= |\n|$)/gm, '});').
+        replace(/-{/g, 'function(){').
+        replace(/(\d+)\.\.(\d+)/g, function(_, a, b){ return range(a, b) }).
+        replace(/([\s\(]+)\./gm, '$1this.').
+        replace(/\.should([_\.]not)?[_\.](\w+)(?: |$)(.*)$/gm, '.should$1_$2($3)').
+        replace(/(.+?)\.(should(?:[_\.]not)?)[_\.](\w+)\((.*)\)$/gm, 'JSpec.match($1, "$2", "$3", [$4]);')
+    },
+
+    /**
+     * Create a range string which can be evaluated to a native array.
+     *
+     * @param  {int} start
+     * @param  {int} end
+     * @return {string}
+     * @api public
+     */
+
+    range : function(start, end) {
+      current = parseInt(start), end = parseInt(end), values = [current]
+      if (end > current) while (++current <= end) values.push(current)
+      else               while (--current >= end) values.push(current)
+      return '[' + values + ']'
+    },
+
+    /**
+     * Report on the results. 
+     *
+     * @return {JSpec}
+     * @api public
+     */
+
+    report : function() {
+      this.options.formatter ? 
+        new this.options.formatter(this, this.options):
+        new this.formatters.DOM(this, this.options)
+      return this
+    },
+
+    /**
+     * Run the spec suites.
+     *
+     * @return {JSpec}
+     * @api public
+     */
+
+    run : function() {
+      if (option('profile')) console.group('Profile')
+      each(this.suites, function(suite) { this.runSuite(suite) })
+      if (option('profile')) console.groupEnd()
+      return this
+    },
+
+    /**
+     * Run a suite.
+     *
+     * @param  {Suite} suite
+     * @return {JSpec}
+     * @api public
+     */
+
+    runSuite : function(suite) {
+      suite.body()
+      suite.ran = true
+      suite.hook('before')
+      each(suite.specs, function(spec) {
+        suite.hook('before_each')
+        this.runSpec(spec)
+        suite.hook('after_each')
+      })
+      suite.hook('after')
+      if (suite.hasSuites()) {
+        each(suite.suites, function(suite) {
+          this.runSuite(suite)
+        })
+      }
+      return this
+    },
+
+    /**
+     * Run a spec.
+     *
+     * @param  {Spec} spec
+     * @api public
+     */
+
+    runSpec : function(spec) {
+      this.currentSpec = spec
+      this.stats.specs++
+      if (option('profile')) console.time(spec.description)
+      this.evalBody(spec.body, "Error in spec '" + spec.description + "': ")
+      if (option('profile')) console.timeEnd(spec.description)
+      this.stats.assertions += spec.assertions.length
+    },
+
+    /**
+     * Require a dependency, with optional message.
+     *
+     * @param  {string} dependency
+     * @param  {string} message (optional)
+     * @api public
+     */
+
+    requires : function(dependency, message) {
+      try { eval(dependency) }
+      catch (e) { error('depends on ' + dependency + ' ' + (message || '')) }
+    },
+
+    /**
+     * Query against the current query strings keys
+     * or the queryString specified.
+     *
+     * @param  {string} key
+     * @param  {string} queryString
+     * @return {string, null}
+     * @api public
+     */
+
+    query : function(key, queryString) {
+      queryString = (queryString || window.location.search || '').substring(1)
+      return inject(queryString.split('&'), null, function(value, pair){
+        parts = pair.split('=')
+        return  parts[0] == key ? parts[1].replace(/%20|\+/gmi, ' ') : value
+      })
+    },
+
+    /**
+     * Throw a JSpec related error.
+     *
+     * @param {string} message
+     * @param {Exception} e
+     * @api public
+     */
+
+    error : function(message, e) {
+      throw 'jspec: ' + message + (e ? e.message : '') + ' near line ' + e.line
+    },
+
+    /**
+     * Load a files contents.
+     *
+     * @param  {string} file
+     * @return {string}
+     * @api public
+     */
+
+    load : function(file) {
+      if ('XMLHttpRequest' in this.main) {
+        request = new XMLHttpRequest
+        request.open('GET', file, false)
+        request.send(null)
+        if (request.readyState == 4) return request.responseText
+      }
+      else if ('load' in this.main) {
+        // TODO: workaround for IO issue / preprocessing
+        load(file)
+      }
+      else {
+        error('cannot load ' + file)
+      }
+    },
+
+    /**
+     * Load, pre-process, and evaluate a file.
+     *
+     * @param {string} file
+     * @param {JSpec}
+     * @api public
+     */
+
+    exec : function(file) {
+      eval(this.preprocess(this.load(file)))
+      return this
+    }
+  }
+
+  // --- Utility functions
+
+  map    = JSpec.map
+  any    = JSpec.any
+  last   = JSpec.last
+  range  = JSpec.range
+  each   = JSpec.each
+  option = JSpec.option
+  inject = JSpec.inject
+  error  = JSpec.error
+  escape = JSpec.escape
+  print  = JSpec.print
+  hash   = JSpec.hash
+  query  = JSpec.query
+  strip  = JSpec.strip
+  addMatchers = JSpec.addMatchers
+
+  // --- Matchers
+
+  addMatchers({
+    be                 : "alias eql",
+    equal              : "===",
+    be_greater_than    : ">",
+    be_less_than       : "<",
+    be_at_least        : ">=",
+    be_at_most         : "<=",
+    be_a               : "actual.constructor == expected",
+    be_an              : "alias be_a",
+    be_null            : "actual == null",
+    be_empty           : "actual.length == 0",
+    be_true            : "actual == true",
+    be_false           : "actual == false",
+    be_type            : "typeof actual == expected",
+    match              : "typeof actual == 'string' ? actual.match(expected) : false",
+    respond_to         : "typeof actual[expected] == 'function'",
+    have_length        : "actual.length == expected",
+    be_within          : "actual >= expected[0] && actual <= last(expected)",
+    have_length_within : "actual.length >= expected[0] && actual.length <= last(expected)",
+
+    eql : { match : function(actual, expected) {
+      if (actual.constructor == Array || actual.constructor == Object) return hash(actual) == hash(expected)
+      else return actual == expected
+    }},
+
+    include : { match : function(actual) {
+      for (state = true, i = 1; i < arguments.length; i++) {
+        arg = arguments[i]
+        switch (actual.constructor) {
+          case String: 
+          case Number:
+          case RegExp:
+          case Function:
+            state = actual.toString().match(arg.toString())
+            break
+         
+          case Object:
+            state = arg in actual
+            break
+          
+          case Array: 
+            state = any(actual, function(value){ return hash(value) == hash(arg) })
+            break
+        }
+        if (!state) return false
+      }
+      return true
+    }},
+
+    throw_error : { match : function(actual, expected) {
+      try { actual() }
+      catch (e) {
+        if (expected == undefined) return true 
+        else return expected.constructor == RegExp ?
+          expected.test(e) : e.toString() == expected
+      }
+    }},
+    
+    have : { match : function(actual, length, property) {
+      return actual[property].length == length
+    }},
+    
+    have_at_least : { match : function(actual, length, property) {
+      return actual[property].length >= length
+    }},
+    
+    have_at_most : { match : function(actual, length, property) {
+      return actual[property].length <= length
+    }},
+    
+    have_within : { match : function(actual, range, property) {
+      length = actual[property].length
+      return length >= range.shift() && length <= range.pop()
+    }},
+    
+    have_prop : { match : function(actual, property, value) {
+      if (actual[property] == null || typeof actual[property] == 'function') return false
+      return value == null ? true : JSpec.matchers['eql'].match(actual[property], value)
+    }},
+    
+    have_property : { match : function(actual, property, value) {
+      if (actual[property] == null || typeof actual[property] == 'function') return false
+      return value == null ? true : value === actual[property]
+    }}
+  })
+
+  // --- Expose
+  
+  this.JSpec = JSpec
+
+})();