teabag 0.4.2 → 0.4.3

data/README.md

@@ -9,9 +9,7 @@ Ok, another test runner, right? Really? Yeah, that's a tough one, but we're pret
 
 The intention is to be the simplest but most complete Javascript testing solution for Rails, taking full advantage of the asset pipeline. It ships with support for Jasmine, Mocha and QUnit, and has custom reporters for each.
 
-We've just released Teabag, and we expect to be working on it for a while to get a glossy shine to everything, so check it out and let us know what you think. Feedback, ideas and pull requests would be awesome.
-
-[Follow @modeset_ on twitter](https://twitter.com/modeset_)
+Feedback, ideas and pull requests are always welcome, or you can hit us up [@modeset_](https://twitter.com/modeset_).
 
 
 ## Screenshots
@@ -32,16 +30,16 @@ We've just released Teabag, and we expect to be working on it for a while to get
 2. [Quickstart](#quickstart)
 3. [Usage](#usage)
 4. [Writing Specs](#writing-specs)
-5. [Suites](#suites)
-6. [Configuration](#configuration)
-7. [Test Frameworks](#test-frameworks)
-8. [Support Libraries](#support-libraries)
-9. [CI Support](#ci-support)
-10. [Roadmap](#roadmap)
+5. [Fixtures](#fixtures)
+6. [Suites](#suites)
+7. [Configuration](#configuration)
+8. [Test Frameworks](#test-frameworks)
+9. [Support Libraries](#support-libraries)
+10. [CI Support](#ci-support)
 
 ## Installation
 
-Add it to your Gemfile. In almost all cases you'll want to restrict it to the `:asset`, or `:development, :test` groups.
+Add it to your Gemfile. In most cases you'll want to restrict it to the `:asset`, or `:development, :test` groups.
 
 ```ruby
 group :assets do
@@ -49,7 +47,7 @@ group :assets do
 end
 ```
 
-Optionally run the install generator to get the initializer and a basic spec helper if you want them.
+Optionally run the install generator to get the initializer and a basic spec helper.
 
 ```
 rails generate teabag:install
@@ -67,19 +65,17 @@ rails generate teabag:install
 
 The install generator will create a `spec/javascripts` directory for you. Teabag will automatically pick up any specs written in that folder named `[classname]_spec.(js|coffee|js.coffee)`.
 
-Let's write a basic class and spec in CoffeeScript using Jasmine (though you could just as easily use vanilla Javascript). Create `spec/javascripts/calculator_spec.coffee` and put this in it:
+Let's write a basic implementation in CoffeeScript using Jasmine (you could just as easily use vanilla Javascript). Create a `spec/javascripts/calculator_spec.coffee` and put this in it:
 
 ```coffeescript
 #= require calculator
+describe "Calculator", ->
 
-describe 'Calculator', ->
-
-  it 'should add two digits', ->
-    calc = new Calculator()
-    expect( calc.add(2,2) ).toBe(4)
+  it "should add two digits", ->
+    expect( new Calculator().add(2,2) ).toBe(4)
 ```
 
-Create `app/assets/javascripts/calculator.coffee` and put this in it:
+Now let's create an `app/assets/javascripts/calculator.coffee` and add:
 
 ```coffeescript
 class @Calculator
@@ -94,23 +90,23 @@ Failures:
      Failure/Error: TypeError: 'undefined' is not a function
 ```
 
-Now we just need make the test pass. Let's implement the `add` method on Calculator.
+To make the test pass we just need to implement the `add` method.
 
 ```coffeescript
   add: (a, b) ->
     a + b
 ```
 
-Run `rake teabag` again - that spec should now be passing!
+`rake teabag` again and that spec should be passing!
 
 If you'd prefer, you can also run your tests in the browser. Fire up your Rails server and visit [localhost:3000/teabag](http://localhost:3000/teabag) to run the specs in whichever browser you want.
 
 
 ## Usage
 
-Teabag uses the Rails asset pipeline to serve files which means you're free to use things like CoffeeScript. This simplifies the fixtures as well and lets you do some pretty awesome things like use builder, hamlc, rabl, etc. to generate your views.
+Teabag uses the Rails asset pipeline to serve files. This simplifies the fixtures as well and lets you use things like HAML or RABL/JBuilder to generate your fixtures.
 
-If you want a more visual experience you can browse to the specs in the browser, or you can use the rake task to run them headless on the command line with PhantomJS. Works great with CI, too!
+If you want a more visual experience you can browse to the specs in the browser, or you can use the rake task to run them headlessly with PhantomJS or with Selenium WebDriver.
 
 ### Browser
 
@@ -136,23 +132,15 @@ Specify the suite with the rake task by using:
 rake teabag suite=my_fantastic_suite
 ```
 
-When a failure is encountered, a URL will be generated so you can pop open a browser and load a focused run to examine that specific failure.
-
-You can override a few configurations by using environment variables. `FAILS_FALSE=[true/false]`, `SUPPRESS_LOGS=[false/true]` and `FORMATTERS=tap_y`. You can read more about these configuration directives below.
+You can override a few configurations by using environment variables. `FAILS_FALSE=[true/false]`, `SUPPRESS_LOGS=[false/true]` and `FORMATTERS=tap_y` (read more about [configuration](#configuration) below.)
 
-Teabag has support for [tapout](https://github.com/rubyworks/tapout). You can use the tap_y formatter and pipe the results to tapout to use any of the reporters that tapout provides.
+Teabag also has support for [tapout](https://github.com/rubyworks/tapout). Use the tap_y formatter and pipe the results to tapout to use any of the reporters that tapout provides.
 
 ```
 rake teabag SUPPRESS_LOG=true FORMATTERS=tap_y | tapout progress
 ```
 
-**Note:** By default the rake task runs within the development environment, but you can specify the environment using`RAILS_ENV=test rake teabag`. This is an asset compilation optimization, and to keep consistent with what you might see in the browser (since that's likely running in development).
-
-**Note:** We usually like to include our Javascript specs into the default rake task, like so:
-
-```ruby
-task :default => [:spec, :teabag, :cucumber]
-```
+**Note:** By default the rake task runs within the development environment, but you can specify the environment using `RAILS_ENV=test rake teabag`. This is an asset compilation optimization, and to keep consistent with what you might see in the browser (since that's likely running in development).
 
 
 ## Writing Specs
@@ -175,11 +163,11 @@ describe("My great feature", function() {
 });
 ```
 
-Check out an example of a [Mocha Spec](https://github.com/modeset/teabag/wiki/Using-Mocha) and a [QUnit Test](https://github.com/modeset/teabag/wiki/Using-QUnit).
+Check out examples of a [Mocha Spec](https://github.com/modeset/teabag/wiki/Using-Mocha) and a [QUnit Test](https://github.com/modeset/teabag/wiki/Using-QUnit).
 
 ### Pending Specs
 
-We've normalized declaring that a spec is pending between the two libraries. Since Jasmine lacks the concept we've added it in, and since Mocha has several ways to accomplish it we thought it would be worth mentioning what we consider the standard between the two to be.
+We've normalized declaring that a spec is pending between Mocha and Jasmine. Since Jasmine lacks the concept we've added it in, and since Mocha has several ways to accomplish it we thought it would be worth mentioning what we consider the standard between the two to be.
 
 To mark a spec as pending you can either not provide a function as the second argument to `it`, or you can use `xit` and `xdescribe`.  Mocha provides some additional ways to accomplish this, but to keep it consistent we've normalized on what they both support.
 
@@ -197,47 +185,75 @@ describe "My great feature", ->
       expect(true).to.be(false)
 ```
 
-If you're using one library and you want to take advantage of the things that that library provides you're completely free to do so, and this is provided as a suggestion. The Teabag reporters understand the techniques above and have specs for them. QUnit doesn't support specifying a test as pending.
+If you're using a specific framework and you want to take advantage of the things that that framerowk provides you're free to do so, and this is provided as a recommended standard. The Teabag reporters understand the techniques above and have specs for them. QUnit doesn't support specifying a test as pending.
+
+### Deferring Execution
+
+Teabag allows deferring execution in the cases when you're using AMD or other asynchronous libraries. This is especially useful if you're using [CommonJS](http://www.commonjs.org/) or [RequireJS](http://requirejs.org/), etc.  You can tell Teabag to defer and then execute the runner yourself later -- after loading asychronously.
+
+```coffeescript
+Teabag.defer = true
+setTimeout(Teabag.execute, 1000) # defers execution for 1 second
+```
+
 
-### Fixtures
+## Fixtures
 
-Teabag fixtures are using jasmine-jquery for now.
+You're free to use your own fixture library (like jasmine-jquery, which we've included as a support library), but Teabag ships with a fixture library that works with Mocha, Jasmine, and QUnit with a minimum of effort and a nice API.
 
-If jasmine-jquery isn't your thing, you can also load your fixtures manually into the "#teabag-fixtures" element.
+The fixture path is configurable within Teabag, and the views will be rendered by a standard controller.  This allows you to use things like RABL/JBuilder if you're building JSON, or HAML if you're building markup.  The element that Teabag creates is "#teabag-fixtures", in case you need to access it directly.
 
-The fixture path is configurable, and the views will be rendered by a controller.  This allows you to use things like rabl if you're building JSON, or haml if you're building markup.
 
-To load fixtures in your specs you'll need to include jasmine-jquery -- and then use the `loadFixtures` method.
+### Loading Files
 
-```coffeescript
-#= require jquery
-#= require support/jasmine-jquery
-describe "fixtures", ->
+Loading fixtures allows you to specify any number of files to load, and if they should be appended to the fixture element, or replace what's currently there.
 
-  it "loads fixtures", ->
-    loadFixtures("fixture.html")
-    expect($("#fixture_view")).toExist()
-```
+`fixture.load(url[, url, ...], append = false)` or `fixture(url[, url, ...], append = false)`
 
-### Deferring Execution
+### Setting Manually
 
-Teabag has the concept of deferring execution in the cases when you're using AMD or other asynchronous libraries. This is especially useful if you're using [CommonJS](http://www.commonjs.org/) or [RequireJS](http://requirejs.org/), etc.
+If you don't want to load files directly from the server you can provide strings instead of files, otherwise functions exactly like `fixture.load`.
 
-You can tell Teabag to defer and then execute the runner later -- after loading asychronously.
+`fixture.set(html[, html, ...], append = false)`
+
+### Cleaning Up
+
+You shouldn't have to cleanup (we do that for you based on your test framework), but if you need it.
+
+`fixture.cleanup()`
+
+### Preloading Files
+
+Some test cases require stubbing Ajax requests, and in those cases you may want to preload the fixture files -- this caches them for later.  You can preload fixtures in your spec helper, or before you start mocking Ajax methods.
+
+`fixture.preload(url[, url, ...])`
+
+### Example Usage
 
 ```coffeescript
-Teabag.defer = true
-setTimeout(Teabag.execute, 1000) # defers execution for 1 second
+fixture.preload("fixture.html", "fixture.json") # make the actual requests for the files
+describe "Using fixtures", ->
+
+  fixture.set("<h2>Another Title</h2>") # create some markup manually (will be in a beforeEach)
+
+  beforeEach ->
+    @fixtures = fixture.load("fixture.html", "fixture.json", true) # append these fixtures which were already cached
+
+  it "loads fixtures", ->
+    expect($("h1", fixture.el).text()).toBe("Title") # using fixture.el as a jquery scope
+    expect($("h2", fixture.el).text()).toBe("Another Title")
+    expect(@fixtures[0]).toBe(fixture.el) # the element is available as a return value and through fixture.el
+    expect(@fixtures[1]).toEqual(fixture.json[0]) # the json for json fixtures is returned, and available in fixture.json
 ```
 
+Check out an example of using fixtures with [Mocha](https://github.com/modeset/teabag/wiki/Using-Mocha) and [QUnit](https://github.com/modeset/teabag/wiki/Using-QUnit).
 
-## Suites
 
-Teabag uses the concept of suites to group your tests at a high level. These suites are run in isolation from one another, and can have different configurations.
+## Suites
 
-You can define suites in the configuration, and for brevity `config` is the argument passed to the `Teabag.setup` block.
+Teabag uses the concept of suites to group your tests at a high level. These suites are run in isolation from one another, and can have different configurations. You can define suites in the configuration, and for brevity `config` is the argument passed to the `Teabag.setup` block.
 
-When creating a suite definition you simply pass it a name and a block. The following example defines a suite named "my_suite". You can focus to just this suite by browsing to `/teabag/my_suite` or running the rake task with `suite=my_suite`.
+When creating a suite provide a name (optional) and a block. The following example defines a suite named "my_suite". You can focus to just this suite by browsing to `/teabag/my_suite` or running the rake task with `suite=my_suite`.
 
 ```ruby
 config.suite :my_suite do |suite|
@@ -245,7 +261,7 @@ config.suite :my_suite do |suite|
 end
 ```
 
-There's always a "default" suite defined, and you can modify this suite if you don't specify a name, or use `:default`. In this example we're just adjusting the default suite configuration.
+There's always a "default" suite defined, and to modify this suite just don't specify a name, or use `:default`. In this example we're setting the default suite configuration.
 
 ```ruby
 config.suite do |suite|
@@ -253,18 +269,18 @@ config.suite do |suite|
 end
 ```
 
-It's worth noting that suites don't inherit from the default suite values, but instead always fall back to the defaults outlined below.
+**Note:** Suites don't inherit from the default suite, but instead always fall back to the defaults outlined below.
 
 ### Manifest Style
 
-Teabag is happy to look for files for you, but you can disable this feature and maintain a manifest yourself.  Since each suite can utilize a different spec helper, you can use these to create your own manifest of specs using the `= require` directive.
+Teabag is happy to look for files for you, but you can disable this feature and maintain a manifest yourself.  Each suite can utilize a different spec helper and you can use these to create your own manifest using the `= require` directive.
 
 Tell the suite that you don't want it to match any files, and then require files in your spec helper.
 
 ```ruby
 config.suite do |suite|
   suite.matcher = nil
-  suite.helper = "my_spec_manifest"
+  suite.helper = "spec_manifest"
 end
 ```
 
@@ -272,29 +288,27 @@ end
 
 #### `matcher`
 
-You can specify a file matcher for your specs, and the matching files will be automatically loaded when the suite is run. It's important that these files are serve-able from sprockets (aka the asset pipeline), and you'll receive an exception if they aren't.
+You can specify a file matcher and all matching files will be loaded when the suite is run. It's important that these files are serve-able from sprockets.
 
-**Note:** Set this to `nil` if you want to use your helper as a manifest.
+**Note:** Can also be set to `nil`.
 
 **default:** `"{spec/javascripts,app/assets}/**/*_spec.{js,js.coffee,coffee}"`
 
 
 #### `helper`
 
-Each suite can load a different spec helper, which can in turn require additional files. This file is loaded before your specs are loaded -- so you can use this as a manifest if you set the matcher to nil.
+Each suite can load a different spec helper, which can in turn require additional files. This file is loaded before your specs are loaded, and can be used as a manifest.
 
 **default:** `"spec_helper"`
 
 #### `javascripts`
 
-These are the core Teabag javascripts. Spec files should not go here -- but if you want to add additional support for jasmine matchers, switch to mocha, include expectation libraries etc., this is a good place to do that.
+These are the core Teabag javascripts. It's strongly encouraged to include only the base files here. You can require other support libraries in your spec helper, which allows you to change them without having to restart the server.
 
 Available frameworks: teabag-jasmine, teabag-mocha, teabag-qunit
 
 **Note:** To use the CoffeeScript source files use `"teabag/jasmine"` etc.
 
-**Note:** It's strongly encouraged to include only the base files in the `javascripts` directive. You can require other support libraries in your spec helper, which makes them easier to change (you don't have to restart the server.)
-
 **default:** `["teabag-jasmine"]`
 
 #### `stylesheets`
@@ -308,41 +322,41 @@ If you want to change how Teabag looks, or include your own stylesheets you can
 
 The best way to read about the configuration options is to generate the initializer, but we've included the info here too.
 
-**Note:** `Teabag.setup` may not be available in all environments, so keep that in mind. The generator provides a check wrapped around Teabag.setup.
+**Note:** `Teabag.setup` may not be available in all environments. The generator provides a check wrapped around Teabag.setup.
 
 #### `mount_at`
 
-This determines where the Teabag spec path will be mounted. Changing this to "/jasmine" would allow you to browse to `http://localhost:3000/jasmine` to run your specs.
+This determines where the Teabag routes will be mounted. Changing this to "/jasmine" would allow you to browse to http://localhost:3000/jasmine to run your specs.
 
 **default:** `"/teabag"`
 
 #### `root`
 
-The root path defaults to Rails.root if left nil, but if you're testing an engine using a dummy application it's useful to be able to set this to your engines root.. E.g. `Teabag::Engine.root`
+This defaults to Rails.root if left nil. If you're testing an engine using a dummy application it can be useful to set this to your engines root.. E.g. `Teabag::Engine.root`
 
 **default:** `nil`
 
 #### `asset_paths`
 
-These paths are appended to the rails assets paths (relative to config.root), and by default is an array that you can replace or add to.
+These paths are appended to the Rails assets paths (relative to config.root), and by default is an array that you can replace or add to.
 
 **default:** `["spec/javascripts", "spec/javascripts/stylesheets", "test/javascripts", "test/javascripts/stylesheets"]`
 
 #### `fixture_path`
 
-Fixtures are different than the specs, in that Rails is rendering them directly through a controller. This means you can use haml, erb builder, rabl, etc. to render content in the views available in this path.
+Fixtures are rendered through a standard controller. This means you can use things like HAML or RABL/JBuilder, etc. to generate fixtures within this path.
 
 **default:** `"spec/javascripts/fixtures"`
 
 #### `server_timeout`
 
-Timeout for starting the server in seconds. If your server is slow to start you may have to bump the timeout, or you may want to lower this if you know it shouldn't take long to start.
+Timeout for starting the server in seconds. If your server is slow to start you may have to bump this, or you may want to lower this if you know it shouldn't take long to start.
 
 **default:** `20`
 
 #### `driver`
 
-Allows you to specify which driver you want to run your specs with -- Supports [PhantomJS](http://phantomjs.org/) and [Selenium Webdriver](http://seleniumhq.org/docs/03_webdriver.jsp). For more information about using Selenium WebDriver check this [wiki article](https://github.com/modeset/teabag/wiki/Using-Selenium-WebDriver), or in case you're having trouble with [PhantomJS on Linux](https://github.com/modeset/teabag/wiki/PhantomJS-on-Linux).
+Allows you to specify which driver you want to run your specs with -- Supports [PhantomJS](http://phantomjs.org/) and [Selenium Webdriver](http://seleniumhq.org/docs/03_webdriver.jsp). Check the wiki for more information about [Using Selenium WebDriver](https://github.com/modeset/teabag/wiki/Using-Selenium-WebDriver), and this one if you're having issues with [PhantomJS on Linux](https://github.com/modeset/teabag/wiki/PhantomJS-on-Linux).
 
 Supported drivers: phantomjs, selenium
 
@@ -352,27 +366,27 @@ Supported drivers: phantomjs, selenium
 
 #### `formatters`
 
-When running Teabag from the command line you can specify the formatters that it will use when displaying the results. Some formatters can be used together, and some are meant to be used by themselves. Play around, and see what you like.
+You can specify the formatters that Teabag will use when outputting the results.
 
 Supported formatters: dot, tap_y, swayze_or_oprah
 
-**Note:** Override this directive by running `rake teabag FORMATTERS=dot,other_formatter`.
+**Note:** Override this directive by running `rake teabag FORMATTERS=dot,swayze_or_oprah`.
 
 **default:** `"dot"`
 
 #### `fail_fast`
 
-When you're running several suites it can be useful to make Teabag fail directly after any suite fails (not continuing on to the next suite), but in environments like CI this isn't as desirable. You can also configure this using the `FAIL_FAST` environment variable.
+If you have several suites it can be useful to make Teabag fail directly after any suite contains failures, but in environments like CI this may not be desirable.
 
-**Note:** override this directive by running `rake teabag FAIL_FAST=false`
+**Note:** Override this directive by running `rake teabag FAIL_FAST=false`
 
 **default:** `true`
 
 #### `suppress_log`
 
-When you run Teabag from the console, it will pipe all console.log/debug/etc. calls to the console. This is useful to catch places where you've forgotten to remove console.log calls, but in verbose applications that use logging heavily this may not be desirable.
+Teabag pipes all console[log/debug/error] calls to STDOUT. This is useful to catch places where you've forgotten to remove them, but in verbose applications this may not be desirable.
 
-**Note:** override this directive by running `rake teabag SUPPRESS_LOG=true`
+**Note:** Override this directive by running `rake teabag SUPPRESS_LOG=true`
 
 **default:** `false`
 
@@ -383,18 +397,18 @@ When you run Teabag from the console, it will pipe all console.log/debug/etc. ca
 
 [Mocha](http://visionmedia.github.com/mocha) came up while we were working on Teabag -- we read up about it and thought it was a pretty awesome library with some really great approaches to some of the things that some of us browser types should consider more often, so we included it and added support for it. We encourage you to give it a try. Read more about [Using Mocha](https://github.com/modeset/teabag/wiki/Using-Mocha) with Teabag.
 
-[QUnit](http://qunitjs.com) We're not sure about how many people use QUnit, but we like jQuery, and it wasn't that hard to add support for it, so we did. Show us some love if you're using it. Read more about [Using QUnit](https://github.com/modeset/teabag/wiki/Using-QUnit) with Teabag.
+[QUnit](http://qunitjs.com) We're not sure about how many people use QUnit, but we like jQuery, so we added it. Read more about [Using QUnit](https://github.com/modeset/teabag/wiki/Using-QUnit) with Teabag.
 
 
 ## Support Libraries
 
-Because we know that testing usually requires more than just the test framework we've included some of the great libraries that we use on a regular basis.
+We know that testing usually requires more than just the test framework, so we've included some of the libraries that we use on a regular basis.
 
 - [jasmine-jquery.js](https://github.com/velesin/jasmine-jquery) jQuery matchers and fixture support (Jasmine).
-- [Sinon.JS](https://github.com/cjohansen/Sinon.JS) Great for stubbing / spying, and mocking Ajax (Mocha/Jasmine).
 - [expect.js](https://github.com/LearnBoost/expect.js) Minimalistic BDD assertion toolkit (Mocha).
+- [Sinon.JS](https://github.com/cjohansen/Sinon.JS) Great for stubbing / spying, and mocking Ajax.
 
-You can require these files in your spec helper using:
+You can require these files in your spec helper by using:
 
 ```javascript
 //=require support/jasmine-jquery
@@ -410,13 +424,6 @@ There's a few things that we're doing to make Teabag nicer on CI. We're in the p
 More on this shortly....
 
 
-## Roadmap
-
-So, there's lots of directions we can take the Teabag project, but we'll give it some time to see what people are looking for.
-
-Check the [issues](https://github.com/modeset/teabag/issues) to see / discuss features that we're considering or are working on.
-
-
 ## License
 
 Licensed under the [MIT License](http://creativecommons.org/licenses/MIT/)

data/app/assets/javascripts/teabag/base/fixture.coffee

@@ -0,0 +1,99 @@
+class Teabag.fixture
+
+  @cache: {}
+  @el: null
+  @json: []
+
+  # Public API
+
+  @preload: (urls...) -> preload(url) for url in urls
+
+
+  @load: (urls..., append = false) ->
+    unless typeof(append) == "boolean"
+      urls.push(append)
+      append = false
+    load(url, append || index > 0) for url, index in urls
+
+
+  @set: (htmls..., append = false) ->
+    unless typeof(append) == "boolean"
+      htmls.push(append)
+      append = false
+    set(html, append || index > 0) for html, index in htmls
+
+
+  @cleanup: -> cleanup()
+
+
+  # behaves like load, and is only provided as a convenience
+  constructor: -> Teabag.fixture.load.apply(window, arguments)
+
+
+  # Private
+
+  xhr = null
+
+  preload = (url) =>
+    load(url, false, true)
+
+
+  load = (url, append, preload = false) =>
+    return loadComplete(url, cached.type, cached.content, append, preload) if cached = Teabag.fixture.cache[url]
+    value = null
+    xhrRequest url, ->
+      return unless xhr.readyState == 4
+      throw("Unable to load fixture \"#{url}\".") unless xhr.status == 200
+      value = loadComplete(url, xhr.getResponseHeader("content-type"), xhr.responseText, append, preload)
+    return value
+
+
+  loadComplete = (url, type, content, append, preload) =>
+    Teabag.fixture.cache[url] = {type: type, content: content}
+    return @json[@json.push(JSON.parse(content)) - 1] if type.match(/application\/json;/)
+    return content if preload
+    if append then addContent(content) else putContent(content)
+    return Teabag.fixture.el
+
+
+  set = (content, append) ->
+    if append then addContent(content) else putContent(content)
+
+
+  putContent = (content) =>
+    cleanup()
+    create()
+    Teabag.fixture.el.innerHTML = content
+
+
+  addContent = (content) =>
+    create() unless Teabag.fixture.el
+    Teabag.fixture.el.innerHTML += content
+
+
+
+  create = =>
+    Teabag.fixture.el = document.createElement("div")
+    Teabag.fixture.el.id = "teabag-fixtures"
+    document.body?.appendChild(Teabag.fixture.el)
+
+
+  cleanup = =>
+    Teabag.fixture.el ||= document.getElementById("teabag-fixtures")
+    Teabag.fixture.el?.parentNode?.removeChild(Teabag.fixture.el)
+    Teabag.fixture.el = null
+
+
+  xhrRequest = (url, callback) ->
+    if window.XMLHttpRequest # Mozilla, Safari, ...
+      xhr = new XMLHttpRequest()
+    else if window.ActiveXObject # IE
+      try xhr = new ActiveXObject("Msxml2.XMLHTTP")
+      catch e
+        try xhr = new ActiveXObject("Microsoft.XMLHTTP")
+        catch e
+    throw("Unable to make Ajax Request") unless xhr
+
+    xhr.onreadystatechange = callback
+    xhr.open("GET", "#{Teabag.root}/fixtures/#{url}", false)
+    xhr.send()

data/app/assets/javascripts/teabag/base/teabag.coffee

@@ -1,5 +1,6 @@
 #= require_self
 #= require teabag/base/runner
+#= require teabag/base/fixture
 #= require teabag/base/reporters/html
 #= require teabag/base/reporters/console
 

data/app/assets/javascripts/teabag/jasmine.coffee

@@ -4,8 +4,6 @@
 
 class Teabag.Runner extends Teabag.Runner
 
-  env = jasmine.getEnv()
-
   constructor: ->
     super
     env.execute()
@@ -84,3 +82,37 @@ class Teabag.Suite
     @link = "?grep=#{encodeURIComponent(@fullDescription)}"
     @parent = @suite.parentSuite
     @viewId = @suite.viewId
+
+
+
+class Teabag.fixture extends Teabag.fixture
+
+  window.fixture = @
+
+  @load: ->
+    args = arguments
+    throw "Teabag can't load fixtures outside of describe." unless env.currentSuite || env.currentSpec
+    if env.currentSuite
+      env.beforeEach => fixture.__super__.constructor.load.apply(@, args)
+      env.afterEach => @cleanup()
+      super
+    else
+      env.currentSpec.after => @cleanup()
+      super
+
+
+  @set: ->
+    args = arguments
+    throw "Teabag can't load fixtures outside of describe." unless env.currentSuite || env.currentSpec
+    if env.currentSuite
+      env.beforeEach => fixture.__super__.constructor.set.apply(@, args)
+      env.afterEach => @cleanup()
+      super
+    else
+      env.currentSpec.after => @cleanup()
+      super
+
+
+
+# set the environment
+env = jasmine.getEnv()

data/app/assets/javascripts/teabag/mocha.coffee

@@ -5,11 +5,11 @@
 
 class Teabag.Runner extends Teabag.Runner
 
-  env = mocha.setup("bdd")
-
   constructor: ->
     super
     env.run()
+    env.started = true
+    afterEach -> Teabag.fixture.cleanup()
 
 
   setup: ->
@@ -65,3 +65,25 @@ class Teabag.Suite
     @link = "?grep=#{encodeURIComponent(@fullDescription)}"
     @parent = if @suite.parent.root then null else @suite.parent
     @viewId = @suite.viewId
+
+
+
+class Teabag.fixture extends Teabag.fixture
+
+  window.fixture = @
+
+  @load: ->
+    args = arguments
+    if env.started then super
+    else beforeEach => fixture.__super__.constructor.load.apply(@, args)
+
+
+  @set: ->
+    args = arguments
+    if env.started then super
+    else beforeEach => fixture.__super__.constructor.set.apply(@, args)
+
+
+
+# set the environment
+env = mocha.setup("bdd")

data/app/assets/javascripts/teabag/qunit.coffee

@@ -5,10 +5,6 @@
 
 class Teabag.Runner extends Teabag.Runner
 
-  env = QUnit
-  env.config.autostart = false
-  env.config.altertitle = false
-
   constructor: ->
     super
     env.start()
@@ -25,7 +21,7 @@ class Teabag.Spec
   constructor: (@spec) ->
     @fullDescription = "#{@spec.module} #{@spec.name}"
     @description = "#{@spec.name} (#{@spec.failed}, #{@spec.passed}, #{@spec.total})"
-    @link = "?grep=#{encodeURIComponent(@fullDescription)}"
+    @link = "?grep=#{encodeURIComponent("#{@spec.module}: #{@spec.name}")}"
     @parent = if @spec.module then new Teabag.Suite({description: @spec.module}) else null
     @suiteName = @spec.module
     @viewId = @spec.viewId
@@ -59,3 +55,16 @@ class Teabag.Suite
     @description = @suite.description
     @link = "?grep=#{encodeURIComponent(@fullDescription)}"
     @parent = null
+
+
+# set the environment
+env = QUnit
+env.config.autostart = false
+env.config.altertitle = false
+env.config.filter = Teabag.Runner.prototype.getParams()["grep"]
+
+window.fixture = Teabag.fixture
+originalReset = env.reset
+env.reset = ->
+  originalReset()
+  Teabag.fixture.cleanup()