RubyGems - jspec - Versions diffs - 2.11.13 → 3.0.0 - Mend

jspec 2.11.13 → 3.0.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (77) hide show

data/History.md +714 -0
data/Manifest +51 -36
data/README.md +968 -0
data/Rakefile +4 -53
data/bin/jspec +93 -224
data/jspec.gemspec +5 -5
data/lib/images/sprites.png +0 -0
data/lib/jspec.css +2 -2
data/lib/jspec.growl.js +115 -0
data/lib/jspec.jquery.js +1 -1
data/lib/jspec.js +98 -101
data/lib/jspec.shell.js +5 -2
data/lib/jspec.timers.js +1 -1
data/lib/jspec.xhr.js +12 -2
data/spec/commands/example_command.rb +19 -0
data/spec/dom.html +33 -0
data/spec/node.js +32 -0
data/spec/rhino.js +24 -0
data/spec/ruby/bin/init_spec.rb +101 -0
data/spec/ruby/bin/install_spec.rb +141 -0
data/spec/ruby/bin/run_spec.rb +0 -0
data/spec/ruby/bin/shell_spec.rb +13 -0
data/spec/ruby/bin/spec_helper.rb +25 -0
data/spec/ruby/bin/update_spec.rb +72 -0
data/spec/server.html +29 -0
data/spec/server.rb +1 -1
data/spec/{env.js → support/env.js} +554 -664
data/spec/support/jquery.js +4376 -0
data/spec/{helpers.js → unit/helpers.js} +2 -0
data/spec/{spec.fixtures.js → unit/spec.fixtures.js} +0 -1
data/spec/{spec.grammar-less.js → unit/spec.grammar-less.js} +0 -0
data/spec/{spec.grammar.js → unit/spec.grammar.js} +1 -11
data/spec/{spec.jquery.js → unit/spec.jquery.js} +0 -17
data/spec/{spec.jquery.xhr.js → unit/spec.jquery.xhr.js} +13 -2
data/spec/unit/spec.js +187 -0
data/spec/{spec.matchers.js → unit/spec.matchers.js} +141 -66
data/spec/{spec.modules.js → unit/spec.modules.js} +0 -0
data/spec/{spec.shared-behaviors.js → unit/spec.shared-behaviors.js} +0 -0
data/spec/{spec.utils.js → unit/spec.utils.js} +123 -22
data/spec/{spec.xhr.js → unit/spec.xhr.js} +11 -10
data/{server → src}/browsers.rb +23 -0
data/{server → src}/helpers.rb +2 -17
data/src/installables.rb +229 -0
data/src/project.rb +340 -0
data/{server → src}/routes.rb +1 -1
data/{server → src}/server.rb +0 -0
data/support/js.jar +0 -0
data/templates/default/History.md +5 -0
data/templates/default/{README.rdoc → Readme.md} +3 -3
data/templates/default/lib/{yourlib.core.js → yourlib.js} +0 -0
data/templates/default/spec/commands/example_command.rb +19 -0
data/templates/default/spec/{spec.dom.html → dom.html} +5 -3
data/templates/default/spec/rhino.js +10 -0
data/templates/default/spec/server.html +18 -0
data/templates/default/spec/unit/spec.helper.js +0 -0
data/templates/default/spec/{spec.core.js → unit/spec.js} +0 -0
data/templates/rails/commands/example_commands.rb +19 -0
data/templates/rails/{spec.dom.html → dom.html} +4 -2
data/templates/rails/rhino.js +10 -0
data/templates/rails/server.html +18 -0
data/templates/rails/unit/spec.helper.js +0 -0
data/templates/rails/{spec.application.js → unit/spec.js} +0 -0
metadata +56 -41
data/History.rdoc +0 -590
data/README.rdoc +0 -842
data/spec/async +0 -1
data/spec/jquery.js +0 -19
data/spec/spec.dom.html +0 -34
data/spec/spec.js +0 -166
data/spec/spec.node.js +0 -46
data/spec/spec.rhino.js +0 -23
data/spec/spec.server.html +0 -29
data/templates/default/History.rdoc +0 -4
data/templates/default/spec/spec.rhino.js +0 -8
data/templates/default/spec/spec.server.html +0 -16
data/templates/rails/spec.rhino.js +0 -8
data/templates/rails/spec.server.html +0 -16

data/README.rdoc DELETED Viewed

@@ -1,842 +0,0 @@
-= 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
-* Modular via JSpec Module's and hooks
-* Mock Ajax Requests
-* Rhino support
-* Env.js support
-* Async support
-* Fixture 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
-* Method Stubbing
-* Shared behaviors
-* Profiling
-* Interactive Shell
-* Ruby on Rails Integration
-* Tiny (15 kb compressed, 1300-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. First install [Gemcutter](http://gemcutter.org/) then execute:
-  $ sudo gem install jspec
-At which point you may:
-  $ jspec init myproject
-By default, the command above will use absolute path for all JSpec library files.
-This behavior can be a problem when you're working across different computers or
-operating systems. You can freeze the library or symlink it.
-  $ jspec init myproject --freeze
-  $ jspec init myproject --symlink
-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.
-== Cheat Sheet
-Using the bash cheat sheet library found at http://github.com/visionmedia/ch
-we can get quick cheat sheets for many aspects of development including JSpec!
-  $ cd /tmp && git clone git://github.com/visionmedia/ch.git && cd ch && sudo make install && ch jspec
-== 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, Server)
-* reportToId   {string} an element id to report to when using the DOM formatter (DOM)
-* verbose      {bool} verbose server output, defaults to false (Server)
-== 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 < 0 or {}
-  - be_true            == true
-  - be_false           == false
-  - be_type            be type of x
-  - be_greater_than    >
-  - be_less_than       <
-  - be_undefined       check if variable passed is undefined
-  - throw_error        should throw an error, optionally supply the error string or regexp for message 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
-== Async Support With Mock Timers
-The javascript mock timers library is available at http://github.com/visionmedia/js-mock-timers
-although it is already bundled with JSpec at lib/jspec.timers.js
-Timers return ids and may be passed to clearInterval(), however
-they do not execute in threads, they must be manually scheduled and
-controlled via the tick() function.
-  setTimeout(function(){
-    alert('Wahoo!')
-  }, 400)
-  tick(200) // Nothing happens
-  tick(400) // Wahoo!
-setInterval() works as expected, although it persists, where as setTimeout()
-is destroyed after a single call. As conveyed by the last tick() call below,
-a large increment in milliseconds may cause the callbacks to be called several times
-to 'catch up'.
-  progress = ''
-  var id = setInterval(function(){
-    progress += '.'
-  }, 100)
-  tick(50),  print(progress) // ''
-  tick(50),  print(progress) // '.'
-  tick(100), print(progress) // '..'
-  tick(100), print(progress) // '...'
-  tick(300), print(progress) // '......'
-  clearInterval(id)
-  tick(800) // Nothing happens
-You may also reset at any time using resetTimers()
-== 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
-== Method Stubbing
-JSpec currently provides very simple stubbing support shown below:
-  person = { toString : function(){ return '<Person>' } }
-  stub(person, 'toString').and_return('Ive been stubbed!')
-After each spec all stubs are restored to their original methods so
-there is no reason to explicitly call destub(). To persist stubs,
-use a before_each hook:
-  before_each
-    stub(someObject, 'method').and_return({ some : thing })
-  end
-To destub a method simply call destub() at any time:
-  destub(person, 'toString')
-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
-  * Core
-  - an_instance_of                 used in conjunction with the 'receive' matcher
-  - mockRequest, mock_request      mock a request (requires jspec.xhr.js)
-  - unmockRequest, unmock_request  unmock requests (requests jspec.xhr.js)
-  * 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
-== Mock Ajax Requests
-JSpec supports generic Ajax mocking which is usable with any JavaScript framework via 'jspec.xhr.js'. The
-API is comprised of two functions, mockRequest() and unmockRequest(). unmockRequest() is
-automatically called after each specification to restore the default functionality of XMLHttpRequest,
-so it is uncommon to call unmockRequest() directly. Below is a jQuery example:
-  it 'should mock requests'
-    mockRequest().and_return('{ foo : "bar" }', 'application/json')
-    $.getJSON('foo', function(response, statusText){
-      response.foo.should.eql 'bar'
-    })
-  end
-The mockRequest().and_return signature is as follows:
-  mockRequest().and_return(<data>, [content-type], [response-status-code], [headers-hash])
-At the moment mockRequest() itself does not accept any arguments, however in the future
-this will be used to target specific uris for mocking.
-NOTE: works with Rhino as well
-== 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
-=== __END__
-Any text placed after __END__ is considered irrelevant and
-is striped out before evaluation. This is sometimes useful for
-document or code reference while writing specs.
-For example when writting regression specs it is sometimes useful
-to paste the issue ticket's comment(s) below this area for reference.
-== 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()
-== Fixtures
-The fixture() utility function may be used in order to load arbitrary file contents
-for use with your specifications. JSpec will resolve fixture('data') in the following
-manor:
-  - 'data'
-  - 'spec/data'
-  - 'spec/fixtures/data'
-  - 'spec/fixtures/data.html'
-So if the file 'spec/fixtures/data.html' exists, we can simply use fixture('data'),
-where as 'spec/fixtures/xml/data.xml' must be specified with fixture('xml/data.xml').
-If you prefer not to store fixtures in the 'fixtures' directory you must be more specific
-with the path supplied.
-== Testing DOM Elements
-When using jQuery testing DOM elements is very easy. Many may think they require specific
-sandbox divs in their html, however you do not. Using the fixture support mentioned above
-you may simply load some HTML, and use the 'elements()' utility which is an alias of jQuery:
-  describe 'JSpec DOM testing'
-    describe 'is so easy'
-      before_each
-        list = elements(fixture('users-list'))
-        // or list = jQuery(fixture('users-list'))
-        // or list = $(fixture('users-list'))
-      end
-      it 'should have users'
-        list.should.have_tag 'ul'
-      end
-    end
-  end
-You may also use simple strings, since jQuery's constructor will convert them to DOM elements:
-  describe 'Something'
-    before_each
-      html = elements('<p>Foo</p>')
-      // or html = $('<p>Foo</p>') ...
-    end
-    it 'should do something'
-      html.should.have_text 'Foo'
-    end
-  end
-== 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'
-      }
-    }
-  })
-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:
-  - name       : module name string
-  - init       : called to initialize a module
-  - formatters : hash of formatters merged with JSpec.formatters
-  - utilities  : hash of utility functions merged with JSpec.defaultContext
-  - matchers   : hash of matchers merged with JSpec's core matchers via JSpec.addMatchers()
-  - DSLs       : hash of DSL methods; for example DSLs.snake contains before_each, after_each, etc.
-                 Where as DSLs.camel may contain beforeEach, afterEach, etc.
-Below is a list of hooks, descriptions, and valid return values which
-may simply be implemented as module methods. beforeSuite, afterSuite, beforeSpec, and afterSpec have lower
-precedence than before_each, after_each etc within the specs themselves, allowing them to override or undo
-anything that has been done by a Module.
-  - 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
-  - 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 (describe block)         : (no return value)
-  - afterSuite(suite)                : after running of suite  (describe block)         : (no return value)
-  - beforeSpec(spec)                 : before running of spec  (it block)               : (no return value)
-  - afterSpec(spec)                  : after running of spec   (it block)               : (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,
-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
-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.
-When utilizing the server if a file named spec/jspec.rb (or jspec/jspec.rb for rails)
-is present, then it will be loaded before the server is started. This allows you to
-add Sinatra routes, support additional Browsers, etc.
-Run with all supported browsers:
-  $ jspec run --server
-Run with specific browsers:
-  $ jspec run --browsers Safari,Firefox,Chrome,Explorer
-Run with alternative browser names:
-  $ jspec run --browsers safari,ff,chrome,ie
-Browsers supported in core:
-  Browser::Safari
-  Browser::Chrome
-  Browser::Opera
-  Browser::Firefox
-  Browser::IE
-Supplied routes:
-  /slow/NUMBER
-  /status/NUMBER
-For example $.get('/slow/4', function(){}) will take 4 seconds
-to reply, where as $.get('/status/404', function(){}) will respond
-with an 404 status code. Add additional Sinatra routes to the jspec.rb
-file to add your own functionality.
-== Interactive Shell
-JSpec provides an interactive shell through Rhino, utilize with:
-$ jspec shell
-Or to specify additional files to load:
-$ jspec shell lib/*.js
-Or view additional shell help
-$ jspec help shell
-== Ruby on Rails
-No additional gems are required for JSpec to work with rails, although
-http://github.com/bhauman/jspec-rails has been created by 'bhauman'. JSpec
-supports Rails out of the box, simply execute:
-  $ jspec init --rails
-Then while still in the root directory of your Rails project, run the following
-command which will bind to, and refresh your browsers automatically when any changes
-are made to ./public/javascripts/*.js or ./jspec/*.js
-  $ jspec
-Or just like regular JSpec applications, run once:
-  $ jspec run
-Or run via the terminal using Rhino:
-  $ jspec run --rhino
-== Support Browsers
-Browsers below are supported and can be found in server/browsers.rb, however
-your spec/server.rb file may support additional browsers.
-* Safari
-* Chrome
-* Firefox
-* Opera
-* Internet Explorer
-== Known Issues
-* The preprocessor is not (yet) capable of multiline conversions. For example the following is invalid
-  object.stub('getContentsOfURL').and_return(function(url){
-    return 'html'
-  })
-  In cases such as this, you may always revert to utilizing JSpec in a grammar-less form as follows:
-  stub(object, 'getContentsOfURL').and_return(function(url){
-    return 'html'
-  })
-== Additional JSpec Modules
-* JSocka stubbing http://github.com/gisikw/jsocka/tree/master
-== More Information
-* Google Group http://groups.google.com/group/jspec
-* IRC Channel irc://irc.freenode.net#jspec
-* Featured article in JSMag: http://www.jsmag.com/main.issues.description/id=21/
-* 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
-* jQuery + HTML fixture example http://gist.github.com/147831
-* Follow 'tjholowaychuk' on twitter
-== Contributors
-Many ideas and bug reports were contributed by
-the following developers, thankyou for making
-JSpec more enjoyable, and bug free ;)
-* Lawrence Pit
-* mpd@jesters-court.ne
-* Sarah Brown
-* kevin.gisi@gmail.com
-* tony_t_tubbs@yahoo.com
-* enno84@gmx.net
-* fnando
-* Tobias Svensson
-== 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.