raus22-jspec 2.0.4

data/History.rdoc

@@ -0,0 +1,323 @@
+
+=== 2.0.3 / 2009-05-15
+
+* Table should span full width
+  (Very week release I know, but improperly styled things bug me :) )
+
+=== 2.0.2 / 2009-05-11
+
+* Added rails integration link http://github.com/bhauman/jspec-rails
+* Changed; puts() now displays constructor name when available
+* Fixed Terminal output which was not displaying due to a recent commit
+* fixed IE bug : DOM elements don't have valueOf() method
+
+=== 2.0.1 / 2009-05-01
+
+* Added better failure messages for throw_error matcher
+* Renamed print() to puts() [#108]
+
+=== 2.0.0 / 2009-04-27
+
+* Added DOM loading indicator [#105]
+* Added wait() helper for additional async support
+* Added shared behavior support using should_behave_like('Another Suite')
+* Added CSS body toggling [#1]
+* Added receive matcher for Proxy Assertins
+* Added grammar-less support
+* Added an_instance_of() helper
+* Removed .this literal
+* Removed deprecated be_a_TYPE_input matchers
+
+* Added ProxyAssertion 
+* Added select() util
+* Added does() util for report-less assertions
+* Added find() util 
+* Added JSpec.contentsOf()
+* Added matchers to body evaluation [#90]
+
+=== 1.1.7 / 2009-04-22
+
+* Removed trailing commas causing issues with IE (what a suprise ;) )
+
+=== 1.1.6 / 2009-04-22
+
+* Fixed typo in requires()
+* Added expect()
+
+=== 1.1.5 / 2009-04-17
+
+* Strengthened specs for cascading hooks
+* Fixed cascading hooks
+
+=== 1.1.4 / 2009-04-17
+
+* Added rhino and server template files
+* Added JSpec.hasXhr()
+* Added JSpec.xhr()
+* Added Ruby javascript testing server
+* Added support for options passed to run()
+* Added failuresOnly for Terminal formatter
+* Added terminal assertion graphs
+* Addec color() utility
+* Added main.puts() since we use print() as a utility
+* Added rhino support
+* Added fail() utility function
+* Added JSpec.Assertion
+* Added normalizeMatcherMessage()
+* Added normalizeMatcherBody()
+* Added have_classes [#19]
+* Added extend() utility
+* Added be_an_instance_of matcher
+* Added constructor checking support for throw_error matcher [#72]
+* Added file support for exception messages, making them much easier to debug
+* Added catching of exceptions throw within specs [#46]
+* Changed; executable aborts when template does not exist
+* Changed; matchers now normalized upon creation, accepts function, hash, or string.
+* Changed be() matcher to be strict [#57]
+* Changed error() to conditionally show line number when available
+* Renamed Jspec.addSuite to JSpec.describe and Suite#addSpec to Suite#it
+* Refactored be_a_TYPE_input matchers so that the deprication warning is logged only when calling the method
+* Fixed JSpec.requires() now works with latest version of JSpec.error()
+* Fixed error() now displays exceptions throw that do not respond to .message
+* Fixed commenting bug [#37]
+* Removed JSpec.main, now just using local main
+
+=== 1.1.3 / 2009-04-14
+
+* Removed /test used for the executable, causing gem to fail building
+
+=== 1.1.2 / 2009-04-14
+
+* Added `jspec update` sub-command [#63]
+
+=== 1.1.1 / 2009-04-12
+
+* Added gemspec
+
+=== 1.1.0 / 2009-04-12
+
+* jspec executable fully functional
+
+=== 1.0.4 / 2009-04-09
+
+* Added `jspec bind`
+* Added `jspec run`
+* Added `jspec init`
+* Added `jspec` executable
+* Added gemspec and manifest
+* Added command-line usage docs
+* Added custom matchers documentation
+* Removed double negation
+
+=== 1.0.3 / 2009-04-08
+
+* Added have_prop matcher, have_property is now strict [#56]
+
+=== 1.0.2 / 2009-04-08
+
+* Added be_selected, be_checked matchers
+* Added string support to each() each('some foo bar', ...)
+* Added have_ATTR matchers [#51]
+* Deprected be_a_TYPE_input matchers [#50]
+
+=== 1.0.1 / 2009-04-07
+
+* Added have_property matcher [#53]
+
+=== 1.0.0 / 2009-04-06
+
+* Added option() which gives the query string option precedence [#39]
+* Changed; Using JSpec.options.formatter not JSpec.formatter [#44]
+* Fixed Console formatter, now displays nested suites
+* Check out http://visionmedia.github.com/jspec for additional documentation!
+
+=== 0.9.6 / 2009-04-03
+
+* Added nesting support
+* Added printing of nested specs
+* Added assertion graphs to DOM formatter
+* Refactored preprocess()
+* Refactored most of the specs
+* Renamed preProcess() to preprocess()
+* Removed running of a single suite via ?suite= for now
+
+=== 0.9.5 / 2009-04-02
+
+* Added support for printing of function bodies and regexps [#27]
+* Added support for strings / regexp with should_throw_error [#26]
+* Added have_within matcher
+* Added have_at_most matcher
+* Added have_at_least matcher
+* Added have matcher [#24]
+
+=== 0.9.4 / 2009-04-02
+
+* Added be_a_TYPE_input matchers (be_a_checkbox_input, be_a_text_input, etc)
+* Added be_disabled matcher [#21]
+* Added be_enabled matcher [#20]
+* Refactored be_visible and be_hidden with $(elem).is()
+
+=== 0.9.2 / 2009-04-02
+
+* Added support for multi-arg failure messages [#2]
+* Better printing of jQuery objects [#15]
+
+=== 0.9.1 / 2009-04-02
+
+* Added support for dotted negation of assertions (foo.should.not.equal bar)
+* Added support for dot-style assertions [#17] (foo.should_not.equal bar)
+
+=== 0.9.0 / 2009-04-01
+
+* Added spec for strip()
+* Added strip()
+* Added any() util
+* Added new improved include matcher
+* Added have_many and have_one matchers
+* Added have_attr matcher [#14]
+* Added map() util
+* Added inject() util
+* Added escape() util
+* Added recursive array and object printing
+* Added DOM formatter option failuresOnly
+* Added support for running of a single squite via ?suite=...
+* Added query() util
+* Added last() util
+* Added be_within matcher, accepts a range literal
+* Added inclusive range literal n..n
+* Added row hover
+* Refactored range()
+* Refactored setMessage()
+* Refactored hash()
+* Changed; preprocessor passing array of args (multi-arg matcher support)
+* Changed jQuery to $ for internal usage
+
+=== 0.8.0 / 2009-02-27
+
+* Added a new style for the DOM formatter (not finished yet)
+
+=== 0.7.0 / 2009-02-27
+
+* Added Console formatter (anything implementing the console object. Firebug, Safari 4, etc)
+* Added JSpec.options.profile for optional profiling of specs
+* Added this. literal alternative (view readme)
+* Moved formatters into JSpec.formatters 
+* Added error() util
+* Added savings raketask
+* Fixed parse error bug in Safari 4
+
+=== 0.6.3 / 2009-02-26
+
+* Added minification for jspec.jquery.js when packaging before release
+* Added compression of css when packaging before release
+
+=== 0.6.2 / 2009-02-26
+
+* Changed; using $ in jspec.jquery.js for JSpec, take that jQuery ;)
+* Added addMatchers, print, hash, and each as 'utility functions' this allows 
+  JSpec to do each(...) internally instead of JSpec.each(...), while still preventing
+  pollution of the global scope.
+
+=== 0.6.1 / 2009-02-26
+
+* Added closrue literal -{ (view README)
+* Added option to DOM formatter, now allows you to specify which element id to output to
+
+=== 0.6.0 / 2009-02-24
+
+* Added JSpec.hash 
+* Added be_null matcher
+* Allow recursive composite matching using should_eql and should_not_eql
+  For example [1, 2, [3]].should_eql([1, 2, [3]]) is true, works with object
+  'hashes' as well.
+
+=== 0.5.1 / 2009-02-24
+
+* Damn auto-release messed up
+
+=== 0.5.0 / 2009-02-24
+
+* Added async support for jQuery
+* Added JSpec.requires for dependencies
+* Added JSpec.throw
+* Added JSpec.runSpec
+* Refactored jspec.jquery.js
+* Fixed evalBody exceptions, previously was not showing exception message
+* Fixed bug of JSpec interpreting // in a string such as http:// to be a comment.
+
+=== 0.4.1 / 2009-02-22
+
+* Added elements() alias of element()
+* Added support for string passed to runSuite; runSuite('Matchers') is the same as
+  runSuite(JSpec.suites['Matchers']).
+* Fixed some documentation
+
+=== 0.4.0 / 2009-02-20
+
+* Added comment literal (//)
+* Added pre-processor for convering matchers.
+  For example 'test'.should_be_true becomes JSpec.match('test', 'should_be', 'true'),
+  preventing pollution of core prototypes.
+
+=== 0.3.2 / 2009-02-19
+
+* Added TM bundle (go checkout my jspec.tmbundle repo on github)
+* Renamed have_length_of to have_length
+
+=== 0.3.1 / 2009-02-19
+
+* Added jquery js to package
+
+=== 0.3.0 / 2009-02-19
+
+* Added JSpec.match
+* Added options to report() which are passed to formatter
+* Added sandbox helpers (reg / jquery)
+* Added have_child and have_children
+* Added have_tag and have_tags
+* Changed exec to only load / eval file
+* Fixed parser token issue, was previously matching things like end() as literal end
+
+=== 0.2.3 / 2009-02-18
+
+* Changed test dir to spec
+* Changed test.js to core.spec.js
+
+=== 0.2.2 / 2009-02-18
+
+* Added contexts
+
+=== 0.2.0 / 2009-02-18
+
+* Added release rake task
+* Added package with minified alternative
+
+=== 0.1.0 / 2009-02-18
+
+* Added new sexy syntax (warning: you will have to re-write your specs)
+* Added pre-processor for optional matcher parens 
+* Added several new matchers 
+* Added matcher aliasing 
+* Added simple matcher declarations 
+* Added __END__ 
+* Added yet-to-be-implemented specs 
+* Added loading of suites via JSpec.load
+
+=== 0.0.4 / 2008-11-03
+
+* Added ability to pass only a description to it(), meaning not yet implemented
+
+=== 0.0.3 / 2008-10-28
+
+* Added should_fail
+* Added should_match
+* Added should_not_match
+* Added should_be and should_not_be
+
+=== 0.0.2 / 2008-10-28
+
+* Fixed typo in documentation for pointing to the master repo
+
+=== 0.0.1 / 2008-10-28
+
+* Initial release

data/Manifest

@@ -0,0 +1,44 @@
+bin/jspec
+History.rdoc
+jspec.gemspec
+lib/images/bg.png
+lib/images/hr.png
+lib/images/loading.gif
+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
+server/browsers.rb
+server/server.rb
+spec/async
+spec/jquery-1.3.1.js
+spec/server.html
+spec/spec.grammar-less.js
+spec/spec.grammar.js
+spec/spec.html
+spec/spec.jquery.js
+spec/spec.js
+spec/spec.matchers.js
+spec/spec.rhino.js
+spec/spec.shared-behaviors.js
+spec/spec.utils.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
+templates/rhino/History.rdoc
+templates/rhino/lib/yourlib.core.js
+templates/rhino/README.rdoc
+templates/rhino/spec/spec.core.js
+templates/rhino/spec/spec.js
+templates/server/History.rdoc
+templates/server/lib/yourlib.core.js
+templates/server/README.rdoc
+templates/server/spec/spec.core.js
+templates/server/spec/spec.html

data/README.rdoc

@@ -0,0 +1,495 @@
+
+= JSpec
+
+JSpec is a minimalistic JavaScript behavior driven development framework,
+providing simple installation, extremely low learning curve, absolutely no pollution
+to core prototypes, async request support, and incredibly sexy syntax, tons of matchers
+and much more.
+
+== Features
+
+* Highly readable
+* Framework / DOM independent
+* Rhino support
+* Async support
+* Ruby JavaScript testing server
+* Nested describes
+* Does not pollute core object prototypes
+* Cascading before/after/before_each/after_each hooks
+* Extremely simple and intuitive matcher declaration
+* Over 45 core matchers
+* Allows parens to be optional when using matchers to increase readability
+* Several helpful formatters (DOM, Console, Terminal, ...)
+* Assertion graphs displaying how many, and which assertions pass or failed
+* Default / customizable evaluation contexts
+* DOM sandbox support
+* Great looking default DOM theme
+* `jspec` command-line utility for auto-running specs, and initializing project templates
+* Proxy or 'Spy' assertions 
+* Shared behaviors
+* Profiling
+* Rails Integration (http://github.com/bhauman/jspec-rails)
+* Tiny (15 kb compressed, 1600-ish LOC)
+
+== Installation
+
+Simply download JSpec and include JSpec.css and JSpec.js in your markup.
+Head over to the downloads section on Github, clone this public repo, or 
+add JSpec as a git submodule with in your project. Alternatively JSpec is
+also available as a Ruby Gem (though this is not required), which also 
+provides the `jspec` executable. To install as a gem simply:
+  $ sudo gem install visionmedia-jspec
+
+At which point you may:
+  $ jspec init myproject
+
+JSpec scripts should NOT be referenced via the <script> tag, they should be
+loaded using the exec method (unless you are using the grammar-less alternative).
+Below is an example:
+
+  ...
+  <script>
+    function runSuites() {
+      JSpec
+      .exec('spec.core.js')
+      .exec('spec.jquery.js')
+      .run({ failuresOnly : true })
+      .report()
+    }
+  </script>
+  <body onLoad="runSuites()">
+  ...
+
+You may optionally want to use sources in the /pkg directory
+for your project, since it includes compressed alternatives generated
+each release.
+
+== Example
+
+  describe 'ShoppingCart'
+    before_each
+      cart = new ShoppingCart
+    end
+    
+    describe 'addProducts'
+      it 'should add several products'
+        cart.addProduct('cookie')
+        cart.addProduct('icecream')
+        cart.should.have 2, 'products'
+      end
+    end
+  
+    describe 'checkout'
+      it 'should throw an error when checking out with no products'
+        -{ cart.clear().checkout() }.should.throw_error EmptyCart
+      end
+    end
+  end
+
+== Grammar-less Example
+
+JSpec's grammar is optional, you may also use the equivalent grammar-less
+alternative below using pure JavaScript (when using the JSpec grammar you
+may also use grammar-less assertions):
+
+  JSpec.describe('ShoppingCart', function(){
+    before_each(function{
+      cart = new ShoppingCart
+    })
+
+    describe('addProducts', function(){
+      it ('should add several products', function(){
+        cart.addProducts('cookie')
+        cart.addProducts('icecream')
+        expect(cart).to(have, 2, 'products')
+      })
+    })
+
+    describe('checkout', function(){
+      it ('should throw an error when checking out with no products', function(){
+        expect(function(){ cart.clear().checkout() }).to(throw_error, EmptyCart)
+      })
+    })
+  }) 
+
+== Options
+
+You may alter the way JSpec operates by assigning options via the
+JSpec.options hash, by passing string-based option values via the 
+query string, or passing a hash to run(). For example 
+JSpec.options.failuresOnly = true, and ?failuresOnly=1 will both work.
+
+* profile {bool} when enabled, uses console.time() in order to display performance information in your console log as specs are completed. (DOM, Console)
+* failuresOnly {bool} displays only failing specs, making them quick to discover and fix (DOM, Terminal)
+* reportToId {string} an element id to report to when using the DOM formatter (DOM)
+  
+== Matchers
+
+  * Core
+  
+  - equal, be          ===
+  - be_a, be_an        have constructor of x
+  - be_an_instance_of  instanceof x
+  - be_at_least        >=
+  - be_at_most         <=
+  - be_null            == null
+  - be_empty           length of 0
+  - be_true            == true
+  - be_false           == false
+  - be_type            be type of x
+  - be_greater_than    >
+  - be_less_than       <
+  - throw_error        should throw an error, optionally supply the error string for comparison
+  - have               object should have n of property (person.should.have(2, 'pets'))
+  - have_at_least      object should have at least n of property
+  - have_at_most       object should have a maximum n of property
+  - have_within        object should have within n..n of property (person.should.have_within(1..3, 'pets')
+  - have_length        length of n
+  - have_prop          object should have property x, optionally supplying an expected value
+  - have_property      strict version of have_prop
+  - be_within          checks if n is within the range passed
+  - include            include substring, array element, or hash key
+  - match              string should match regexp x
+  - respond_to         property x should be a function
+  - eql                matches simple literals (strings, numbers) with == 
+                       However composites like arrays or 'hashes' are recursively matched,
+                       meaning that [1, 2, [3]].should_eql([1, 2, [3]]) will be true.
+  
+  * jQuery
+  
+  - have_tag, have_one    have exactly one tag   
+  - have_tags, have_many  have more than one tag
+  - have_child            have exactly one child
+  - have_children         have more than one child
+  - have_text             have plain text
+  - have_attr             have an attribute, with optional value
+  - have_type
+  - have_id
+  - have_title
+  - have_alt
+  - have_href
+  - have_rel
+  - have_rev
+  - have_name
+  - have_target
+  - have_value     
+  - have_class
+  - have_classes
+  - be_visible
+  - be_hidden
+  - be_enabled
+  - be_disabled
+  - be_selected
+  - be_checked
+
+== Proxy Assertions
+
+Proxy or 'Spy' assertions allow you to assert that a method is called n number
+of times, with x arguments, returning x value. For example:
+
+  person = { getPets : function(species){ return ['izzy'] }}
+  person.should.receive('getPets', 'twice').with_args(an_instance_of(String))and_return(['izzy'])
+  person.getPets('dog') // This will pass
+  person.getPets()      // This will fail because we asked an instance of String
+
+This is a useful mechanism for testing the behavior of your object, as well as
+how other methods may interact with it. Below is another example:
+
+  array = ['foo', 'bar']
+  array.should.receive('toString').and_return('foo,bar')
+  'array: ' + array // This line causes the spec to pass due to calling toString()
+
+For more examples view spec/spec.matchers.js
+
+== Helpers
+
+  * Core
+
+  - wait             delay execution of a spec for the duration set (async support)
+  - an_instance_of   used in conjunction with the 'receive' matcher
+                
+  * jQuery      
+                
+  - sandbox     used to generate new DOM sandbox, using jQuery object
+  - element     same as invoking jQuery, just reads better and no need to worry about $ collisions
+  - elements    alias of element
+
+== Shared Behaviors
+
+JSpec's support for shared behaviors allows multiple suites or describe blocks to share
+common functionality. For example an Admin, would inherit all specs of User:
+
+  describe 'User'
+    before
+      User = function(name) { this.name = name }
+      user = new User('joe')
+    end
+    
+    it 'should have a name'
+      user.should.have_property 'name'
+    end
+    
+    describe 'Administrator'
+      should_behave_like('User')
+  
+      before
+        Admin = function(name) { this.name = name }
+        Admin.prototype.may = function(perm){ return true }
+        user = new Admin('tj')
+      end
+  
+      it 'should have access to all permissions'
+        user.may('edit pages').should.be_true
+      end
+    end
+  end
+
+NOTE: both User and Administrator's before hooks implement the 'user' variable
+
+== Async Support Using wait()
+
+When using jQuery with JSpec all requests are switched to sync, allowing specs
+to run naturally, however when testing functionality using setTimeout, setInterval etc
+JSpec supplies the wait() utility to delay a spec from running:
+
+  it 'should wait for n milliseconds'
+    wait(2, 'seconds')
+    setTimeout(function(){
+      true.should.be true
+    }, 1500)
+  end
+
+== Hooks
+
+Currently the following hooks are supported, and may be utilized any number of times as they
+are simply pushed to a stack. So for instance you may have two before_each blocks within the same
+scope, they will both run, but this can help keep your specs readable.
+
+  * before       run once before the suite is executed
+  * after        run once after the suite is executed
+  * before_each  run before each specification
+  * after_each   run after each specification
+
+== Custom Contexts
+
+Custom contexts can be applied to supply helper
+methods or properties to all subsequent bodies (other hooks, or specs).
+
+Keep in mind that when replacing the default context you will loose 
+functionality provided by it, unless you manually merge it with your 
+custom context.
+
+To reset the context simply assign null to obtain the original context.
+
+  ...
+  before
+    JSpec.context = { foo : 'bar' }
+  end
+
+  after
+    JSpec.context = null
+  end
+
+  it 'will work ;)'
+    foo.should_equal 'bar'
+  end
+  ...
+
+== Async Support
+
+Currently only jspec.jquery.js supports async requests. JSpec uses jQuery.ajaxSetup and sets all
+requests to sync, which preserves execution order, and reports correctly.
+
+  it 'should load mah cookies (textfile)'
+    $.post('async', function(text){
+      text.should_eql 'cookies!'
+    })
+  end
+
+== Pre-processor
+
+The pre-processing capability of JSpec is extremely powerful. Your JavaScript
+code is not necessarily what it seems. For example when you seemingly invoke a
+object's prototype like below:
+
+  'foobar'.should.include 'bar'
+
+First parens are added:
+
+  'foobar'.should.include('bar')
+
+Secondly the matcher invocation is converted to a non-polluting match() call:
+
+  JSpec.match('foobar', 'should', 'include', 'bar')
+
+This also means instead of:
+
+  var object = { foo : 'bar' }
+  object.should.include 'foo'
+
+We can do:
+ 
+  { foo : 'bar' }.should.include 'foo'
+
+=== Closure Literal
+
+These are equivalent:
+
+  -{ throw 'test' }.should.throw_error
+  function() { throw 'test' }.should.throw_error
+
+=== Inclusive Range Literal
+
+The following expands to the array of [1,2,3,4,5]
+
+  n.should.be_within 1..5
+
+== Formatters
+
+To change a formatter simply alter the options hash like below, assigning
+a new constructor, or pass it within the hash to run():
+
+  JSpec.options.formatter = JSpec.formatters.Console
+
+OR
+
+	JSpec
+	.exec('...')
+	.run({ formatter : JSpec.formatters.Terminal })
+	.report()
+
+== Custom Matchers
+
+First lets create a simple equality matcher. In the case below JSpec is smart enough to realize
+this is simply a binary operator, and simply transforms this into 'actual === expected'
+
+  JSpec.addMatchers({
+    equal : '==='
+  })
+
+To alias a method to keep your specs readable you may alias them like below:
+
+  JSpec.addMatchers({
+    be : 'alias equal'
+  })
+
+  'foo'.should.equal 'foo'
+  true.should.be true
+
+Matchers with string bodies implicitly return the expression value.
+The expanded version of the equal matcher would then be:
+
+  JSpec.addMatchers({
+    equal : 'actual === expected'
+  })
+
+Large matchers or those which require several parameters may wish
+to utilize the hash method:
+
+  JSpec.addMatchers({
+    equal : { match : function(actual, expected){
+      return actual === expected
+    }}  
+  })
+
+To keep JSpec tiny, JSpec will default to generating failure messages
+for you, how ever this can be explicitly defined:
+
+  JSpec.addMatchers({
+    equal : { 
+      match : function(actual, expected){
+        return actual === expected
+      },
+      message : function(actual, expected, negate) {
+        return 'a message here'
+      }
+    }
+  })
+
+== JSpec Command-line Utility
+
+When installed as a Ruby Gem, the `jspec` executable will become available,
+allowing you to initialize project templates quickly, as well as auto-testing
+specifications when a file is altered.
+
+Initialize JSpec-driven project template in directory 'myproject':
+  $ jspec init myproject
+
+Once within 'myproject' start testing by executing:
+  $ jspec
+
+For additional usage execute:
+  $ jspec help
+
+Or for specific usage:
+  $ jspec help run
+
+== Rhino
+
+JSpec provides transparent support for Rhino, while using the Terminal formatter.
+Simply create a JavaScript file with contents similar to below, and then execute
+the command following it:
+
+  load('lib/jspec.js')
+  
+  JSpec
+  .exec('spec/spec.grammar.js')
+  .exec('spec/spec.core.js')
+  .run({ formatter : JSpec.formatters.Terminal, failuresOnly : true })
+  .report()
+
+Initialize project with:
+  $ jspec init myproject --template rhino
+
+Run with:
+  $ jspec run --rhino
+
+Or bind (automated testing):
+  $ jspec --rhino 
+
+== Server
+
+The Ruby JavaScript testing server included with JSpec simply runs
+the spec suites within each browser you specify, while reporting result
+back to the terminal. It is essentially the same as using the DOM formatter
+and auto-testing each browser, however results are centralized to the terminal,
+removing the need to manually view each browser's output.
+
+Initialize project with:
+  $ jspec init myproject --template server
+
+Run with:
+  $ jspec run --server
+
+== More Information
+
+* Syntax comparison with other frameworks http://gist.github.com/92283
+* Get the TextMate bundle at https://github.com/visionmedia/jspec.tmbundle/tree
+* For more information consult the JSpec source code documentation or visit http://visionmedia.github.com/jspec
+
+== License 
+
+(The MIT License)
+
+Copyright (c) 2008 - 2009 TJ Holowaychuk <tj@vision-media.ca>
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+