diff --git a/AssetFile b/AssetFile
index 035412ff..36294dae 100644
--- a/AssetFile
+++ b/AssetFile
@@ -20,7 +20,7 @@ input 'assets/javascripts' do
     concat files, 'vendor.js'
   end
 
-  match '**/*.coffee' do
+  match '{app,config,lib}/**/*.coffee' do
     coffee_script
   end
 
@@ -49,6 +49,23 @@ input 'assets/javascripts' do
   end
 end
 
+# DOH. how to simplify this.
+input 'assets/javascripts/spec' do
+  match 'vendor/*.js' do
+    files = %w(
+      vendor/jasmine.js
+      vendor/jasmine-html.js
+      vendor/jasmine-runner.js
+    )
+    concat files, 'specs/vendor.js'
+  end
+
+  match '**/*.coffee' do
+    coffee_script
+    concat 'specs/specs.js'
+  end
+end
+
 output 'public/stylesheets'
 input 'assets/stylesheets' do
   match '**/*.scss' do
@@ -62,9 +79,9 @@ input 'assets/stylesheets' do
   end
 end
 
-output 'public'
-input 'assets', 'index.html.erb' do
-  filter(Rake::Pipeline::Web::Filters::TiltFilter) do |input|
-    input.sub /\.erb$/, ''
-  end
-end
+# output 'public'
+# input 'assets', 'index.html.erb' do
+#   filter(Rake::Pipeline::Web::Filters::TiltFilter) do |input|
+#     input.sub /\\.erb$/, ''
+#   end
+# end
diff --git a/assets/javascripts/app/app.coffee b/assets/javascripts/app/app.coffee
index c8fd1ac4..32854715 100644
--- a/assets/javascripts/app/app.coffee
+++ b/assets/javascripts/app/app.coffee
@@ -14,5 +14,3 @@ Travis.store = DS.Store.extend(
   revision: 4
   adapter: Travis.RestAdapter.create()
 ).create()
-
-Travis.initialize()
diff --git a/assets/javascripts/app/helpers/urls.coffee b/assets/javascripts/app/helpers/urls.coffee
index 8ddd1882..45d74704 100644
--- a/assets/javascripts/app/helpers/urls.coffee
+++ b/assets/javascripts/app/helpers/urls.coffee
@@ -20,12 +20,11 @@
       '%@.png'.fmt @get('slug')
     ).property('slug')
 
-  Build:
-    githubCommit: (->
+  Commit:
+    urlGithubCommit: (->
       'http://github.com/%@/commit/%@'.fmt @getPath('repository.slug'), @getPath('commit.sha')
     ).property('repository.slug', 'commit.sha')
 
-  Commit:
     urlAuthor: (->
       'mailto:%@'.fmt @getPath('commit.authorEmail')
     ).property()
diff --git a/assets/javascripts/app/templates/builds/list.hbs b/assets/javascripts/app/templates/builds/list.hbs
index d13511cf..37836b93 100644
--- a/assets/javascripts/app/templates/builds/list.hbs
+++ b/assets/javascripts/app/templates/builds/list.hbs
@@ -14,7 +14,7 @@
       {{#view Travis.BuildsItemView contextBinding="build"}}
         <tr>
           <td class="number"><a {{action viewBuild href=true}}>{{number}}</a></td>
-          <td class="commit"><a {{bindAttr href="urlGithubCommit"}}>{{formatCommit commit}}</a></td>
+          <td class="commit"><a {{bindAttr href="view.urlGithubCommit"}}>{{formatCommit commit}}</a></td>
           <td class="message">{{{formatMessage commit.message short="true"}}}</td>
           <td class="duration" {{bindAttr title="started_at"}}>{{formatDuration duration}}</td>
           <td class="finished_at timeago" {{bindAttr title="finished_at"}}>{{formatTime finished_at}}</td>
diff --git a/assets/javascripts/app/templates/repositories/list.hbs b/assets/javascripts/app/templates/repositories/list.hbs
index 99d8499f..89f84e60 100644
--- a/assets/javascripts/app/templates/repositories/list.hbs
+++ b/assets/javascripts/app/templates/repositories/list.hbs
@@ -1,24 +1,22 @@
 {{#if content.lastObject.isLoaded}}
-  <ul>
+  <ul id="repositories">
     {{#each repository in content}}
-      {{#view Travis.RepositoriesItemView contextBinding="repository"}}
-        <li {{bindAttr class="view.classes"}}>
-          <div class="wrapper">
-            <a {{action viewCurrent href=true}} class="slug">{{slug}}</a>
-            <a {{action viewBuild href=true context="lastBuild"}} class="build">#{{lastBuildNumber}}</a>
-          </div>
+      {{#view Travis.RepositoriesItemView tagName="li" classBinding="classes" contextBinding="repository"}}
+        <div class="wrapper">
+          <a {{action viewCurrent href=true}} class="slug">{{slug}}</a>
+          <a {{action viewBuild href=true context="lastBuild"}} class="build">#{{lastBuildNumber}}</a>
+        </div>
 
-          <p class="summary">
-            <span class="duration_label">{{t repositories.duration}}:</span>
-            <abbr class="duration" {{bindAttr title="lastBuildStartedAt"}}>{{formatDuration lastBuildDuration}}</abbr>,
-            <span class="finished_at_label">{{t repositories.finished_at}}:</span>
-            <abbr class="finished_at timeago" {{bindAttr title="lastBuildFinishedAt"}}>{{formatTime lastBuildFinished_at}}</abbr>
-          </p>
-          {{#if description}}
-            <p class="description">{{description}}</p>
-          {{/if}}
-          <span class="indicator"></span>
-        </li>
+        <p class="summary">
+          <span class="duration_label">{{t repositories.duration}}:</span>
+          <abbr class="duration" {{bindAttr title="lastBuildStartedAt"}}>{{formatDuration lastBuildDuration}}</abbr>,
+          <span class="finished_at_label">{{t repositories.finished_at}}:</span>
+          <abbr class="finished_at timeago" {{bindAttr title="lastBuildFinishedAt"}}>{{formatTime lastBuildFinished_at}}</abbr>
+        </p>
+        {{#if description}}
+          <p class="description">{{description}}</p>
+        {{/if}}
+        <span class="indicator"></span>
       {{/view}}
     {{/each}}
   <ul>
diff --git a/assets/javascripts/spec/foo.spec.js b/assets/javascripts/spec/foo.spec.js
deleted file mode 100644
index 647e7ca8..00000000
--- a/assets/javascripts/spec/foo.spec.js
+++ /dev/null
@@ -1,5 +0,0 @@
-describe("Foo", function () {
-  it("creates a global variable called Util", function () {
-    expect(Util).to.be.an("object");
-  });
-})
diff --git a/assets/javascripts/spec/foo_spec.coffee b/assets/javascripts/spec/foo_spec.coffee
new file mode 100644
index 00000000..8b1d9dc3
--- /dev/null
+++ b/assets/javascripts/spec/foo_spec.coffee
@@ -0,0 +1,14 @@
+describe 'Foo', ->
+  it 'bar', ->
+    console.log('before spec')
+    link = $($('#repositories a.slug')[0])
+    console.log $('body').html().toString()
+    # link.attr('href').should.equal '#/travis-ci/travis-core'
+    console.log('after spec')
+
+  it 'bar', ->
+    console.log('before spec')
+    link = $($('#repositories a.slug')[0])
+    # link.attr('href').should.equal '#/travis-ci/travis-core'
+    console.log('after spec')
+
diff --git a/assets/javascripts/spec/spec_helper.coffee b/assets/javascripts/spec/spec_helper.coffee
new file mode 100644
index 00000000..c44a81e7
--- /dev/null
+++ b/assets/javascripts/spec/spec_helper.coffee
@@ -0,0 +1,11 @@
+minispade.require 'app'
+
+$('body').append($('<div id="spec_content"></div>'))
+Travis.rootElement = '#spec_content'
+
+# beforeEach ->
+#   $('body #spec_content').empty()
+#   Travis.initialize()
+
+# afterEach ->
+#
diff --git a/assets/javascripts/spec/support/index.html b/assets/javascripts/spec/support/index.html
deleted file mode 100644
index 2d674242..00000000
--- a/assets/javascripts/spec/support/index.html
+++ /dev/null
@@ -1,23 +0,0 @@
-<!DOCTYPE html>
-<html>
-<head>
-  <meta charset="UTF-8">
-  <title>Mocha Test Runner</title>
-  <link rel="stylesheet" href="stylesheets/vendor/mocha.css">
-  <script src="../vendor/mocha.js"></script>
-  <script src="../vendor/expect.js"></script>
-
-  <script>
-      mocha.setup('bdd');
-  </script>
-
-  <script src="../../app/foo.js"></script>
-  <script src="../foo.spec.js"></script>
-</head>
-<body>
-    <div id="mocha"></div>
-    <script>
-        mocha.run();
-    </script>
-</body>
-</html>
diff --git a/assets/javascripts/spec/vendor/jasmine-html.js b/assets/javascripts/spec/vendor/jasmine-html.js
new file mode 100644
index 00000000..a0b06394
--- /dev/null
+++ b/assets/javascripts/spec/vendor/jasmine-html.js
@@ -0,0 +1,616 @@
+jasmine.HtmlReporterHelpers = {};
+
+jasmine.HtmlReporterHelpers.createDom = function(type, attrs, childrenVarArgs) {
+  var el = document.createElement(type);
+
+  for (var i = 2; i < arguments.length; i++) {
+    var child = arguments[i];
+
+    if (typeof child === 'string') {
+      el.appendChild(document.createTextNode(child));
+    } else {
+      if (child) {
+        el.appendChild(child);
+      }
+    }
+  }
+
+  for (var attr in attrs) {
+    if (attr == "className") {
+      el[attr] = attrs[attr];
+    } else {
+      el.setAttribute(attr, attrs[attr]);
+    }
+  }
+
+  return el;
+};
+
+jasmine.HtmlReporterHelpers.getSpecStatus = function(child) {
+  var results = child.results();
+  var status = results.passed() ? 'passed' : 'failed';
+  if (results.skipped) {
+    status = 'skipped';
+  }
+
+  return status;
+};
+
+jasmine.HtmlReporterHelpers.appendToSummary = function(child, childElement) {
+  var parentDiv = this.dom.summary;
+  var parentSuite = (typeof child.parentSuite == 'undefined') ? 'suite' : 'parentSuite';
+  var parent = child[parentSuite];
+
+  if (parent) {
+    if (typeof this.views.suites[parent.id] == 'undefined') {
+      this.views.suites[parent.id] = new jasmine.HtmlReporter.SuiteView(parent, this.dom, this.views);
+    }
+    parentDiv = this.views.suites[parent.id].element;
+  }
+
+  parentDiv.appendChild(childElement);
+};
+
+
+jasmine.HtmlReporterHelpers.addHelpers = function(ctor) {
+  for(var fn in jasmine.HtmlReporterHelpers) {
+    ctor.prototype[fn] = jasmine.HtmlReporterHelpers[fn];
+  }
+};
+
+jasmine.HtmlReporter = function(_doc) {
+  var self = this;
+  var doc = _doc || window.document;
+
+  var reporterView;
+
+  var dom = {};
+
+  // Jasmine Reporter Public Interface
+  self.logRunningSpecs = false;
+
+  self.reportRunnerStarting = function(runner) {
+    var specs = runner.specs() || [];
+
+    if (specs.length == 0) {
+      return;
+    }
+
+    createReporterDom(runner.env.versionString());
+    doc.body.appendChild(dom.reporter);
+
+    reporterView = new jasmine.HtmlReporter.ReporterView(dom);
+    reporterView.addSpecs(specs, self.specFilter);
+  };
+
+  self.reportRunnerResults = function(runner) {
+    reporterView && reporterView.complete();
+  };
+
+  self.reportSuiteResults = function(suite) {
+    reporterView.suiteComplete(suite);
+  };
+
+  self.reportSpecStarting = function(spec) {
+    if (self.logRunningSpecs) {
+      self.log('>> Jasmine Running ' + spec.suite.description + ' ' + spec.description + '...');
+    }
+  };
+
+  self.reportSpecResults = function(spec) {
+    reporterView.specComplete(spec);
+  };
+
+  self.log = function() {
+    var console = jasmine.getGlobal().console;
+    if (console && console.log) {
+      if (console.log.apply) {
+        console.log.apply(console, arguments);
+      } else {
+        console.log(arguments); // ie fix: console.log.apply doesn't exist on ie
+      }
+    }
+  };
+
+  self.specFilter = function(spec) {
+    if (!focusedSpecName()) {
+      return true;
+    }
+
+    return spec.getFullName().indexOf(focusedSpecName()) === 0;
+  };
+
+  return self;
+
+  function focusedSpecName() {
+    var specName;
+
+    (function memoizeFocusedSpec() {
+      if (specName) {
+        return;
+      }
+
+      var paramMap = [];
+      var params = doc.location.search.substring(1).split('&');
+
+      for (var i = 0; i < params.length; i++) {
+        var p = params[i].split('=');
+        paramMap[decodeURIComponent(p[0])] = decodeURIComponent(p[1]);
+      }
+
+      specName = paramMap.spec;
+    })();
+
+    return specName;
+  }
+
+  function createReporterDom(version) {
+    dom.reporter = self.createDom('div', { id: 'HTMLReporter', className: 'jasmine_reporter' },
+      dom.banner = self.createDom('div', { className: 'banner' },
+        self.createDom('span', { className: 'title' }, "Jasmine "),
+        self.createDom('span', { className: 'version' }, version)),
+
+      dom.symbolSummary = self.createDom('ul', {className: 'symbolSummary'}),
+      dom.alert = self.createDom('div', {className: 'alert'}),
+      dom.results = self.createDom('div', {className: 'results'},
+        dom.summary = self.createDom('div', { className: 'summary' }),
+        dom.details = self.createDom('div', { id: 'details' }))
+    );
+  }
+};
+jasmine.HtmlReporterHelpers.addHelpers(jasmine.HtmlReporter);jasmine.HtmlReporter.ReporterView = function(dom) {
+  this.startedAt = new Date();
+  this.runningSpecCount = 0;
+  this.completeSpecCount = 0;
+  this.passedCount = 0;
+  this.failedCount = 0;
+  this.skippedCount = 0;
+
+  this.createResultsMenu = function() {
+    this.resultsMenu = this.createDom('span', {className: 'resultsMenu bar'},
+      this.summaryMenuItem = this.createDom('a', {className: 'summaryMenuItem', href: "#"}, '0 specs'),
+      ' | ',
+      this.detailsMenuItem = this.createDom('a', {className: 'detailsMenuItem', href: "#"}, '0 failing'));
+
+    this.summaryMenuItem.onclick = function() {
+      dom.reporter.className = dom.reporter.className.replace(/ showDetails/g, '');
+    };
+
+    this.detailsMenuItem.onclick = function() {
+      showDetails();
+    };
+  };
+
+  this.addSpecs = function(specs, specFilter) {
+    this.totalSpecCount = specs.length;
+
+    this.views = {
+      specs: {},
+      suites: {}
+    };
+
+    for (var i = 0; i < specs.length; i++) {
+      var spec = specs[i];
+      this.views.specs[spec.id] = new jasmine.HtmlReporter.SpecView(spec, dom, this.views);
+      if (specFilter(spec)) {
+        this.runningSpecCount++;
+      }
+    }
+  };
+
+  this.specComplete = function(spec) {
+    this.completeSpecCount++;
+
+    if (isUndefined(this.views.specs[spec.id])) {
+      this.views.specs[spec.id] = new jasmine.HtmlReporter.SpecView(spec, dom);
+    }
+
+    var specView = this.views.specs[spec.id];
+
+    switch (specView.status()) {
+      case 'passed':
+        this.passedCount++;
+        break;
+
+      case 'failed':
+        this.failedCount++;
+        break;
+
+      case 'skipped':
+        this.skippedCount++;
+        break;
+    }
+
+    specView.refresh();
+    this.refresh();
+  };
+
+  this.suiteComplete = function(suite) {
+    var suiteView = this.views.suites[suite.id];
+    if (isUndefined(suiteView)) {
+      return;
+    }
+    suiteView.refresh();
+  };
+
+  this.refresh = function() {
+
+    if (isUndefined(this.resultsMenu)) {
+      this.createResultsMenu();
+    }
+
+    // currently running UI
+    if (isUndefined(this.runningAlert)) {
+      this.runningAlert = this.createDom('a', {href: "?", className: "runningAlert bar"});
+      dom.alert.appendChild(this.runningAlert);
+    }
+    this.runningAlert.innerHTML = "Running " + this.completeSpecCount + " of " + specPluralizedFor(this.totalSpecCount);
+
+    // skipped specs UI
+    if (isUndefined(this.skippedAlert)) {
+      this.skippedAlert = this.createDom('a', {href: "?", className: "skippedAlert bar"});
+    }
+
+    this.skippedAlert.innerHTML = "Skipping " + this.skippedCount + " of " + specPluralizedFor(this.totalSpecCount) + " - run all";
+
+    if (this.skippedCount === 1 && isDefined(dom.alert)) {
+      dom.alert.appendChild(this.skippedAlert);
+    }
+
+    // passing specs UI
+    if (isUndefined(this.passedAlert)) {
+      this.passedAlert = this.createDom('span', {href: "?", className: "passingAlert bar"});
+    }
+    this.passedAlert.innerHTML = "Passing " + specPluralizedFor(this.passedCount);
+
+    // failing specs UI
+    if (isUndefined(this.failedAlert)) {
+      this.failedAlert = this.createDom('span', {href: "?", className: "failingAlert bar"});
+    }
+    this.failedAlert.innerHTML = "Failing " + specPluralizedFor(this.failedCount);
+
+    if (this.failedCount === 1 && isDefined(dom.alert)) {
+      dom.alert.appendChild(this.failedAlert);
+      dom.alert.appendChild(this.resultsMenu);
+    }
+
+    // summary info
+    this.summaryMenuItem.innerHTML = "" + specPluralizedFor(this.runningSpecCount);
+    this.detailsMenuItem.innerHTML = "" + this.failedCount + " failing";
+  };
+
+  this.complete = function() {
+    dom.alert.removeChild(this.runningAlert);
+
+    this.skippedAlert.innerHTML = "Ran " + this.runningSpecCount + " of " + specPluralizedFor(this.totalSpecCount) + " - run all";
+
+    if (this.failedCount === 0) {
+      dom.alert.appendChild(this.createDom('span', {className: 'passingAlert bar'}, "Passing " + specPluralizedFor(this.passedCount)));
+    } else {
+      showDetails();
+    }
+
+    dom.banner.appendChild(this.createDom('span', {className: 'duration'}, "finished in " + ((new Date().getTime() - this.startedAt.getTime()) / 1000) + "s"));
+  };
+
+  return this;
+
+  function showDetails() {
+    if (dom.reporter.className.search(/showDetails/) === -1) {
+      dom.reporter.className += " showDetails";
+    }
+  }
+
+  function isUndefined(obj) {
+    return typeof obj === 'undefined';
+  }
+
+  function isDefined(obj) {
+    return !isUndefined(obj);
+  }
+
+  function specPluralizedFor(count) {
+    var str = count + " spec";
+    if (count > 1) {
+      str += "s"
+    }
+    return str;
+  }
+
+};
+
+jasmine.HtmlReporterHelpers.addHelpers(jasmine.HtmlReporter.ReporterView);
+
+
+jasmine.HtmlReporter.SpecView = function(spec, dom, views) {
+  this.spec = spec;
+  this.dom = dom;
+  this.views = views;
+
+  this.symbol = this.createDom('li', { className: 'pending' });
+  this.dom.symbolSummary.appendChild(this.symbol);
+
+  this.summary = this.createDom('div', { className: 'specSummary' },
+      this.createDom('a', {
+        className: 'description',
+        href: '?spec=' + encodeURIComponent(this.spec.getFullName()),
+        title: this.spec.getFullName()
+      }, this.spec.description)
+  );
+
+  this.detail = this.createDom('div', { className: 'specDetail' },
+      this.createDom('a', {
+        className: 'description',
+        href: '?spec=' + encodeURIComponent(this.spec.getFullName()),
+        title: this.spec.getFullName()
+      }, this.spec.getFullName())
+  );
+};
+
+jasmine.HtmlReporter.SpecView.prototype.status = function() {
+  return this.getSpecStatus(this.spec);
+};
+
+jasmine.HtmlReporter.SpecView.prototype.refresh = function() {
+  this.symbol.className = this.status();
+
+  switch (this.status()) {
+    case 'skipped':
+      break;
+
+    case 'passed':
+      this.appendSummaryToSuiteDiv();
+      break;
+
+    case 'failed':
+      this.appendSummaryToSuiteDiv();
+      this.appendFailureDetail();
+      break;
+  }
+};
+
+jasmine.HtmlReporter.SpecView.prototype.appendSummaryToSuiteDiv = function() {
+  this.summary.className += ' ' + this.status();
+  this.appendToSummary(this.spec, this.summary);
+};
+
+jasmine.HtmlReporter.SpecView.prototype.appendFailureDetail = function() {
+  this.detail.className += ' ' + this.status();
+
+  var resultItems = this.spec.results().getItems();
+  var messagesDiv = this.createDom('div', { className: 'messages' });
+
+  for (var i = 0; i < resultItems.length; i++) {
+    var result = resultItems[i];
+
+    if (result.type == 'log') {
+      messagesDiv.appendChild(this.createDom('div', {className: 'resultMessage log'}, result.toString()));
+    } else if (result.type == 'expect' && result.passed && !result.passed()) {
+      messagesDiv.appendChild(this.createDom('div', {className: 'resultMessage fail'}, result.message));
+
+      if (result.trace.stack) {
+        messagesDiv.appendChild(this.createDom('div', {className: 'stackTrace'}, result.trace.stack));
+      }
+    }
+  }
+
+  if (messagesDiv.childNodes.length > 0) {
+    this.detail.appendChild(messagesDiv);
+    this.dom.details.appendChild(this.detail);
+  }
+};
+
+jasmine.HtmlReporterHelpers.addHelpers(jasmine.HtmlReporter.SpecView);jasmine.HtmlReporter.SuiteView = function(suite, dom, views) {
+  this.suite = suite;
+  this.dom = dom;
+  this.views = views;
+
+  this.element = this.createDom('div', { className: 'suite' },
+      this.createDom('a', { className: 'description', href: '?spec=' + encodeURIComponent(this.suite.getFullName()) }, this.suite.description)
+  );
+
+  this.appendToSummary(this.suite, this.element);
+};
+
+jasmine.HtmlReporter.SuiteView.prototype.status = function() {
+  return this.getSpecStatus(this.suite);
+};
+
+jasmine.HtmlReporter.SuiteView.prototype.refresh = function() {
+  this.element.className += " " + this.status();
+};
+
+jasmine.HtmlReporterHelpers.addHelpers(jasmine.HtmlReporter.SuiteView);
+
+/* @deprecated Use jasmine.HtmlReporter instead
+ */
+jasmine.TrivialReporter = function(doc) {
+  this.document = doc || document;
+  this.suiteDivs = {};
+  this.logRunningSpecs = false;
+};
+
+jasmine.TrivialReporter.prototype.createDom = function(type, attrs, childrenVarArgs) {
+  var el = document.createElement(type);
+
+  for (var i = 2; i < arguments.length; i++) {
+    var child = arguments[i];
+
+    if (typeof child === 'string') {
+      el.appendChild(document.createTextNode(child));
+    } else {
+      if (child) { el.appendChild(child); }
+    }
+  }
+
+  for (var attr in attrs) {
+    if (attr == "className") {
+      el[attr] = attrs[attr];
+    } else {
+      el.setAttribute(attr, attrs[attr]);
+    }
+  }
+
+  return el;
+};
+
+jasmine.TrivialReporter.prototype.reportRunnerStarting = function(runner) {
+  var showPassed, showSkipped;
+
+  this.outerDiv = this.createDom('div', { id: 'TrivialReporter', className: 'jasmine_reporter' },
+      this.createDom('div', { className: 'banner' },
+        this.createDom('div', { className: 'logo' },
+            this.createDom('span', { className: 'title' }, "Jasmine"),
+            this.createDom('span', { className: 'version' }, runner.env.versionString())),
+        this.createDom('div', { className: 'options' },
+            "Show ",
+            showPassed = this.createDom('input', { id: "__jasmine_TrivialReporter_showPassed__", type: 'checkbox' }),
+            this.createDom('label', { "for": "__jasmine_TrivialReporter_showPassed__" }, " passed "),
+            showSkipped = this.createDom('input', { id: "__jasmine_TrivialReporter_showSkipped__", type: 'checkbox' }),
+            this.createDom('label', { "for": "__jasmine_TrivialReporter_showSkipped__" }, " skipped")
+            )
+          ),
+
+      this.runnerDiv = this.createDom('div', { className: 'runner running' },
+          this.createDom('a', { className: 'run_spec', href: '?' }, "run all"),
+          this.runnerMessageSpan = this.createDom('span', {}, "Running..."),
+          this.finishedAtSpan = this.createDom('span', { className: 'finished-at' }, ""))
+      );
+
+  this.document.body.appendChild(this.outerDiv);
+
+  var suites = runner.suites();
+  for (var i = 0; i < suites.length; i++) {
+    var suite = suites[i];
+    var suiteDiv = this.createDom('div', { className: 'suite' },
+        this.createDom('a', { className: 'run_spec', href: '?spec=' + encodeURIComponent(suite.getFullName()) }, "run"),
+        this.createDom('a', { className: 'description', href: '?spec=' + encodeURIComponent(suite.getFullName()) }, suite.description));
+    this.suiteDivs[suite.id] = suiteDiv;
+    var parentDiv = this.outerDiv;
+    if (suite.parentSuite) {
+      parentDiv = this.suiteDivs[suite.parentSuite.id];
+    }
+    parentDiv.appendChild(suiteDiv);
+  }
+
+  this.startedAt = new Date();
+
+  var self = this;
+  showPassed.onclick = function(evt) {
+    if (showPassed.checked) {
+      self.outerDiv.className += ' show-passed';
+    } else {
+      self.outerDiv.className = self.outerDiv.className.replace(/ show-passed/, '');
+    }
+  };
+
+  showSkipped.onclick = function(evt) {
+    if (showSkipped.checked) {
+      self.outerDiv.className += ' show-skipped';
+    } else {
+      self.outerDiv.className = self.outerDiv.className.replace(/ show-skipped/, '');
+    }
+  };
+};
+
+jasmine.TrivialReporter.prototype.reportRunnerResults = function(runner) {
+  var results = runner.results();
+  var className = (results.failedCount > 0) ? "runner failed" : "runner passed";
+  this.runnerDiv.setAttribute("class", className);
+  //do it twice for IE
+  this.runnerDiv.setAttribute("className", className);
+  var specs = runner.specs();
+  var specCount = 0;
+  for (var i = 0; i < specs.length; i++) {
+    if (this.specFilter(specs[i])) {
+      specCount++;
+    }
+  }
+  var message = "" + specCount + " spec" + (specCount == 1 ? "" : "s" ) + ", " + results.failedCount + " failure" + ((results.failedCount == 1) ? "" : "s");
+  message += " in " + ((new Date().getTime() - this.startedAt.getTime()) / 1000) + "s";
+  this.runnerMessageSpan.replaceChild(this.createDom('a', { className: 'description', href: '?'}, message), this.runnerMessageSpan.firstChild);
+
+  this.finishedAtSpan.appendChild(document.createTextNode("Finished at " + new Date().toString()));
+};
+
+jasmine.TrivialReporter.prototype.reportSuiteResults = function(suite) {
+  var results = suite.results();
+  var status = results.passed() ? 'passed' : 'failed';
+  if (results.totalCount === 0) { // todo: change this to check results.skipped
+    status = 'skipped';
+  }
+  this.suiteDivs[suite.id].className += " " + status;
+};
+
+jasmine.TrivialReporter.prototype.reportSpecStarting = function(spec) {
+  if (this.logRunningSpecs) {
+    this.log('>> Jasmine Running ' + spec.suite.description + ' ' + spec.description + '...');
+  }
+};
+
+jasmine.TrivialReporter.prototype.reportSpecResults = function(spec) {
+  var results = spec.results();
+  var status = results.passed() ? 'passed' : 'failed';
+  if (results.skipped) {
+    status = 'skipped';
+  }
+  var specDiv = this.createDom('div', { className: 'spec '  + status },
+      this.createDom('a', { className: 'run_spec', href: '?spec=' + encodeURIComponent(spec.getFullName()) }, "run"),
+      this.createDom('a', {
+        className: 'description',
+        href: '?spec=' + encodeURIComponent(spec.getFullName()),
+        title: spec.getFullName()
+      }, spec.description));
+
+
+  var resultItems = results.getItems();
+  var messagesDiv = this.createDom('div', { className: 'messages' });
+  for (var i = 0; i < resultItems.length; i++) {
+    var result = resultItems[i];
+
+    if (result.type == 'log') {
+      messagesDiv.appendChild(this.createDom('div', {className: 'resultMessage log'}, result.toString()));
+    } else if (result.type == 'expect' && result.passed && !result.passed()) {
+      messagesDiv.appendChild(this.createDom('div', {className: 'resultMessage fail'}, result.message));
+
+      if (result.trace.stack) {
+        messagesDiv.appendChild(this.createDom('div', {className: 'stackTrace'}, result.trace.stack));
+      }
+    }
+  }
+
+  if (messagesDiv.childNodes.length > 0) {
+    specDiv.appendChild(messagesDiv);
+  }
+
+  this.suiteDivs[spec.suite.id].appendChild(specDiv);
+};
+
+jasmine.TrivialReporter.prototype.log = function() {
+  var console = jasmine.getGlobal().console;
+  if (console && console.log) {
+    if (console.log.apply) {
+      console.log.apply(console, arguments);
+    } else {
+      console.log(arguments); // ie fix: console.log.apply doesn't exist on ie
+    }
+  }
+};
+
+jasmine.TrivialReporter.prototype.getLocation = function() {
+  return this.document.location;
+};
+
+jasmine.TrivialReporter.prototype.specFilter = function(spec) {
+  var paramMap = {};
+  var params = this.getLocation().search.substring(1).split('&');
+  for (var i = 0; i < params.length; i++) {
+    var p = params[i].split('=');
+    paramMap[decodeURIComponent(p[0])] = decodeURIComponent(p[1]);
+  }
+
+  if (!paramMap.spec) {
+    return true;
+  }
+  return spec.getFullName().indexOf(paramMap.spec) === 0;
+};
diff --git a/assets/javascripts/spec/vendor/jasmine-runner.js b/assets/javascripts/spec/vendor/jasmine-runner.js
new file mode 100644
index 00000000..76319ae9
--- /dev/null
+++ b/assets/javascripts/spec/vendor/jasmine-runner.js
@@ -0,0 +1,104 @@
+/**
+ Jasmine Reporter that outputs test results to the browser console. 
+ Useful for running in a headless environment such as PhantomJs, ZombieJs etc.
+
+ Usage:
+ // From your html file that loads jasmine:  
+ jasmine.getEnv().addReporter(new jasmine.ConsoleReporter());
+ jasmine.getEnv().execute();
+*/
+
+(function(jasmine, console) {
+  if (!jasmine) {
+    throw "jasmine library isn't loaded!";
+  }
+
+  var ANSI = {}
+  ANSI.color_map = {
+      "green" : 32,
+      "red"   : 31
+  }
+
+  ANSI.colorize_text = function(text, color) {
+    var color_code = this.color_map[color];
+    return "\033[" + color_code + "m" + text + "\033[0m";
+  }
+  
+  var ConsoleReporter = function() {
+    if (!console || !console.log) { throw "console isn't present!"; }
+    this.status = this.statuses.stopped;
+  };
+
+  var proto = ConsoleReporter.prototype;
+  proto.statuses = {
+    stopped : "stopped",
+    running : "running",
+    fail    : "fail",
+    success : "success"
+  };
+
+  proto.reportRunnerStarting = function(runner) {
+    this.status = this.statuses.running;
+    this.start_time = (new Date()).getTime();
+    this.executed_specs = 0;
+    this.passed_specs = 0;
+    this.log("Starting...");
+  };
+
+  proto.reportRunnerResults = function(runner) {
+    var failed = this.executed_specs - this.passed_specs;
+    var spec_str = this.executed_specs + (this.executed_specs === 1 ? " spec, " : " specs, ");
+    var fail_str = failed + (failed === 1 ? " failure in " : " failures in ");
+    var color = (failed > 0)? "red" : "green";
+    var dur = (new Date()).getTime() - this.start_time;
+
+    this.log("");
+    this.log("Finished");
+    this.log("-----------------");
+    this.log(spec_str + fail_str + (dur/1000) + "s.", color);
+
+    this.status = (failed > 0)? this.statuses.fail : this.statuses.success;
+
+    /* Print something that signals that testing is over so that headless browsers
+       like PhantomJs know when to terminate. */
+    this.log("");
+    this.log("ConsoleReporter finished");
+  };
+
+
+  proto.reportSpecStarting = function(spec) {
+    this.executed_specs++;
+  };
+
+  proto.reportSpecResults = function(spec) {
+    if (spec.results().passed()) {
+      this.passed_specs++;
+      return;
+    }
+
+    var resultText = spec.suite.description + " : " + spec.description;
+    this.log(resultText, "red");
+
+    var items = spec.results().getItems()
+    for (var i = 0; i < items.length; i++) {
+      var text = items[i].trace;
+      this.log(text, "red");
+    }
+  };
+
+  proto.reportSuiteResults = function(suite) {
+    if (!suite.parentSuite) { return; }
+    var results = suite.results();
+    var failed = results.totalCount - results.passedCount;
+    var color = (failed > 0)? "red" : "green";
+    this.log(suite.description + ": " + results.passedCount + " of " + results.totalCount + " passed.", color);
+  };
+
+  proto.log = function(str, color) {
+    var text = (color != undefined)? ANSI.colorize_text(str, color) : str;
+    console.log(text)
+  };
+
+  jasmine.ConsoleReporter = ConsoleReporter;
+})(jasmine, console);
+
diff --git a/assets/javascripts/spec/vendor/jasmine.js b/assets/javascripts/spec/vendor/jasmine.js
new file mode 100644
index 00000000..79d1d4f4
--- /dev/null
+++ b/assets/javascripts/spec/vendor/jasmine.js
@@ -0,0 +1,2529 @@
+var isCommonJS = typeof window == "undefined";
+
+/**
+ * Top level namespace for Jasmine, a lightweight JavaScript BDD/spec/testing framework.
+ *
+ * @namespace
+ */
+var jasmine = {};
+if (isCommonJS) exports.jasmine = jasmine;
+/**
+ * @private
+ */
+jasmine.unimplementedMethod_ = function() {
+  throw new Error("unimplemented method");
+};
+
+/**
+ * Use <code>jasmine.undefined</code> instead of <code>undefined</code>, since <code>undefined</code> is just
+ * a plain old variable and may be redefined by somebody else.
+ *
+ * @private
+ */
+jasmine.undefined = jasmine.___undefined___;
+
+/**
+ * Show diagnostic messages in the console if set to true
+ *
+ */
+jasmine.VERBOSE = false;
+
+/**
+ * Default interval in milliseconds for event loop yields (e.g. to allow network activity or to refresh the screen with the HTML-based runner). Small values here may result in slow test running. Zero means no updates until all tests have completed.
+ *
+ */
+jasmine.DEFAULT_UPDATE_INTERVAL = 250;
+
+/**
+ * Default timeout interval in milliseconds for waitsFor() blocks.
+ */
+jasmine.DEFAULT_TIMEOUT_INTERVAL = 5000;
+
+jasmine.getGlobal = function() {
+  function getGlobal() {
+    return this;
+  }
+
+  return getGlobal();
+};
+
+/**
+ * Allows for bound functions to be compared.  Internal use only.
+ *
+ * @ignore
+ * @private
+ * @param base {Object} bound 'this' for the function
+ * @param name {Function} function to find
+ */
+jasmine.bindOriginal_ = function(base, name) {
+  var original = base[name];
+  if (original.apply) {
+    return function() {
+      return original.apply(base, arguments);
+    };
+  } else {
+    // IE support
+    return jasmine.getGlobal()[name];
+  }
+};
+
+jasmine.setTimeout = jasmine.bindOriginal_(jasmine.getGlobal(), 'setTimeout');
+jasmine.clearTimeout = jasmine.bindOriginal_(jasmine.getGlobal(), 'clearTimeout');
+jasmine.setInterval = jasmine.bindOriginal_(jasmine.getGlobal(), 'setInterval');
+jasmine.clearInterval = jasmine.bindOriginal_(jasmine.getGlobal(), 'clearInterval');
+
+jasmine.MessageResult = function(values) {
+  this.type = 'log';
+  this.values = values;
+  this.trace = new Error(); // todo: test better
+};
+
+jasmine.MessageResult.prototype.toString = function() {
+  var text = "";
+  for (var i = 0; i < this.values.length; i++) {
+    if (i > 0) text += " ";
+    if (jasmine.isString_(this.values[i])) {
+      text += this.values[i];
+    } else {
+      text += jasmine.pp(this.values[i]);
+    }
+  }
+  return text;
+};
+
+jasmine.ExpectationResult = function(params) {
+  this.type = 'expect';
+  this.matcherName = params.matcherName;
+  this.passed_ = params.passed;
+  this.expected = params.expected;
+  this.actual = params.actual;
+  this.message = this.passed_ ? 'Passed.' : params.message;
+
+  var trace = (params.trace || new Error(this.message));
+  this.trace = this.passed_ ? '' : trace;
+};
+
+jasmine.ExpectationResult.prototype.toString = function () {
+  return this.message;
+};
+
+jasmine.ExpectationResult.prototype.passed = function () {
+  return this.passed_;
+};
+
+/**
+ * Getter for the Jasmine environment. Ensures one gets created
+ */
+jasmine.getEnv = function() {
+  var env = jasmine.currentEnv_ = jasmine.currentEnv_ || new jasmine.Env();
+  return env;
+};
+
+/**
+ * @ignore
+ * @private
+ * @param value
+ * @returns {Boolean}
+ */
+jasmine.isArray_ = function(value) {
+  return jasmine.isA_("Array", value);
+};
+
+/**
+ * @ignore
+ * @private
+ * @param value
+ * @returns {Boolean}
+ */
+jasmine.isString_ = function(value) {
+  return jasmine.isA_("String", value);
+};
+
+/**
+ * @ignore
+ * @private
+ * @param value
+ * @returns {Boolean}
+ */
+jasmine.isNumber_ = function(value) {
+  return jasmine.isA_("Number", value);
+};
+
+/**
+ * @ignore
+ * @private
+ * @param {String} typeName
+ * @param value
+ * @returns {Boolean}
+ */
+jasmine.isA_ = function(typeName, value) {
+  return Object.prototype.toString.apply(value) === '[object ' + typeName + ']';
+};
+
+/**
+ * Pretty printer for expecations.  Takes any object and turns it into a human-readable string.
+ *
+ * @param value {Object} an object to be outputted
+ * @returns {String}
+ */
+jasmine.pp = function(value) {
+  var stringPrettyPrinter = new jasmine.StringPrettyPrinter();
+  stringPrettyPrinter.format(value);
+  return stringPrettyPrinter.string;
+};
+
+/**
+ * Returns true if the object is a DOM Node.
+ *
+ * @param {Object} obj object to check
+ * @returns {Boolean}
+ */
+jasmine.isDomNode = function(obj) {
+  return obj.nodeType > 0;
+};
+
+/**
+ * Returns a matchable 'generic' object of the class type.  For use in expecations of type when values don't matter.
+ *
+ * @example
+ * // don't care about which function is passed in, as long as it's a function
+ * expect(mySpy).toHaveBeenCalledWith(jasmine.any(Function));
+ *
+ * @param {Class} clazz
+ * @returns matchable object of the type clazz
+ */
+jasmine.any = function(clazz) {
+  return new jasmine.Matchers.Any(clazz);
+};
+
+/**
+ * Returns a matchable subset of a JSON object. For use in expectations when you don't care about all of the
+ * attributes on the object.
+ *
+ * @example
+ * // don't care about any other attributes than foo.
+ * expect(mySpy).toHaveBeenCalledWith(jasmine.objectContaining({foo: "bar"});
+ *
+ * @param sample {Object} sample
+ * @returns matchable object for the sample
+ */
+jasmine.objectContaining = function (sample) {
+    return new jasmine.Matchers.ObjectContaining(sample);
+};
+
+/**
+ * Jasmine Spies are test doubles that can act as stubs, spies, fakes or when used in an expecation, mocks.
+ *
+ * Spies should be created in test setup, before expectations.  They can then be checked, using the standard Jasmine
+ * expectation syntax. Spies can be checked if they were called or not and what the calling params were.
+ *
+ * A Spy has the following fields: wasCalled, callCount, mostRecentCall, and argsForCall (see docs).
+ *
+ * Spies are torn down at the end of every spec.
+ *
+ * Note: Do <b>not</b> call new jasmine.Spy() directly - a spy must be created using spyOn, jasmine.createSpy or jasmine.createSpyObj.
+ *
+ * @example
+ * // a stub
+ * var myStub = jasmine.createSpy('myStub');  // can be used anywhere
+ *
+ * // spy example
+ * var foo = {
+ *   not: function(bool) { return !bool; }
+ * }
+ *
+ * // actual foo.not will not be called, execution stops
+ * spyOn(foo, 'not');
+
+ // foo.not spied upon, execution will continue to implementation
+ * spyOn(foo, 'not').andCallThrough();
+ *
+ * // fake example
+ * var foo = {
+ *   not: function(bool) { return !bool; }
+ * }
+ *
+ * // foo.not(val) will return val
+ * spyOn(foo, 'not').andCallFake(function(value) {return value;});
+ *
+ * // mock example
+ * foo.not(7 == 7);
+ * expect(foo.not).toHaveBeenCalled();
+ * expect(foo.not).toHaveBeenCalledWith(true);
+ *
+ * @constructor
+ * @see spyOn, jasmine.createSpy, jasmine.createSpyObj
+ * @param {String} name
+ */
+jasmine.Spy = function(name) {
+  /**
+   * The name of the spy, if provided.
+   */
+  this.identity = name || 'unknown';
+  /**
+   *  Is this Object a spy?
+   */
+  this.isSpy = true;
+  /**
+   * The actual function this spy stubs.
+   */
+  this.plan = function() {
+  };
+  /**
+   * Tracking of the most recent call to the spy.
+   * @example
+   * var mySpy = jasmine.createSpy('foo');
+   * mySpy(1, 2);
+   * mySpy.mostRecentCall.args = [1, 2];
+   */
+  this.mostRecentCall = {};
+
+  /**
+   * Holds arguments for each call to the spy, indexed by call count
+   * @example
+   * var mySpy = jasmine.createSpy('foo');
+   * mySpy(1, 2);
+   * mySpy(7, 8);
+   * mySpy.mostRecentCall.args = [7, 8];
+   * mySpy.argsForCall[0] = [1, 2];
+   * mySpy.argsForCall[1] = [7, 8];
+   */
+  this.argsForCall = [];
+  this.calls = [];
+};
+
+/**
+ * Tells a spy to call through to the actual implemenatation.
+ *
+ * @example
+ * var foo = {
+ *   bar: function() { // do some stuff }
+ * }
+ *
+ * // defining a spy on an existing property: foo.bar
+ * spyOn(foo, 'bar').andCallThrough();
+ */
+jasmine.Spy.prototype.andCallThrough = function() {
+  this.plan = this.originalValue;
+  return this;
+};
+
+/**
+ * For setting the return value of a spy.
+ *
+ * @example
+ * // defining a spy from scratch: foo() returns 'baz'
+ * var foo = jasmine.createSpy('spy on foo').andReturn('baz');
+ *
+ * // defining a spy on an existing property: foo.bar() returns 'baz'
+ * spyOn(foo, 'bar').andReturn('baz');
+ *
+ * @param {Object} value
+ */
+jasmine.Spy.prototype.andReturn = function(value) {
+  this.plan = function() {
+    return value;
+  };
+  return this;
+};
+
+/**
+ * For throwing an exception when a spy is called.
+ *
+ * @example
+ * // defining a spy from scratch: foo() throws an exception w/ message 'ouch'
+ * var foo = jasmine.createSpy('spy on foo').andThrow('baz');
+ *
+ * // defining a spy on an existing property: foo.bar() throws an exception w/ message 'ouch'
+ * spyOn(foo, 'bar').andThrow('baz');
+ *
+ * @param {String} exceptionMsg
+ */
+jasmine.Spy.prototype.andThrow = function(exceptionMsg) {
+  this.plan = function() {
+    throw exceptionMsg;
+  };
+  return this;
+};
+
+/**
+ * Calls an alternate implementation when a spy is called.
+ *
+ * @example
+ * var baz = function() {
+ *   // do some stuff, return something
+ * }
+ * // defining a spy from scratch: foo() calls the function baz
+ * var foo = jasmine.createSpy('spy on foo').andCall(baz);
+ *
+ * // defining a spy on an existing property: foo.bar() calls an anonymnous function
+ * spyOn(foo, 'bar').andCall(function() { return 'baz';} );
+ *
+ * @param {Function} fakeFunc
+ */
+jasmine.Spy.prototype.andCallFake = function(fakeFunc) {
+  this.plan = fakeFunc;
+  return this;
+};
+
+/**
+ * Resets all of a spy's the tracking variables so that it can be used again.
+ *
+ * @example
+ * spyOn(foo, 'bar');
+ *
+ * foo.bar();
+ *
+ * expect(foo.bar.callCount).toEqual(1);
+ *
+ * foo.bar.reset();
+ *
+ * expect(foo.bar.callCount).toEqual(0);
+ */
+jasmine.Spy.prototype.reset = function() {
+  this.wasCalled = false;
+  this.callCount = 0;
+  this.argsForCall = [];
+  this.calls = [];
+  this.mostRecentCall = {};
+};
+
+jasmine.createSpy = function(name) {
+
+  var spyObj = function() {
+    spyObj.wasCalled = true;
+    spyObj.callCount++;
+    var args = jasmine.util.argsToArray(arguments);
+    spyObj.mostRecentCall.object = this;
+    spyObj.mostRecentCall.args = args;
+    spyObj.argsForCall.push(args);
+    spyObj.calls.push({object: this, args: args});
+    return spyObj.plan.apply(this, arguments);
+  };
+
+  var spy = new jasmine.Spy(name);
+
+  for (var prop in spy) {
+    spyObj[prop] = spy[prop];
+  }
+
+  spyObj.reset();
+
+  return spyObj;
+};
+
+/**
+ * Determines whether an object is a spy.
+ *
+ * @param {jasmine.Spy|Object} putativeSpy
+ * @returns {Boolean}
+ */
+jasmine.isSpy = function(putativeSpy) {
+  return putativeSpy && putativeSpy.isSpy;
+};
+
+/**
+ * Creates a more complicated spy: an Object that has every property a function that is a spy.  Used for stubbing something
+ * large in one call.
+ *
+ * @param {String} baseName name of spy class
+ * @param {Array} methodNames array of names of methods to make spies
+ */
+jasmine.createSpyObj = function(baseName, methodNames) {
+  if (!jasmine.isArray_(methodNames) || methodNames.length === 0) {
+    throw new Error('createSpyObj requires a non-empty array of method names to create spies for');
+  }
+  var obj = {};
+  for (var i = 0; i < methodNames.length; i++) {
+    obj[methodNames[i]] = jasmine.createSpy(baseName + '.' + methodNames[i]);
+  }
+  return obj;
+};
+
+/**
+ * All parameters are pretty-printed and concatenated together, then written to the current spec's output.
+ *
+ * Be careful not to leave calls to <code>jasmine.log</code> in production code.
+ */
+jasmine.log = function() {
+  var spec = jasmine.getEnv().currentSpec;
+  spec.log.apply(spec, arguments);
+};
+
+/**
+ * Function that installs a spy on an existing object's method name.  Used within a Spec to create a spy.
+ *
+ * @example
+ * // spy example
+ * var foo = {
+ *   not: function(bool) { return !bool; }
+ * }
+ * spyOn(foo, 'not'); // actual foo.not will not be called, execution stops
+ *
+ * @see jasmine.createSpy
+ * @param obj
+ * @param methodName
+ * @returns a Jasmine spy that can be chained with all spy methods
+ */
+var spyOn = function(obj, methodName) {
+  return jasmine.getEnv().currentSpec.spyOn(obj, methodName);
+};
+if (isCommonJS) exports.spyOn = spyOn;
+
+/**
+ * Creates a Jasmine spec that will be added to the current suite.
+ *
+ * // TODO: pending tests
+ *
+ * @example
+ * it('should be true', function() {
+ *   expect(true).toEqual(true);
+ * });
+ *
+ * @param {String} desc description of this specification
+ * @param {Function} func defines the preconditions and expectations of the spec
+ */
+var it = function(desc, func) {
+  return jasmine.getEnv().it(desc, func);
+};
+if (isCommonJS) exports.it = it;
+
+/**
+ * Creates a <em>disabled</em> Jasmine spec.
+ *
+ * A convenience method that allows existing specs to be disabled temporarily during development.
+ *
+ * @param {String} desc description of this specification
+ * @param {Function} func defines the preconditions and expectations of the spec
+ */
+var xit = function(desc, func) {
+  return jasmine.getEnv().xit(desc, func);
+};
+if (isCommonJS) exports.xit = xit;
+
+/**
+ * Starts a chain for a Jasmine expectation.
+ *
+ * It is passed an Object that is the actual value and should chain to one of the many
+ * jasmine.Matchers functions.
+ *
+ * @param {Object} actual Actual value to test against and expected value
+ */
+var expect = function(actual) {
+  return jasmine.getEnv().currentSpec.expect(actual);
+};
+if (isCommonJS) exports.expect = expect;
+
+/**
+ * Defines part of a jasmine spec.  Used in cominbination with waits or waitsFor in asynchrnous specs.
+ *
+ * @param {Function} func Function that defines part of a jasmine spec.
+ */
+var runs = function(func) {
+  jasmine.getEnv().currentSpec.runs(func);
+};
+if (isCommonJS) exports.runs = runs;
+
+/**
+ * Waits a fixed time period before moving to the next block.
+ *
+ * @deprecated Use waitsFor() instead
+ * @param {Number} timeout milliseconds to wait
+ */
+var waits = function(timeout) {
+  jasmine.getEnv().currentSpec.waits(timeout);
+};
+if (isCommonJS) exports.waits = waits;
+
+/**
+ * Waits for the latchFunction to return true before proceeding to the next block.
+ *
+ * @param {Function} latchFunction
+ * @param {String} optional_timeoutMessage
+ * @param {Number} optional_timeout
+ */
+var waitsFor = function(latchFunction, optional_timeoutMessage, optional_timeout) {
+  jasmine.getEnv().currentSpec.waitsFor.apply(jasmine.getEnv().currentSpec, arguments);
+};
+if (isCommonJS) exports.waitsFor = waitsFor;
+
+/**
+ * A function that is called before each spec in a suite.
+ *
+ * Used for spec setup, including validating assumptions.
+ *
+ * @param {Function} beforeEachFunction
+ */
+var beforeEach = function(beforeEachFunction) {
+  jasmine.getEnv().beforeEach(beforeEachFunction);
+};
+if (isCommonJS) exports.beforeEach = beforeEach;
+
+/**
+ * A function that is called after each spec in a suite.
+ *
+ * Used for restoring any state that is hijacked during spec execution.
+ *
+ * @param {Function} afterEachFunction
+ */
+var afterEach = function(afterEachFunction) {
+  jasmine.getEnv().afterEach(afterEachFunction);
+};
+if (isCommonJS) exports.afterEach = afterEach;
+
+/**
+ * Defines a suite of specifications.
+ *
+ * Stores the description and all defined specs in the Jasmine environment as one suite of specs. Variables declared
+ * are accessible by calls to beforeEach, it, and afterEach. Describe blocks can be nested, allowing for specialization
+ * of setup in some tests.
+ *
+ * @example
+ * // TODO: a simple suite
+ *
+ * // TODO: a simple suite with a nested describe block
+ *
+ * @param {String} description A string, usually the class under test.
+ * @param {Function} specDefinitions function that defines several specs.
+ */
+var describe = function(description, specDefinitions) {
+  return jasmine.getEnv().describe(description, specDefinitions);
+};
+if (isCommonJS) exports.describe = describe;
+
+/**
+ * Disables a suite of specifications.  Used to disable some suites in a file, or files, temporarily during development.
+ *
+ * @param {String} description A string, usually the class under test.
+ * @param {Function} specDefinitions function that defines several specs.
+ */
+var xdescribe = function(description, specDefinitions) {
+  return jasmine.getEnv().xdescribe(description, specDefinitions);
+};
+if (isCommonJS) exports.xdescribe = xdescribe;
+
+
+// Provide the XMLHttpRequest class for IE 5.x-6.x:
+jasmine.XmlHttpRequest = (typeof XMLHttpRequest == "undefined") ? function() {
+  function tryIt(f) {
+    try {
+      return f();
+    } catch(e) {
+    }
+    return null;
+  }
+
+  var xhr = tryIt(function() {
+    return new ActiveXObject("Msxml2.XMLHTTP.6.0");
+  }) ||
+    tryIt(function() {
+      return new ActiveXObject("Msxml2.XMLHTTP.3.0");
+    }) ||
+    tryIt(function() {
+      return new ActiveXObject("Msxml2.XMLHTTP");
+    }) ||
+    tryIt(function() {
+      return new ActiveXObject("Microsoft.XMLHTTP");
+    });
+
+  if (!xhr) throw new Error("This browser does not support XMLHttpRequest.");
+
+  return xhr;
+} : XMLHttpRequest;
+/**
+ * @namespace
+ */
+jasmine.util = {};
+
+/**
+ * Declare that a child class inherit it's prototype from the parent class.
+ *
+ * @private
+ * @param {Function} childClass
+ * @param {Function} parentClass
+ */
+jasmine.util.inherit = function(childClass, parentClass) {
+  /**
+   * @private
+   */
+  var subclass = function() {
+  };
+  subclass.prototype = parentClass.prototype;
+  childClass.prototype = new subclass();
+};
+
+jasmine.util.formatException = function(e) {
+  var lineNumber;
+  if (e.line) {
+    lineNumber = e.line;
+  }
+  else if (e.lineNumber) {
+    lineNumber = e.lineNumber;
+  }
+
+  var file;
+
+  if (e.sourceURL) {
+    file = e.sourceURL;
+  }
+  else if (e.fileName) {
+    file = e.fileName;
+  }
+
+  var message = (e.name && e.message) ? (e.name + ': ' + e.message) : e.toString();
+
+  if (file && lineNumber) {
+    message += ' in ' + file + ' (line ' + lineNumber + ')';
+  }
+
+  return message;
+};
+
+jasmine.util.htmlEscape = function(str) {
+  if (!str) return str;
+  return str.replace(/&/g, '&amp;')
+    .replace(/</g, '&lt;')
+    .replace(/>/g, '&gt;');
+};
+
+jasmine.util.argsToArray = function(args) {
+  var arrayOfArgs = [];
+  for (var i = 0; i < args.length; i++) arrayOfArgs.push(args[i]);
+  return arrayOfArgs;
+};
+
+jasmine.util.extend = function(destination, source) {
+  for (var property in source) destination[property] = source[property];
+  return destination;
+};
+
+/**
+ * Environment for Jasmine
+ *
+ * @constructor
+ */
+jasmine.Env = function() {
+  this.currentSpec = null;
+  this.currentSuite = null;
+  this.currentRunner_ = new jasmine.Runner(this);
+
+  this.reporter = new jasmine.MultiReporter();
+
+  this.updateInterval = jasmine.DEFAULT_UPDATE_INTERVAL;
+  this.defaultTimeoutInterval = jasmine.DEFAULT_TIMEOUT_INTERVAL;
+  this.lastUpdate = 0;
+  this.specFilter = function() {
+    return true;
+  };
+
+  this.nextSpecId_ = 0;
+  this.nextSuiteId_ = 0;
+  this.equalityTesters_ = [];
+
+  // wrap matchers
+  this.matchersClass = function() {
+    jasmine.Matchers.apply(this, arguments);
+  };
+  jasmine.util.inherit(this.matchersClass, jasmine.Matchers);
+
+  jasmine.Matchers.wrapInto_(jasmine.Matchers.prototype, this.matchersClass);
+};
+
+
+jasmine.Env.prototype.setTimeout = jasmine.setTimeout;
+jasmine.Env.prototype.clearTimeout = jasmine.clearTimeout;
+jasmine.Env.prototype.setInterval = jasmine.setInterval;
+jasmine.Env.prototype.clearInterval = jasmine.clearInterval;
+
+/**
+ * @returns an object containing jasmine version build info, if set.
+ */
+jasmine.Env.prototype.version = function () {
+  if (jasmine.version_) {
+    return jasmine.version_;
+  } else {
+    throw new Error('Version not set');
+  }
+};
+
+/**
+ * @returns string containing jasmine version build info, if set.
+ */
+jasmine.Env.prototype.versionString = function() {
+  if (!jasmine.version_) {
+    return "version unknown";
+  }
+
+  var version = this.version();
+  var versionString = version.major + "." + version.minor + "." + version.build;
+  if (version.release_candidate) {
+    versionString += ".rc" + version.release_candidate;
+  }
+  versionString += " revision " + version.revision;
+  return versionString;
+};
+
+/**
+ * @returns a sequential integer starting at 0
+ */
+jasmine.Env.prototype.nextSpecId = function () {
+  return this.nextSpecId_++;
+};
+
+/**
+ * @returns a sequential integer starting at 0
+ */
+jasmine.Env.prototype.nextSuiteId = function () {
+  return this.nextSuiteId_++;
+};
+
+/**
+ * Register a reporter to receive status updates from Jasmine.
+ * @param {jasmine.Reporter} reporter An object which will receive status updates.
+ */
+jasmine.Env.prototype.addReporter = function(reporter) {
+  this.reporter.addReporter(reporter);
+};
+
+jasmine.Env.prototype.execute = function() {
+  this.currentRunner_.execute();
+};
+
+jasmine.Env.prototype.describe = function(description, specDefinitions) {
+  var suite = new jasmine.Suite(this, description, specDefinitions, this.currentSuite);
+
+  var parentSuite = this.currentSuite;
+  if (parentSuite) {
+    parentSuite.add(suite);
+  } else {
+    this.currentRunner_.add(suite);
+  }
+
+  this.currentSuite = suite;
+
+  var declarationError = null;
+  try {
+    specDefinitions.call(suite);
+  } catch(e) {
+    declarationError = e;
+  }
+
+  if (declarationError) {
+    this.it("encountered a declaration exception", function() {
+      throw declarationError;
+    });
+  }
+
+  this.currentSuite = parentSuite;
+
+  return suite;
+};
+
+jasmine.Env.prototype.beforeEach = function(beforeEachFunction) {
+  if (this.currentSuite) {
+    this.currentSuite.beforeEach(beforeEachFunction);
+  } else {
+    this.currentRunner_.beforeEach(beforeEachFunction);
+  }
+};
+
+jasmine.Env.prototype.currentRunner = function () {
+  return this.currentRunner_;
+};
+
+jasmine.Env.prototype.afterEach = function(afterEachFunction) {
+  if (this.currentSuite) {
+    this.currentSuite.afterEach(afterEachFunction);
+  } else {
+    this.currentRunner_.afterEach(afterEachFunction);
+  }
+
+};
+
+jasmine.Env.prototype.xdescribe = function(desc, specDefinitions) {
+  return {
+    execute: function() {
+    }
+  };
+};
+
+jasmine.Env.prototype.it = function(description, func) {
+  var spec = new jasmine.Spec(this, this.currentSuite, description);
+  this.currentSuite.add(spec);
+  this.currentSpec = spec;
+
+  if (func) {
+    spec.runs(func);
+  }
+
+  return spec;
+};
+
+jasmine.Env.prototype.xit = function(desc, func) {
+  return {
+    id: this.nextSpecId(),
+    runs: function() {
+    }
+  };
+};
+
+jasmine.Env.prototype.compareObjects_ = function(a, b, mismatchKeys, mismatchValues) {
+  if (a.__Jasmine_been_here_before__ === b && b.__Jasmine_been_here_before__ === a) {
+    return true;
+  }
+
+  a.__Jasmine_been_here_before__ = b;
+  b.__Jasmine_been_here_before__ = a;
+
+  var hasKey = function(obj, keyName) {
+    return obj !== null && obj[keyName] !== jasmine.undefined;
+  };
+
+  for (var property in b) {
+    if (!hasKey(a, property) && hasKey(b, property)) {
+      mismatchKeys.push("expected has key '" + property + "', but missing from actual.");
+    }
+  }
+  for (property in a) {
+    if (!hasKey(b, property) && hasKey(a, property)) {
+      mismatchKeys.push("expected missing key '" + property + "', but present in actual.");
+    }
+  }
+  for (property in b) {
+    if (property == '__Jasmine_been_here_before__') continue;
+    if (!this.equals_(a[property], b[property], mismatchKeys, mismatchValues)) {
+      mismatchValues.push("'" + property + "' was '" + (b[property] ? jasmine.util.htmlEscape(b[property].toString()) : b[property]) + "' in expected, but was '" + (a[property] ? jasmine.util.htmlEscape(a[property].toString()) : a[property]) + "' in actual.");
+    }
+  }
+
+  if (jasmine.isArray_(a) && jasmine.isArray_(b) && a.length != b.length) {
+    mismatchValues.push("arrays were not the same length");
+  }
+
+  delete a.__Jasmine_been_here_before__;
+  delete b.__Jasmine_been_here_before__;
+  return (mismatchKeys.length === 0 && mismatchValues.length === 0);
+};
+
+jasmine.Env.prototype.equals_ = function(a, b, mismatchKeys, mismatchValues) {
+  mismatchKeys = mismatchKeys || [];
+  mismatchValues = mismatchValues || [];
+
+  for (var i = 0; i < this.equalityTesters_.length; i++) {
+    var equalityTester = this.equalityTesters_[i];
+    var result = equalityTester(a, b, this, mismatchKeys, mismatchValues);
+    if (result !== jasmine.undefined) return result;
+  }
+
+  if (a === b) return true;
+
+  if (a === jasmine.undefined || a === null || b === jasmine.undefined || b === null) {
+    return (a == jasmine.undefined && b == jasmine.undefined);
+  }
+
+  if (jasmine.isDomNode(a) && jasmine.isDomNode(b)) {
+    return a === b;
+  }
+
+  if (a instanceof Date && b instanceof Date) {
+    return a.getTime() == b.getTime();
+  }
+
+  if (a.jasmineMatches) {
+    return a.jasmineMatches(b);
+  }
+
+  if (b.jasmineMatches) {
+    return b.jasmineMatches(a);
+  }
+
+  if (a instanceof jasmine.Matchers.ObjectContaining) {
+    return a.matches(b);
+  }
+
+  if (b instanceof jasmine.Matchers.ObjectContaining) {
+    return b.matches(a);
+  }
+
+  if (jasmine.isString_(a) && jasmine.isString_(b)) {
+    return (a == b);
+  }
+
+  if (jasmine.isNumber_(a) && jasmine.isNumber_(b)) {
+    return (a == b);
+  }
+
+  if (typeof a === "object" && typeof b === "object") {
+    return this.compareObjects_(a, b, mismatchKeys, mismatchValues);
+  }
+
+  //Straight check
+  return (a === b);
+};
+
+jasmine.Env.prototype.contains_ = function(haystack, needle) {
+  if (jasmine.isArray_(haystack)) {
+    for (var i = 0; i < haystack.length; i++) {
+      if (this.equals_(haystack[i], needle)) return true;
+    }
+    return false;
+  }
+  return haystack.indexOf(needle) >= 0;
+};
+
+jasmine.Env.prototype.addEqualityTester = function(equalityTester) {
+  this.equalityTesters_.push(equalityTester);
+};
+/** No-op base class for Jasmine reporters.
+ *
+ * @constructor
+ */
+jasmine.Reporter = function() {
+};
+
+//noinspection JSUnusedLocalSymbols
+jasmine.Reporter.prototype.reportRunnerStarting = function(runner) {
+};
+
+//noinspection JSUnusedLocalSymbols
+jasmine.Reporter.prototype.reportRunnerResults = function(runner) {
+};
+
+//noinspection JSUnusedLocalSymbols
+jasmine.Reporter.prototype.reportSuiteResults = function(suite) {
+};
+
+//noinspection JSUnusedLocalSymbols
+jasmine.Reporter.prototype.reportSpecStarting = function(spec) {
+};
+
+//noinspection JSUnusedLocalSymbols
+jasmine.Reporter.prototype.reportSpecResults = function(spec) {
+};
+
+//noinspection JSUnusedLocalSymbols
+jasmine.Reporter.prototype.log = function(str) {
+};
+
+/**
+ * Blocks are functions with executable code that make up a spec.
+ *
+ * @constructor
+ * @param {jasmine.Env} env
+ * @param {Function} func
+ * @param {jasmine.Spec} spec
+ */
+jasmine.Block = function(env, func, spec) {
+  this.env = env;
+  this.func = func;
+  this.spec = spec;
+};
+
+jasmine.Block.prototype.execute = function(onComplete) {
+  try {
+    this.func.apply(this.spec);
+  } catch (e) {
+    this.spec.fail(e);
+  }
+  onComplete();
+};
+/** JavaScript API reporter.
+ *
+ * @constructor
+ */
+jasmine.JsApiReporter = function() {
+  this.started = false;
+  this.finished = false;
+  this.suites_ = [];
+  this.results_ = {};
+};
+
+jasmine.JsApiReporter.prototype.reportRunnerStarting = function(runner) {
+  this.started = true;
+  var suites = runner.topLevelSuites();
+  for (var i = 0; i < suites.length; i++) {
+    var suite = suites[i];
+    this.suites_.push(this.summarize_(suite));
+  }
+};
+
+jasmine.JsApiReporter.prototype.suites = function() {
+  return this.suites_;
+};
+
+jasmine.JsApiReporter.prototype.summarize_ = function(suiteOrSpec) {
+  var isSuite = suiteOrSpec instanceof jasmine.Suite;
+  var summary = {
+    id: suiteOrSpec.id,
+    name: suiteOrSpec.description,
+    type: isSuite ? 'suite' : 'spec',
+    children: []
+  };
+
+  if (isSuite) {
+    var children = suiteOrSpec.children();
+    for (var i = 0; i < children.length; i++) {
+      summary.children.push(this.summarize_(children[i]));
+    }
+  }
+  return summary;
+};
+
+jasmine.JsApiReporter.prototype.results = function() {
+  return this.results_;
+};
+
+jasmine.JsApiReporter.prototype.resultsForSpec = function(specId) {
+  return this.results_[specId];
+};
+
+//noinspection JSUnusedLocalSymbols
+jasmine.JsApiReporter.prototype.reportRunnerResults = function(runner) {
+  this.finished = true;
+};
+
+//noinspection JSUnusedLocalSymbols
+jasmine.JsApiReporter.prototype.reportSuiteResults = function(suite) {
+};
+
+//noinspection JSUnusedLocalSymbols
+jasmine.JsApiReporter.prototype.reportSpecResults = function(spec) {
+  this.results_[spec.id] = {
+    messages: spec.results().getItems(),
+    result: spec.results().failedCount > 0 ? "failed" : "passed"
+  };
+};
+
+//noinspection JSUnusedLocalSymbols
+jasmine.JsApiReporter.prototype.log = function(str) {
+};
+
+jasmine.JsApiReporter.prototype.resultsForSpecs = function(specIds){
+  var results = {};
+  for (var i = 0; i < specIds.length; i++) {
+    var specId = specIds[i];
+    results[specId] = this.summarizeResult_(this.results_[specId]);
+  }
+  return results;
+};
+
+jasmine.JsApiReporter.prototype.summarizeResult_ = function(result){
+  var summaryMessages = [];
+  var messagesLength = result.messages.length;
+  for (var messageIndex = 0; messageIndex < messagesLength; messageIndex++) {
+    var resultMessage = result.messages[messageIndex];
+    summaryMessages.push({
+      text: resultMessage.type == 'log' ? resultMessage.toString() : jasmine.undefined,
+      passed: resultMessage.passed ? resultMessage.passed() : true,
+      type: resultMessage.type,
+      message: resultMessage.message,
+      trace: {
+        stack: resultMessage.passed && !resultMessage.passed() ? resultMessage.trace.stack : jasmine.undefined
+      }
+    });
+  }
+
+  return {
+    result : result.result,
+    messages : summaryMessages
+  };
+};
+
+/**
+ * @constructor
+ * @param {jasmine.Env} env
+ * @param actual
+ * @param {jasmine.Spec} spec
+ */
+jasmine.Matchers = function(env, actual, spec, opt_isNot) {
+  this.env = env;
+  this.actual = actual;
+  this.spec = spec;
+  this.isNot = opt_isNot || false;
+  this.reportWasCalled_ = false;
+};
+
+// todo: @deprecated as of Jasmine 0.11, remove soon [xw]
+jasmine.Matchers.pp = function(str) {
+  throw new Error("jasmine.Matchers.pp() is no longer supported, please use jasmine.pp() instead!");
+};
+
+// todo: @deprecated Deprecated as of Jasmine 0.10. Rewrite your custom matchers to return true or false. [xw]
+jasmine.Matchers.prototype.report = function(result, failing_message, details) {
+  throw new Error("As of jasmine 0.11, custom matchers must be implemented differently -- please see jasmine docs");
+};
+
+jasmine.Matchers.wrapInto_ = function(prototype, matchersClass) {
+  for (var methodName in prototype) {
+    if (methodName == 'report') continue;
+    var orig = prototype[methodName];
+    matchersClass.prototype[methodName] = jasmine.Matchers.matcherFn_(methodName, orig);
+  }
+};
+
+jasmine.Matchers.matcherFn_ = function(matcherName, matcherFunction) {
+  return function() {
+    var matcherArgs = jasmine.util.argsToArray(arguments);
+    var result = matcherFunction.apply(this, arguments);
+
+    if (this.isNot) {
+      result = !result;
+    }
+
+    if (this.reportWasCalled_) return result;
+
+    var message;
+    if (!result) {
+      if (this.message) {
+        message = this.message.apply(this, arguments);
+        if (jasmine.isArray_(message)) {
+          message = message[this.isNot ? 1 : 0];
+        }
+      } else {
+        var englishyPredicate = matcherName.replace(/[A-Z]/g, function(s) { return ' ' + s.toLowerCase(); });
+        message = "Expected " + jasmine.pp(this.actual) + (this.isNot ? " not " : " ") + englishyPredicate;
+        if (matcherArgs.length > 0) {
+          for (var i = 0; i < matcherArgs.length; i++) {
+            if (i > 0) message += ",";
+            message += " " + jasmine.pp(matcherArgs[i]);
+          }
+        }
+        message += ".";
+      }
+    }
+    var expectationResult = new jasmine.ExpectationResult({
+      matcherName: matcherName,
+      passed: result,
+      expected: matcherArgs.length > 1 ? matcherArgs : matcherArgs[0],
+      actual: this.actual,
+      message: message
+    });
+    this.spec.addMatcherResult(expectationResult);
+    return jasmine.undefined;
+  };
+};
+
+
+
+
+/**
+ * toBe: compares the actual to the expected using ===
+ * @param expected
+ */
+jasmine.Matchers.prototype.toBe = function(expected) {
+  return this.actual === expected;
+};
+
+/**
+ * toNotBe: compares the actual to the expected using !==
+ * @param expected
+ * @deprecated as of 1.0. Use not.toBe() instead.
+ */
+jasmine.Matchers.prototype.toNotBe = function(expected) {
+  return this.actual !== expected;
+};
+
+/**
+ * toEqual: compares the actual to the expected using common sense equality. Handles Objects, Arrays, etc.
+ *
+ * @param expected
+ */
+jasmine.Matchers.prototype.toEqual = function(expected) {
+  return this.env.equals_(this.actual, expected);
+};
+
+/**
+ * toNotEqual: compares the actual to the expected using the ! of jasmine.Matchers.toEqual
+ * @param expected
+ * @deprecated as of 1.0. Use not.toEqual() instead.
+ */
+jasmine.Matchers.prototype.toNotEqual = function(expected) {
+  return !this.env.equals_(this.actual, expected);
+};
+
+/**
+ * Matcher that compares the actual to the expected using a regular expression.  Constructs a RegExp, so takes
+ * a pattern or a String.
+ *
+ * @param expected
+ */
+jasmine.Matchers.prototype.toMatch = function(expected) {
+  return new RegExp(expected).test(this.actual);
+};
+
+/**
+ * Matcher that compares the actual to the expected using the boolean inverse of jasmine.Matchers.toMatch
+ * @param expected
+ * @deprecated as of 1.0. Use not.toMatch() instead.
+ */
+jasmine.Matchers.prototype.toNotMatch = function(expected) {
+  return !(new RegExp(expected).test(this.actual));
+};
+
+/**
+ * Matcher that compares the actual to jasmine.undefined.
+ */
+jasmine.Matchers.prototype.toBeDefined = function() {
+  return (this.actual !== jasmine.undefined);
+};
+
+/**
+ * Matcher that compares the actual to jasmine.undefined.
+ */
+jasmine.Matchers.prototype.toBeUndefined = function() {
+  return (this.actual === jasmine.undefined);
+};
+
+/**
+ * Matcher that compares the actual to null.
+ */
+jasmine.Matchers.prototype.toBeNull = function() {
+  return (this.actual === null);
+};
+
+/**
+ * Matcher that boolean not-nots the actual.
+ */
+jasmine.Matchers.prototype.toBeTruthy = function() {
+  return !!this.actual;
+};
+
+
+/**
+ * Matcher that boolean nots the actual.
+ */
+jasmine.Matchers.prototype.toBeFalsy = function() {
+  return !this.actual;
+};
+
+
+/**
+ * Matcher that checks to see if the actual, a Jasmine spy, was called.
+ */
+jasmine.Matchers.prototype.toHaveBeenCalled = function() {
+  if (arguments.length > 0) {
+    throw new Error('toHaveBeenCalled does not take arguments, use toHaveBeenCalledWith');
+  }
+
+  if (!jasmine.isSpy(this.actual)) {
+    throw new Error('Expected a spy, but got ' + jasmine.pp(this.actual) + '.');
+  }
+
+  this.message = function() {
+    return [
+      "Expected spy " + this.actual.identity + " to have been called.",
+      "Expected spy " + this.actual.identity + " not to have been called."
+    ];
+  };
+
+  return this.actual.wasCalled;
+};
+
+/** @deprecated Use expect(xxx).toHaveBeenCalled() instead */
+jasmine.Matchers.prototype.wasCalled = jasmine.Matchers.prototype.toHaveBeenCalled;
+
+/**
+ * Matcher that checks to see if the actual, a Jasmine spy, was not called.
+ *
+ * @deprecated Use expect(xxx).not.toHaveBeenCalled() instead
+ */
+jasmine.Matchers.prototype.wasNotCalled = function() {
+  if (arguments.length > 0) {
+    throw new Error('wasNotCalled does not take arguments');
+  }
+
+  if (!jasmine.isSpy(this.actual)) {
+    throw new Error('Expected a spy, but got ' + jasmine.pp(this.actual) + '.');
+  }
+
+  this.message = function() {
+    return [
+      "Expected spy " + this.actual.identity + " to not have been called.",
+      "Expected spy " + this.actual.identity + " to have been called."
+    ];
+  };
+
+  return !this.actual.wasCalled;
+};
+
+/**
+ * Matcher that checks to see if the actual, a Jasmine spy, was called with a set of parameters.
+ *
+ * @example
+ *
+ */
+jasmine.Matchers.prototype.toHaveBeenCalledWith = function() {
+  var expectedArgs = jasmine.util.argsToArray(arguments);
+  if (!jasmine.isSpy(this.actual)) {
+    throw new Error('Expected a spy, but got ' + jasmine.pp(this.actual) + '.');
+  }
+  this.message = function() {
+    if (this.actual.callCount === 0) {
+      // todo: what should the failure message for .not.toHaveBeenCalledWith() be? is this right? test better. [xw]
+      return [
+        "Expected spy " + this.actual.identity + " to have been called with " + jasmine.pp(expectedArgs) + " but it was never called.",
+        "Expected spy " + this.actual.identity + " not to have been called with " + jasmine.pp(expectedArgs) + " but it was."
+      ];
+    } else {
+      return [
+        "Expected spy " + this.actual.identity + " to have been called with " + jasmine.pp(expectedArgs) + " but was called with " + jasmine.pp(this.actual.argsForCall),
+        "Expected spy " + this.actual.identity + " not to have been called with " + jasmine.pp(expectedArgs) + " but was called with " + jasmine.pp(this.actual.argsForCall)
+      ];
+    }
+  };
+
+  return this.env.contains_(this.actual.argsForCall, expectedArgs);
+};
+
+/** @deprecated Use expect(xxx).toHaveBeenCalledWith() instead */
+jasmine.Matchers.prototype.wasCalledWith = jasmine.Matchers.prototype.toHaveBeenCalledWith;
+
+/** @deprecated Use expect(xxx).not.toHaveBeenCalledWith() instead */
+jasmine.Matchers.prototype.wasNotCalledWith = function() {
+  var expectedArgs = jasmine.util.argsToArray(arguments);
+  if (!jasmine.isSpy(this.actual)) {
+    throw new Error('Expected a spy, but got ' + jasmine.pp(this.actual) + '.');
+  }
+
+  this.message = function() {
+    return [
+      "Expected spy not to have been called with " + jasmine.pp(expectedArgs) + " but it was",
+      "Expected spy to have been called with " + jasmine.pp(expectedArgs) + " but it was"
+    ];
+  };
+
+  return !this.env.contains_(this.actual.argsForCall, expectedArgs);
+};
+
+/**
+ * Matcher that checks that the expected item is an element in the actual Array.
+ *
+ * @param {Object} expected
+ */
+jasmine.Matchers.prototype.toContain = function(expected) {
+  return this.env.contains_(this.actual, expected);
+};
+
+/**
+ * Matcher that checks that the expected item is NOT an element in the actual Array.
+ *
+ * @param {Object} expected
+ * @deprecated as of 1.0. Use not.toContain() instead.
+ */
+jasmine.Matchers.prototype.toNotContain = function(expected) {
+  return !this.env.contains_(this.actual, expected);
+};
+
+jasmine.Matchers.prototype.toBeLessThan = function(expected) {
+  return this.actual < expected;
+};
+
+jasmine.Matchers.prototype.toBeGreaterThan = function(expected) {
+  return this.actual > expected;
+};
+
+/**
+ * Matcher that checks that the expected item is equal to the actual item
+ * up to a given level of decimal precision (default 2).
+ *
+ * @param {Number} expected
+ * @param {Number} precision
+ */
+jasmine.Matchers.prototype.toBeCloseTo = function(expected, precision) {
+  if (!(precision === 0)) {
+    precision = precision || 2;
+  }
+  var multiplier = Math.pow(10, precision);
+  var actual = Math.round(this.actual * multiplier);
+  expected = Math.round(expected * multiplier);
+  return expected == actual;
+};
+
+/**
+ * Matcher that checks that the expected exception was thrown by the actual.
+ *
+ * @param {String} expected
+ */
+jasmine.Matchers.prototype.toThrow = function(expected) {
+  var result = false;
+  var exception;
+  if (typeof this.actual != 'function') {
+    throw new Error('Actual is not a function');
+  }
+  try {
+    this.actual();
+  } catch (e) {
+    exception = e;
+  }
+  if (exception) {
+    result = (expected === jasmine.undefined || this.env.equals_(exception.message || exception, expected.message || expected));
+  }
+
+  var not = this.isNot ? "not " : "";
+
+  this.message = function() {
+    if (exception && (expected === jasmine.undefined || !this.env.equals_(exception.message || exception, expected.message || expected))) {
+      return ["Expected function " + not + "to throw", expected ? expected.message || expected : "an exception", ", but it threw", exception.message || exception].join(' ');
+    } else {
+      return "Expected function to throw an exception.";
+    }
+  };
+
+  return result;
+};
+
+jasmine.Matchers.Any = function(expectedClass) {
+  this.expectedClass = expectedClass;
+};
+
+jasmine.Matchers.Any.prototype.jasmineMatches = function(other) {
+  if (this.expectedClass == String) {
+    return typeof other == 'string' || other instanceof String;
+  }
+
+  if (this.expectedClass == Number) {
+    return typeof other == 'number' || other instanceof Number;
+  }
+
+  if (this.expectedClass == Function) {
+    return typeof other == 'function' || other instanceof Function;
+  }
+
+  if (this.expectedClass == Object) {
+    return typeof other == 'object';
+  }
+
+  return other instanceof this.expectedClass;
+};
+
+jasmine.Matchers.Any.prototype.jasmineToString = function() {
+  return '<jasmine.any(' + this.expectedClass + ')>';
+};
+
+jasmine.Matchers.ObjectContaining = function (sample) {
+  this.sample = sample;
+};
+
+jasmine.Matchers.ObjectContaining.prototype.jasmineMatches = function(other, mismatchKeys, mismatchValues) {
+  mismatchKeys = mismatchKeys || [];
+  mismatchValues = mismatchValues || [];
+
+  var env = jasmine.getEnv();
+
+  var hasKey = function(obj, keyName) {
+    return obj != null && obj[keyName] !== jasmine.undefined;
+  };
+
+  for (var property in this.sample) {
+    if (!hasKey(other, property) && hasKey(this.sample, property)) {
+      mismatchKeys.push("expected has key '" + property + "', but missing from actual.");
+    }
+    else if (!env.equals_(this.sample[property], other[property], mismatchKeys, mismatchValues)) {
+      mismatchValues.push("'" + property + "' was '" + (other[property] ? jasmine.util.htmlEscape(other[property].toString()) : other[property]) + "' in expected, but was '" + (this.sample[property] ? jasmine.util.htmlEscape(this.sample[property].toString()) : this.sample[property]) + "' in actual.");
+    }
+  }
+
+  return (mismatchKeys.length === 0 && mismatchValues.length === 0);
+};
+
+jasmine.Matchers.ObjectContaining.prototype.jasmineToString = function () {
+  return "<jasmine.objectContaining(" + jasmine.pp(this.sample) + ")>";
+};
+// Mock setTimeout, clearTimeout
+// Contributed by Pivotal Computer Systems, www.pivotalsf.com
+
+jasmine.FakeTimer = function() {
+  this.reset();
+
+  var self = this;
+  self.setTimeout = function(funcToCall, millis) {
+    self.timeoutsMade++;
+    self.scheduleFunction(self.timeoutsMade, funcToCall, millis, false);
+    return self.timeoutsMade;
+  };
+
+  self.setInterval = function(funcToCall, millis) {
+    self.timeoutsMade++;
+    self.scheduleFunction(self.timeoutsMade, funcToCall, millis, true);
+    return self.timeoutsMade;
+  };
+
+  self.clearTimeout = function(timeoutKey) {
+    self.scheduledFunctions[timeoutKey] = jasmine.undefined;
+  };
+
+  self.clearInterval = function(timeoutKey) {
+    self.scheduledFunctions[timeoutKey] = jasmine.undefined;
+  };
+
+};
+
+jasmine.FakeTimer.prototype.reset = function() {
+  this.timeoutsMade = 0;
+  this.scheduledFunctions = {};
+  this.nowMillis = 0;
+};
+
+jasmine.FakeTimer.prototype.tick = function(millis) {
+  var oldMillis = this.nowMillis;
+  var newMillis = oldMillis + millis;
+  this.runFunctionsWithinRange(oldMillis, newMillis);
+  this.nowMillis = newMillis;
+};
+
+jasmine.FakeTimer.prototype.runFunctionsWithinRange = function(oldMillis, nowMillis) {
+  var scheduledFunc;
+  var funcsToRun = [];
+  for (var timeoutKey in this.scheduledFunctions) {
+    scheduledFunc = this.scheduledFunctions[timeoutKey];
+    if (scheduledFunc != jasmine.undefined &&
+        scheduledFunc.runAtMillis >= oldMillis &&
+        scheduledFunc.runAtMillis <= nowMillis) {
+      funcsToRun.push(scheduledFunc);
+      this.scheduledFunctions[timeoutKey] = jasmine.undefined;
+    }
+  }
+
+  if (funcsToRun.length > 0) {
+    funcsToRun.sort(function(a, b) {
+      return a.runAtMillis - b.runAtMillis;
+    });
+    for (var i = 0; i < funcsToRun.length; ++i) {
+      try {
+        var funcToRun = funcsToRun[i];
+        this.nowMillis = funcToRun.runAtMillis;
+        funcToRun.funcToCall();
+        if (funcToRun.recurring) {
+          this.scheduleFunction(funcToRun.timeoutKey,
+              funcToRun.funcToCall,
+              funcToRun.millis,
+              true);
+        }
+      } catch(e) {
+      }
+    }
+    this.runFunctionsWithinRange(oldMillis, nowMillis);
+  }
+};
+
+jasmine.FakeTimer.prototype.scheduleFunction = function(timeoutKey, funcToCall, millis, recurring) {
+  this.scheduledFunctions[timeoutKey] = {
+    runAtMillis: this.nowMillis + millis,
+    funcToCall: funcToCall,
+    recurring: recurring,
+    timeoutKey: timeoutKey,
+    millis: millis
+  };
+};
+
+/**
+ * @namespace
+ */
+jasmine.Clock = {
+  defaultFakeTimer: new jasmine.FakeTimer(),
+
+  reset: function() {
+    jasmine.Clock.assertInstalled();
+    jasmine.Clock.defaultFakeTimer.reset();
+  },
+
+  tick: function(millis) {
+    jasmine.Clock.assertInstalled();
+    jasmine.Clock.defaultFakeTimer.tick(millis);
+  },
+
+  runFunctionsWithinRange: function(oldMillis, nowMillis) {
+    jasmine.Clock.defaultFakeTimer.runFunctionsWithinRange(oldMillis, nowMillis);
+  },
+
+  scheduleFunction: function(timeoutKey, funcToCall, millis, recurring) {
+    jasmine.Clock.defaultFakeTimer.scheduleFunction(timeoutKey, funcToCall, millis, recurring);
+  },
+
+  useMock: function() {
+    if (!jasmine.Clock.isInstalled()) {
+      var spec = jasmine.getEnv().currentSpec;
+      spec.after(jasmine.Clock.uninstallMock);
+
+      jasmine.Clock.installMock();
+    }
+  },
+
+  installMock: function() {
+    jasmine.Clock.installed = jasmine.Clock.defaultFakeTimer;
+  },
+
+  uninstallMock: function() {
+    jasmine.Clock.assertInstalled();
+    jasmine.Clock.installed = jasmine.Clock.real;
+  },
+
+  real: {
+    setTimeout: jasmine.getGlobal().setTimeout,
+    clearTimeout: jasmine.getGlobal().clearTimeout,
+    setInterval: jasmine.getGlobal().setInterval,
+    clearInterval: jasmine.getGlobal().clearInterval
+  },
+
+  assertInstalled: function() {
+    if (!jasmine.Clock.isInstalled()) {
+      throw new Error("Mock clock is not installed, use jasmine.Clock.useMock()");
+    }
+  },
+
+  isInstalled: function() {
+    return jasmine.Clock.installed == jasmine.Clock.defaultFakeTimer;
+  },
+
+  installed: null
+};
+jasmine.Clock.installed = jasmine.Clock.real;
+
+//else for IE support
+jasmine.getGlobal().setTimeout = function(funcToCall, millis) {
+  if (jasmine.Clock.installed.setTimeout.apply) {
+    return jasmine.Clock.installed.setTimeout.apply(this, arguments);
+  } else {
+    return jasmine.Clock.installed.setTimeout(funcToCall, millis);
+  }
+};
+
+jasmine.getGlobal().setInterval = function(funcToCall, millis) {
+  if (jasmine.Clock.installed.setInterval.apply) {
+    return jasmine.Clock.installed.setInterval.apply(this, arguments);
+  } else {
+    return jasmine.Clock.installed.setInterval(funcToCall, millis);
+  }
+};
+
+jasmine.getGlobal().clearTimeout = function(timeoutKey) {
+  if (jasmine.Clock.installed.clearTimeout.apply) {
+    return jasmine.Clock.installed.clearTimeout.apply(this, arguments);
+  } else {
+    return jasmine.Clock.installed.clearTimeout(timeoutKey);
+  }
+};
+
+jasmine.getGlobal().clearInterval = function(timeoutKey) {
+  if (jasmine.Clock.installed.clearTimeout.apply) {
+    return jasmine.Clock.installed.clearInterval.apply(this, arguments);
+  } else {
+    return jasmine.Clock.installed.clearInterval(timeoutKey);
+  }
+};
+
+/**
+ * @constructor
+ */
+jasmine.MultiReporter = function() {
+  this.subReporters_ = [];
+};
+jasmine.util.inherit(jasmine.MultiReporter, jasmine.Reporter);
+
+jasmine.MultiReporter.prototype.addReporter = function(reporter) {
+  this.subReporters_.push(reporter);
+};
+
+(function() {
+  var functionNames = [
+    "reportRunnerStarting",
+    "reportRunnerResults",
+    "reportSuiteResults",
+    "reportSpecStarting",
+    "reportSpecResults",
+    "log"
+  ];
+  for (var i = 0; i < functionNames.length; i++) {
+    var functionName = functionNames[i];
+    jasmine.MultiReporter.prototype[functionName] = (function(functionName) {
+      return function() {
+        for (var j = 0; j < this.subReporters_.length; j++) {
+          var subReporter = this.subReporters_[j];
+          if (subReporter[functionName]) {
+            subReporter[functionName].apply(subReporter, arguments);
+          }
+        }
+      };
+    })(functionName);
+  }
+})();
+/**
+ * Holds results for a set of Jasmine spec. Allows for the results array to hold another jasmine.NestedResults
+ *
+ * @constructor
+ */
+jasmine.NestedResults = function() {
+  /**
+   * The total count of results
+   */
+  this.totalCount = 0;
+  /**
+   * Number of passed results
+   */
+  this.passedCount = 0;
+  /**
+   * Number of failed results
+   */
+  this.failedCount = 0;
+  /**
+   * Was this suite/spec skipped?
+   */
+  this.skipped = false;
+  /**
+   * @ignore
+   */
+  this.items_ = [];
+};
+
+/**
+ * Roll up the result counts.
+ *
+ * @param result
+ */
+jasmine.NestedResults.prototype.rollupCounts = function(result) {
+  this.totalCount += result.totalCount;
+  this.passedCount += result.passedCount;
+  this.failedCount += result.failedCount;
+};
+
+/**
+ * Adds a log message.
+ * @param values Array of message parts which will be concatenated later.
+ */
+jasmine.NestedResults.prototype.log = function(values) {
+  this.items_.push(new jasmine.MessageResult(values));
+};
+
+/**
+ * Getter for the results: message & results.
+ */
+jasmine.NestedResults.prototype.getItems = function() {
+  return this.items_;
+};
+
+/**
+ * Adds a result, tracking counts (total, passed, & failed)
+ * @param {jasmine.ExpectationResult|jasmine.NestedResults} result
+ */
+jasmine.NestedResults.prototype.addResult = function(result) {
+  if (result.type != 'log') {
+    if (result.items_) {
+      this.rollupCounts(result);
+    } else {
+      this.totalCount++;
+      if (result.passed()) {
+        this.passedCount++;
+      } else {
+        this.failedCount++;
+      }
+    }
+  }
+  this.items_.push(result);
+};
+
+/**
+ * @returns {Boolean} True if <b>everything</b> below passed
+ */
+jasmine.NestedResults.prototype.passed = function() {
+  return this.passedCount === this.totalCount;
+};
+/**
+ * Base class for pretty printing for expectation results.
+ */
+jasmine.PrettyPrinter = function() {
+  this.ppNestLevel_ = 0;
+};
+
+/**
+ * Formats a value in a nice, human-readable string.
+ *
+ * @param value
+ */
+jasmine.PrettyPrinter.prototype.format = function(value) {
+  if (this.ppNestLevel_ > 40) {
+    throw new Error('jasmine.PrettyPrinter: format() nested too deeply!');
+  }
+
+  this.ppNestLevel_++;
+  try {
+    if (value === jasmine.undefined) {
+      this.emitScalar('undefined');
+    } else if (value === null) {
+      this.emitScalar('null');
+    } else if (value === jasmine.getGlobal()) {
+      this.emitScalar('<global>');
+    } else if (value.jasmineToString) {
+      this.emitScalar(value.jasmineToString());
+    } else if (typeof value === 'string') {
+      this.emitString(value);
+    } else if (jasmine.isSpy(value)) {
+      this.emitScalar("spy on " + value.identity);
+    } else if (value instanceof RegExp) {
+      this.emitScalar(value.toString());
+    } else if (typeof value === 'function') {
+      this.emitScalar('Function');
+    } else if (typeof value.nodeType === 'number') {
+      this.emitScalar('HTMLNode');
+    } else if (value instanceof Date) {
+      this.emitScalar('Date(' + value + ')');
+    } else if (value.__Jasmine_been_here_before__) {
+      this.emitScalar('<circular reference: ' + (jasmine.isArray_(value) ? 'Array' : 'Object') + '>');
+    } else if (jasmine.isArray_(value) || typeof value == 'object') {
+      value.__Jasmine_been_here_before__ = true;
+      if (jasmine.isArray_(value)) {
+        this.emitArray(value);
+      } else {
+        this.emitObject(value);
+      }
+      delete value.__Jasmine_been_here_before__;
+    } else {
+      this.emitScalar(value.toString());
+    }
+  } finally {
+    this.ppNestLevel_--;
+  }
+};
+
+jasmine.PrettyPrinter.prototype.iterateObject = function(obj, fn) {
+  for (var property in obj) {
+    if (property == '__Jasmine_been_here_before__') continue;
+    fn(property, obj.__lookupGetter__ ? (obj.__lookupGetter__(property) !== jasmine.undefined &&
+                                         obj.__lookupGetter__(property) !== null) : false);
+  }
+};
+
+jasmine.PrettyPrinter.prototype.emitArray = jasmine.unimplementedMethod_;
+jasmine.PrettyPrinter.prototype.emitObject = jasmine.unimplementedMethod_;
+jasmine.PrettyPrinter.prototype.emitScalar = jasmine.unimplementedMethod_;
+jasmine.PrettyPrinter.prototype.emitString = jasmine.unimplementedMethod_;
+
+jasmine.StringPrettyPrinter = function() {
+  jasmine.PrettyPrinter.call(this);
+
+  this.string = '';
+};
+jasmine.util.inherit(jasmine.StringPrettyPrinter, jasmine.PrettyPrinter);
+
+jasmine.StringPrettyPrinter.prototype.emitScalar = function(value) {
+  this.append(value);
+};
+
+jasmine.StringPrettyPrinter.prototype.emitString = function(value) {
+  this.append("'" + value + "'");
+};
+
+jasmine.StringPrettyPrinter.prototype.emitArray = function(array) {
+  this.append('[ ');
+  for (var i = 0; i < array.length; i++) {
+    if (i > 0) {
+      this.append(', ');
+    }
+    this.format(array[i]);
+  }
+  this.append(' ]');
+};
+
+jasmine.StringPrettyPrinter.prototype.emitObject = function(obj) {
+  var self = this;
+  this.append('{ ');
+  var first = true;
+
+  this.iterateObject(obj, function(property, isGetter) {
+    if (first) {
+      first = false;
+    } else {
+      self.append(', ');
+    }
+
+    self.append(property);
+    self.append(' : ');
+    if (isGetter) {
+      self.append('<getter>');
+    } else {
+      self.format(obj[property]);
+    }
+  });
+
+  this.append(' }');
+};
+
+jasmine.StringPrettyPrinter.prototype.append = function(value) {
+  this.string += value;
+};
+jasmine.Queue = function(env) {
+  this.env = env;
+  this.blocks = [];
+  this.running = false;
+  this.index = 0;
+  this.offset = 0;
+  this.abort = false;
+};
+
+jasmine.Queue.prototype.addBefore = function(block) {
+  this.blocks.unshift(block);
+};
+
+jasmine.Queue.prototype.add = function(block) {
+  this.blocks.push(block);
+};
+
+jasmine.Queue.prototype.insertNext = function(block) {
+  this.blocks.splice((this.index + this.offset + 1), 0, block);
+  this.offset++;
+};
+
+jasmine.Queue.prototype.start = function(onComplete) {
+  this.running = true;
+  this.onComplete = onComplete;
+  this.next_();
+};
+
+jasmine.Queue.prototype.isRunning = function() {
+  return this.running;
+};
+
+jasmine.Queue.LOOP_DONT_RECURSE = true;
+
+jasmine.Queue.prototype.next_ = function() {
+  var self = this;
+  var goAgain = true;
+
+  while (goAgain) {
+    goAgain = false;
+
+    if (self.index < self.blocks.length && !this.abort) {
+      var calledSynchronously = true;
+      var completedSynchronously = false;
+
+      var onComplete = function () {
+        if (jasmine.Queue.LOOP_DONT_RECURSE && calledSynchronously) {
+          completedSynchronously = true;
+          return;
+        }
+
+        if (self.blocks[self.index].abort) {
+          self.abort = true;
+        }
+
+        self.offset = 0;
+        self.index++;
+
+        var now = new Date().getTime();
+        if (self.env.updateInterval && now - self.env.lastUpdate > self.env.updateInterval) {
+          self.env.lastUpdate = now;
+          self.env.setTimeout(function() {
+            self.next_();
+          }, 0);
+        } else {
+          if (jasmine.Queue.LOOP_DONT_RECURSE && completedSynchronously) {
+            goAgain = true;
+          } else {
+            self.next_();
+          }
+        }
+      };
+      self.blocks[self.index].execute(onComplete);
+
+      calledSynchronously = false;
+      if (completedSynchronously) {
+        onComplete();
+      }
+
+    } else {
+      self.running = false;
+      if (self.onComplete) {
+        self.onComplete();
+      }
+    }
+  }
+};
+
+jasmine.Queue.prototype.results = function() {
+  var results = new jasmine.NestedResults();
+  for (var i = 0; i < this.blocks.length; i++) {
+    if (this.blocks[i].results) {
+      results.addResult(this.blocks[i].results());
+    }
+  }
+  return results;
+};
+
+
+/**
+ * Runner
+ *
+ * @constructor
+ * @param {jasmine.Env} env
+ */
+jasmine.Runner = function(env) {
+  var self = this;
+  self.env = env;
+  self.queue = new jasmine.Queue(env);
+  self.before_ = [];
+  self.after_ = [];
+  self.suites_ = [];
+};
+
+jasmine.Runner.prototype.execute = function() {
+  var self = this;
+  if (self.env.reporter.reportRunnerStarting) {
+    self.env.reporter.reportRunnerStarting(this);
+  }
+  self.queue.start(function () {
+    self.finishCallback();
+  });
+};
+
+jasmine.Runner.prototype.beforeEach = function(beforeEachFunction) {
+  beforeEachFunction.typeName = 'beforeEach';
+  this.before_.splice(0,0,beforeEachFunction);
+};
+
+jasmine.Runner.prototype.afterEach = function(afterEachFunction) {
+  afterEachFunction.typeName = 'afterEach';
+  this.after_.splice(0,0,afterEachFunction);
+};
+
+
+jasmine.Runner.prototype.finishCallback = function() {
+  this.env.reporter.reportRunnerResults(this);
+};
+
+jasmine.Runner.prototype.addSuite = function(suite) {
+  this.suites_.push(suite);
+};
+
+jasmine.Runner.prototype.add = function(block) {
+  if (block instanceof jasmine.Suite) {
+    this.addSuite(block);
+  }
+  this.queue.add(block);
+};
+
+jasmine.Runner.prototype.specs = function () {
+  var suites = this.suites();
+  var specs = [];
+  for (var i = 0; i < suites.length; i++) {
+    specs = specs.concat(suites[i].specs());
+  }
+  return specs;
+};
+
+jasmine.Runner.prototype.suites = function() {
+  return this.suites_;
+};
+
+jasmine.Runner.prototype.topLevelSuites = function() {
+  var topLevelSuites = [];
+  for (var i = 0; i < this.suites_.length; i++) {
+    if (!this.suites_[i].parentSuite) {
+      topLevelSuites.push(this.suites_[i]);
+    }
+  }
+  return topLevelSuites;
+};
+
+jasmine.Runner.prototype.results = function() {
+  return this.queue.results();
+};
+/**
+ * Internal representation of a Jasmine specification, or test.
+ *
+ * @constructor
+ * @param {jasmine.Env} env
+ * @param {jasmine.Suite} suite
+ * @param {String} description
+ */
+jasmine.Spec = function(env, suite, description) {
+  if (!env) {
+    throw new Error('jasmine.Env() required');
+  }
+  if (!suite) {
+    throw new Error('jasmine.Suite() required');
+  }
+  var spec = this;
+  spec.id = env.nextSpecId ? env.nextSpecId() : null;
+  spec.env = env;
+  spec.suite = suite;
+  spec.description = description;
+  spec.queue = new jasmine.Queue(env);
+
+  spec.afterCallbacks = [];
+  spec.spies_ = [];
+
+  spec.results_ = new jasmine.NestedResults();
+  spec.results_.description = description;
+  spec.matchersClass = null;
+};
+
+jasmine.Spec.prototype.getFullName = function() {
+  return this.suite.getFullName() + ' ' + this.description + '.';
+};
+
+
+jasmine.Spec.prototype.results = function() {
+  return this.results_;
+};
+
+/**
+ * All parameters are pretty-printed and concatenated together, then written to the spec's output.
+ *
+ * Be careful not to leave calls to <code>jasmine.log</code> in production code.
+ */
+jasmine.Spec.prototype.log = function() {
+  return this.results_.log(arguments);
+};
+
+jasmine.Spec.prototype.runs = function (func) {
+  var block = new jasmine.Block(this.env, func, this);
+  this.addToQueue(block);
+  return this;
+};
+
+jasmine.Spec.prototype.addToQueue = function (block) {
+  if (this.queue.isRunning()) {
+    this.queue.insertNext(block);
+  } else {
+    this.queue.add(block);
+  }
+};
+
+/**
+ * @param {jasmine.ExpectationResult} result
+ */
+jasmine.Spec.prototype.addMatcherResult = function(result) {
+  this.results_.addResult(result);
+};
+
+jasmine.Spec.prototype.expect = function(actual) {
+  var positive = new (this.getMatchersClass_())(this.env, actual, this);
+  positive.not = new (this.getMatchersClass_())(this.env, actual, this, true);
+  return positive;
+};
+
+/**
+ * Waits a fixed time period before moving to the next block.
+ *
+ * @deprecated Use waitsFor() instead
+ * @param {Number} timeout milliseconds to wait
+ */
+jasmine.Spec.prototype.waits = function(timeout) {
+  var waitsFunc = new jasmine.WaitsBlock(this.env, timeout, this);
+  this.addToQueue(waitsFunc);
+  return this;
+};
+
+/**
+ * Waits for the latchFunction to return true before proceeding to the next block.
+ *
+ * @param {Function} latchFunction
+ * @param {String} optional_timeoutMessage
+ * @param {Number} optional_timeout
+ */
+jasmine.Spec.prototype.waitsFor = function(latchFunction, optional_timeoutMessage, optional_timeout) {
+  var latchFunction_ = null;
+  var optional_timeoutMessage_ = null;
+  var optional_timeout_ = null;
+
+  for (var i = 0; i < arguments.length; i++) {
+    var arg = arguments[i];
+    switch (typeof arg) {
+      case 'function':
+        latchFunction_ = arg;
+        break;
+      case 'string':
+        optional_timeoutMessage_ = arg;
+        break;
+      case 'number':
+        optional_timeout_ = arg;
+        break;
+    }
+  }
+
+  var waitsForFunc = new jasmine.WaitsForBlock(this.env, optional_timeout_, latchFunction_, optional_timeoutMessage_, this);
+  this.addToQueue(waitsForFunc);
+  return this;
+};
+
+jasmine.Spec.prototype.fail = function (e) {
+  var expectationResult = new jasmine.ExpectationResult({
+    passed: false,
+    message: e ? jasmine.util.formatException(e) : 'Exception',
+    trace: { stack: e.stack }
+  });
+  this.results_.addResult(expectationResult);
+};
+
+jasmine.Spec.prototype.getMatchersClass_ = function() {
+  return this.matchersClass || this.env.matchersClass;
+};
+
+jasmine.Spec.prototype.addMatchers = function(matchersPrototype) {
+  var parent = this.getMatchersClass_();
+  var newMatchersClass = function() {
+    parent.apply(this, arguments);
+  };
+  jasmine.util.inherit(newMatchersClass, parent);
+  jasmine.Matchers.wrapInto_(matchersPrototype, newMatchersClass);
+  this.matchersClass = newMatchersClass;
+};
+
+jasmine.Spec.prototype.finishCallback = function() {
+  this.env.reporter.reportSpecResults(this);
+};
+
+jasmine.Spec.prototype.finish = function(onComplete) {
+  this.removeAllSpies();
+  this.finishCallback();
+  if (onComplete) {
+    onComplete();
+  }
+};
+
+jasmine.Spec.prototype.after = function(doAfter) {
+  if (this.queue.isRunning()) {
+    this.queue.add(new jasmine.Block(this.env, doAfter, this));
+  } else {
+    this.afterCallbacks.unshift(doAfter);
+  }
+};
+
+jasmine.Spec.prototype.execute = function(onComplete) {
+  var spec = this;
+  if (!spec.env.specFilter(spec)) {
+    spec.results_.skipped = true;
+    spec.finish(onComplete);
+    return;
+  }
+
+  this.env.reporter.reportSpecStarting(this);
+
+  spec.env.currentSpec = spec;
+
+  spec.addBeforesAndAftersToQueue();
+
+  spec.queue.start(function () {
+    spec.finish(onComplete);
+  });
+};
+
+jasmine.Spec.prototype.addBeforesAndAftersToQueue = function() {
+  var runner = this.env.currentRunner();
+  var i;
+
+  for (var suite = this.suite; suite; suite = suite.parentSuite) {
+    for (i = 0; i < suite.before_.length; i++) {
+      this.queue.addBefore(new jasmine.Block(this.env, suite.before_[i], this));
+    }
+  }
+  for (i = 0; i < runner.before_.length; i++) {
+    this.queue.addBefore(new jasmine.Block(this.env, runner.before_[i], this));
+  }
+  for (i = 0; i < this.afterCallbacks.length; i++) {
+    this.queue.add(new jasmine.Block(this.env, this.afterCallbacks[i], this));
+  }
+  for (suite = this.suite; suite; suite = suite.parentSuite) {
+    for (i = 0; i < suite.after_.length; i++) {
+      this.queue.add(new jasmine.Block(this.env, suite.after_[i], this));
+    }
+  }
+  for (i = 0; i < runner.after_.length; i++) {
+    this.queue.add(new jasmine.Block(this.env, runner.after_[i], this));
+  }
+};
+
+jasmine.Spec.prototype.explodes = function() {
+  throw 'explodes function should not have been called';
+};
+
+jasmine.Spec.prototype.spyOn = function(obj, methodName, ignoreMethodDoesntExist) {
+  if (obj == jasmine.undefined) {
+    throw "spyOn could not find an object to spy upon for " + methodName + "()";
+  }
+
+  if (!ignoreMethodDoesntExist && obj[methodName] === jasmine.undefined) {
+    throw methodName + '() method does not exist';
+  }
+
+  if (!ignoreMethodDoesntExist && obj[methodName] && obj[methodName].isSpy) {
+    throw new Error(methodName + ' has already been spied upon');
+  }
+
+  var spyObj = jasmine.createSpy(methodName);
+
+  this.spies_.push(spyObj);
+  spyObj.baseObj = obj;
+  spyObj.methodName = methodName;
+  spyObj.originalValue = obj[methodName];
+
+  obj[methodName] = spyObj;
+
+  return spyObj;
+};
+
+jasmine.Spec.prototype.removeAllSpies = function() {
+  for (var i = 0; i < this.spies_.length; i++) {
+    var spy = this.spies_[i];
+    spy.baseObj[spy.methodName] = spy.originalValue;
+  }
+  this.spies_ = [];
+};
+
+/**
+ * Internal representation of a Jasmine suite.
+ *
+ * @constructor
+ * @param {jasmine.Env} env
+ * @param {String} description
+ * @param {Function} specDefinitions
+ * @param {jasmine.Suite} parentSuite
+ */
+jasmine.Suite = function(env, description, specDefinitions, parentSuite) {
+  var self = this;
+  self.id = env.nextSuiteId ? env.nextSuiteId() : null;
+  self.description = description;
+  self.queue = new jasmine.Queue(env);
+  self.parentSuite = parentSuite;
+  self.env = env;
+  self.before_ = [];
+  self.after_ = [];
+  self.children_ = [];
+  self.suites_ = [];
+  self.specs_ = [];
+};
+
+jasmine.Suite.prototype.getFullName = function() {
+  var fullName = this.description;
+  for (var parentSuite = this.parentSuite; parentSuite; parentSuite = parentSuite.parentSuite) {
+    fullName = parentSuite.description + ' ' + fullName;
+  }
+  return fullName;
+};
+
+jasmine.Suite.prototype.finish = function(onComplete) {
+  this.env.reporter.reportSuiteResults(this);
+  this.finished = true;
+  if (typeof(onComplete) == 'function') {
+    onComplete();
+  }
+};
+
+jasmine.Suite.prototype.beforeEach = function(beforeEachFunction) {
+  beforeEachFunction.typeName = 'beforeEach';
+  this.before_.unshift(beforeEachFunction);
+};
+
+jasmine.Suite.prototype.afterEach = function(afterEachFunction) {
+  afterEachFunction.typeName = 'afterEach';
+  this.after_.unshift(afterEachFunction);
+};
+
+jasmine.Suite.prototype.results = function() {
+  return this.queue.results();
+};
+
+jasmine.Suite.prototype.add = function(suiteOrSpec) {
+  this.children_.push(suiteOrSpec);
+  if (suiteOrSpec instanceof jasmine.Suite) {
+    this.suites_.push(suiteOrSpec);
+    this.env.currentRunner().addSuite(suiteOrSpec);
+  } else {
+    this.specs_.push(suiteOrSpec);
+  }
+  this.queue.add(suiteOrSpec);
+};
+
+jasmine.Suite.prototype.specs = function() {
+  return this.specs_;
+};
+
+jasmine.Suite.prototype.suites = function() {
+  return this.suites_;
+};
+
+jasmine.Suite.prototype.children = function() {
+  return this.children_;
+};
+
+jasmine.Suite.prototype.execute = function(onComplete) {
+  var self = this;
+  this.queue.start(function () {
+    self.finish(onComplete);
+  });
+};
+jasmine.WaitsBlock = function(env, timeout, spec) {
+  this.timeout = timeout;
+  jasmine.Block.call(this, env, null, spec);
+};
+
+jasmine.util.inherit(jasmine.WaitsBlock, jasmine.Block);
+
+jasmine.WaitsBlock.prototype.execute = function (onComplete) {
+  if (jasmine.VERBOSE) {
+    this.env.reporter.log('>> Jasmine waiting for ' + this.timeout + ' ms...');
+  }
+  this.env.setTimeout(function () {
+    onComplete();
+  }, this.timeout);
+};
+/**
+ * A block which waits for some condition to become true, with timeout.
+ *
+ * @constructor
+ * @extends jasmine.Block
+ * @param {jasmine.Env} env The Jasmine environment.
+ * @param {Number} timeout The maximum time in milliseconds to wait for the condition to become true.
+ * @param {Function} latchFunction A function which returns true when the desired condition has been met.
+ * @param {String} message The message to display if the desired condition hasn't been met within the given time period.
+ * @param {jasmine.Spec} spec The Jasmine spec.
+ */
+jasmine.WaitsForBlock = function(env, timeout, latchFunction, message, spec) {
+  this.timeout = timeout || env.defaultTimeoutInterval;
+  this.latchFunction = latchFunction;
+  this.message = message;
+  this.totalTimeSpentWaitingForLatch = 0;
+  jasmine.Block.call(this, env, null, spec);
+};
+jasmine.util.inherit(jasmine.WaitsForBlock, jasmine.Block);
+
+jasmine.WaitsForBlock.TIMEOUT_INCREMENT = 10;
+
+jasmine.WaitsForBlock.prototype.execute = function(onComplete) {
+  if (jasmine.VERBOSE) {
+    this.env.reporter.log('>> Jasmine waiting for ' + (this.message || 'something to happen'));
+  }
+  var latchFunctionResult;
+  try {
+    latchFunctionResult = this.latchFunction.apply(this.spec);
+  } catch (e) {
+    this.spec.fail(e);
+    onComplete();
+    return;
+  }
+
+  if (latchFunctionResult) {
+    onComplete();
+  } else if (this.totalTimeSpentWaitingForLatch >= this.timeout) {
+    var message = 'timed out after ' + this.timeout + ' msec waiting for ' + (this.message || 'something to happen');
+    this.spec.fail({
+      name: 'timeout',
+      message: message
+    });
+
+    this.abort = true;
+    onComplete();
+  } else {
+    this.totalTimeSpentWaitingForLatch += jasmine.WaitsForBlock.TIMEOUT_INCREMENT;
+    var self = this;
+    this.env.setTimeout(function() {
+      self.execute(onComplete);
+    }, jasmine.WaitsForBlock.TIMEOUT_INCREMENT);
+  }
+};
+
+jasmine.version_= {
+  "major": 1,
+  "minor": 2,
+  "build": 0,
+  "revision": 1337005947
+};
diff --git a/assets/javascripts/spec/vendor/mocha.js b/assets/javascripts/spec/vendor/mocha.js
deleted file mode 100644
index a8d6b221..00000000
--- a/assets/javascripts/spec/vendor/mocha.js
+++ /dev/null
@@ -1,4477 +0,0 @@
-;(function(){
-
-// CommonJS require()
-
-function require(p){
-    var path = require.resolve(p)
-      , mod = require.modules[path];
-    if (!mod) throw new Error('failed to require "' + p + '"');
-    if (!mod.exports) {
-      mod.exports = {};
-      mod.call(mod.exports, mod, mod.exports, require.relative(path));
-    }
-    return mod.exports;
-  }
-
-require.modules = {};
-
-require.resolve = function (path){
-    var orig = path
-      , reg = path + '.js'
-      , index = path + '/index.js';
-    return require.modules[reg] && reg
-      || require.modules[index] && index
-      || orig;
-  };
-
-require.register = function (path, fn){
-    require.modules[path] = fn;
-  };
-
-require.relative = function (parent) {
-    return function(p){
-      if ('.' != p.charAt(0)) return require(p);
-
-      var path = parent.split('/')
-        , segs = p.split('/');
-      path.pop();
-
-      for (var i = 0; i < segs.length; i++) {
-        var seg = segs[i];
-        if ('..' == seg) path.pop();
-        else if ('.' != seg) path.push(seg);
-      }
-
-      return require(path.join('/'));
-    };
-  };
-
-
-require.register("browser/debug.js", function(module, exports, require){
-
-module.exports = function(type){
-  return function(){
-
-  }
-};
-}); // module: browser/debug.js
-
-require.register("browser/diff.js", function(module, exports, require){
-
-}); // module: browser/diff.js
-
-require.register("browser/events.js", function(module, exports, require){
-
-/**
- * Module exports.
- */
-
-exports.EventEmitter = EventEmitter;
-
-/**
- * Check if `obj` is an array.
- */
-
-function isArray(obj) {
-  return '[object Array]' == {}.toString.call(obj);
-}
-
-/**
- * Event emitter constructor.
- *
- * @api public
- */
-
-function EventEmitter(){};
-
-/**
- * Adds a listener.
- *
- * @api public
- */
-
-EventEmitter.prototype.on = function (name, fn) {
-  if (!this.$events) {
-    this.$events = {};
-  }
-
-  if (!this.$events[name]) {
-    this.$events[name] = fn;
-  } else if (isArray(this.$events[name])) {
-    this.$events[name].push(fn);
-  } else {
-    this.$events[name] = [this.$events[name], fn];
-  }
-
-  return this;
-};
-
-EventEmitter.prototype.addListener = EventEmitter.prototype.on;
-
-/**
- * Adds a volatile listener.
- *
- * @api public
- */
-
-EventEmitter.prototype.once = function (name, fn) {
-  var self = this;
-
-  function on () {
-    self.removeListener(name, on);
-    fn.apply(this, arguments);
-  };
-
-  on.listener = fn;
-  this.on(name, on);
-
-  return this;
-};
-
-/**
- * Removes a listener.
- *
- * @api public
- */
-
-EventEmitter.prototype.removeListener = function (name, fn) {
-  if (this.$events && this.$events[name]) {
-    var list = this.$events[name];
-
-    if (isArray(list)) {
-      var pos = -1;
-
-      for (var i = 0, l = list.length; i < l; i++) {
-        if (list[i] === fn || (list[i].listener && list[i].listener === fn)) {
-          pos = i;
-          break;
-        }
-      }
-
-      if (pos < 0) {
-        return this;
-      }
-
-      list.splice(pos, 1);
-
-      if (!list.length) {
-        delete this.$events[name];
-      }
-    } else if (list === fn || (list.listener && list.listener === fn)) {
-      delete this.$events[name];
-    }
-  }
-
-  return this;
-};
-
-/**
- * Removes all listeners for an event.
- *
- * @api public
- */
-
-EventEmitter.prototype.removeAllListeners = function (name) {
-  if (name === undefined) {
-    this.$events = {};
-    return this;
-  }
-
-  if (this.$events && this.$events[name]) {
-    this.$events[name] = null;
-  }
-
-  return this;
-};
-
-/**
- * Gets all listeners for a certain event.
- *
- * @api public
- */
-
-EventEmitter.prototype.listeners = function (name) {
-  if (!this.$events) {
-    this.$events = {};
-  }
-
-  if (!this.$events[name]) {
-    this.$events[name] = [];
-  }
-
-  if (!isArray(this.$events[name])) {
-    this.$events[name] = [this.$events[name]];
-  }
-
-  return this.$events[name];
-};
-
-/**
- * Emits an event.
- *
- * @api public
- */
-
-EventEmitter.prototype.emit = function (name) {
-  if (!this.$events) {
-    return false;
-  }
-
-  var handler = this.$events[name];
-
-  if (!handler) {
-    return false;
-  }
-
-  var args = [].slice.call(arguments, 1);
-
-  if ('function' == typeof handler) {
-    handler.apply(this, args);
-  } else if (isArray(handler)) {
-    var listeners = handler.slice();
-
-    for (var i = 0, l = listeners.length; i < l; i++) {
-      listeners[i].apply(this, args);
-    }
-  } else {
-    return false;
-  }
-
-  return true;
-};
-}); // module: browser/events.js
-
-require.register("browser/fs.js", function(module, exports, require){
-
-}); // module: browser/fs.js
-
-require.register("browser/path.js", function(module, exports, require){
-
-}); // module: browser/path.js
-
-require.register("browser/progress.js", function(module, exports, require){
-
-/**
- * Expose `Progress`.
- */
-
-module.exports = Progress;
-
-/**
- * Initialize a new `Progress` indicator.
- */
-
-function Progress() {
-  this.percent = 0;
-  this.size(0);
-  this.fontSize(11);
-  this.font('helvetica, arial, sans-serif');
-}
-
-/**
- * Set progress size to `n`.
- *
- * @param {Number} n
- * @return {Progress} for chaining
- * @api public
- */
-
-Progress.prototype.size = function(n){
-  this._size = n;
-  return this;
-};
-
-/**
- * Set text to `str`.
- *
- * @param {String} str
- * @return {Progress} for chaining
- * @api public
- */
-
-Progress.prototype.text = function(str){
-  this._text = str;
-  return this;
-};
-
-/**
- * Set font size to `n`.
- *
- * @param {Number} n
- * @return {Progress} for chaining
- * @api public
- */
-
-Progress.prototype.fontSize = function(n){
-  this._fontSize = n;
-  return this;
-};
-
-/**
- * Set font `family`.
- *
- * @param {String} family
- * @return {Progress} for chaining
- */
-
-Progress.prototype.font = function(family){
-  this._font = family;
-  return this;
-};
-
-/**
- * Update percentage to `n`.
- *
- * @param {Number} n
- * @return {Progress} for chaining
- */
-
-Progress.prototype.update = function(n){
-  this.percent = n;
-  return this;
-};
-
-/**
- * Draw on `ctx`.
- *
- * @param {CanvasRenderingContext2d} ctx
- * @return {Progress} for chaining
- */
-
-Progress.prototype.draw = function(ctx){
-  var percent = Math.min(this.percent, 100)
-    , size = this._size
-    , half = size / 2
-    , x = half
-    , y = half
-    , rad = half - 1
-    , fontSize = this._fontSize;
-
-  ctx.font = fontSize + 'px ' + this._font;
-
-  var angle = Math.PI * 2 * (percent / 100);
-  ctx.clearRect(0, 0, size, size);
-
-  // outer circle
-  ctx.strokeStyle = '#9f9f9f';
-  ctx.beginPath();
-  ctx.arc(x, y, rad, 0, angle, false);
-  ctx.stroke();
-
-  // inner circle
-  ctx.strokeStyle = '#eee';
-  ctx.beginPath();
-  ctx.arc(x, y, rad - 1, 0, angle, true);
-  ctx.stroke();
-
-  // text
-  var text = this._text || (percent | 0) + '%'
-    , w = ctx.measureText(text).width;
-
-  ctx.fillText(
-      text
-    , x - w / 2 + 1
-    , y + fontSize / 2 - 1);
-
-  return this;
-};
-
-}); // module: browser/progress.js
-
-require.register("browser/tty.js", function(module, exports, require){
-
-exports.isatty = function(){
-  return true;
-};
-
-exports.getWindowSize = function(){
-  return [window.innerHeight, window.innerWidth];
-};
-}); // module: browser/tty.js
-
-require.register("context.js", function(module, exports, require){
-
-/**
- * Expose `Context`.
- */
-
-module.exports = Context;
-
-/**
- * Initialize a new `Context`.
- *
- * @api private
- */
-
-function Context(){}
-
-/**
- * Set the context `Runnable` to `runnable`.
- *
- * @param {Runnable} runnable
- * @return {Context}
- * @api private
- */
-
-Context.prototype.runnable = function(runnable){
-  this._runnable = runnable;
-  return this;
-};
-
-/**
- * Set test timeout `ms`.
- *
- * @param {Number} ms
- * @return {Context} self
- * @api private
- */
-
-Context.prototype.timeout = function(ms){
-  this._runnable.timeout(ms);
-  return this;
-};
-
-/**
- * Inspect the context void of `._runnable`.
- *
- * @return {String}
- * @api private
- */
-
-Context.prototype.inspect = function(){
-  return JSON.stringify(this, function(key, val){
-    return '_runnable' == key
-      ? undefined
-      : val;
-  }, 2);
-};
-
-}); // module: context.js
-
-require.register("hook.js", function(module, exports, require){
-
-/**
- * Module dependencies.
- */
-
-var Runnable = require('./runnable');
-
-/**
- * Expose `Hook`.
- */
-
-module.exports = Hook;
-
-/**
- * Initialize a new `Hook` with the given `title` and callback `fn`.
- *
- * @param {String} title
- * @param {Function} fn
- * @api private
- */
-
-function Hook(title, fn) {
-  Runnable.call(this, title, fn);
-  this.type = 'hook';
-}
-
-/**
- * Inherit from `Runnable.prototype`.
- */
-
-Hook.prototype = new Runnable;
-Hook.prototype.constructor = Hook;
-
-
-}); // module: hook.js
-
-require.register("interfaces/bdd.js", function(module, exports, require){
-
-/**
- * Module dependencies.
- */
-
-var Suite = require('../suite')
-  , Test = require('../test');
-
-/**
- * BDD-style interface:
- *
- *      describe('Array', function(){
- *        describe('#indexOf()', function(){
- *          it('should return -1 when not present', function(){
- *
- *          });
- *
- *          it('should return the index when present', function(){
- *
- *          });
- *        });
- *      });
- *
- */
-
-module.exports = function(suite){
-  var suites = [suite];
-
-  suite.on('pre-require', function(context){
-
-    // noop variants
-
-    context.xdescribe = function(){};
-    context.xit = function(){};
-
-    /**
-     * Execute before running tests.
-     */
-
-    context.before = function(fn){
-      suites[0].beforeAll(fn);
-    };
-
-    /**
-     * Execute after running tests.
-     */
-
-    context.after = function(fn){
-      suites[0].afterAll(fn);
-    };
-
-    /**
-     * Execute before each test case.
-     */
-
-    context.beforeEach = function(fn){
-      suites[0].beforeEach(fn);
-    };
-
-    /**
-     * Execute after each test case.
-     */
-
-    context.afterEach = function(fn){
-      suites[0].afterEach(fn);
-    };
-
-    /**
-     * Describe a "suite" with the given `title`
-     * and callback `fn` containing nested suites
-     * and/or tests.
-     */
-
-    context.describe = context.context = function(title, fn){
-      var suite = Suite.create(suites[0], title);
-      suites.unshift(suite);
-      fn();
-      suites.shift();
-    };
-
-    /**
-     * Describe a specification or test-case
-     * with the given `title` and callback `fn`
-     * acting as a thunk.
-     */
-
-    context.it = context.specify = function(title, fn){
-      suites[0].addTest(new Test(title, fn));
-    };
-  });
-};
-
-}); // module: interfaces/bdd.js
-
-require.register("interfaces/exports.js", function(module, exports, require){
-
-/**
- * Module dependencies.
- */
-
-var Suite = require('../suite')
-  , Test = require('../test');
-
-/**
- * TDD-style interface:
- *
- *     exports.Array = {
- *       '#indexOf()': {
- *         'should return -1 when the value is not present': function(){
- *
- *         },
- *
- *         'should return the correct index when the value is present': function(){
- *
- *         }
- *       }
- *     };
- *
- */
-
-module.exports = function(suite){
-  var suites = [suite];
-
-  suite.on('require', visit);
-
-  function visit(obj) {
-    var suite;
-    for (var key in obj) {
-      if ('function' == typeof obj[key]) {
-        var fn = obj[key];
-        switch (key) {
-          case 'before':
-            suites[0].beforeAll(fn);
-            break;
-          case 'after':
-            suites[0].afterAll(fn);
-            break;
-          case 'beforeEach':
-            suites[0].beforeEach(fn);
-            break;
-          case 'afterEach':
-            suites[0].afterEach(fn);
-            break;
-          default:
-            suites[0].addTest(new Test(key, fn));
-        }
-      } else {
-        var suite = Suite.create(suites[0], key);
-        suites.unshift(suite);
-        visit(obj[key]);
-        suites.shift();
-      }
-    }
-  }
-};
-}); // module: interfaces/exports.js
-
-require.register("interfaces/index.js", function(module, exports, require){
-
-exports.bdd = require('./bdd');
-exports.tdd = require('./tdd');
-exports.qunit = require('./qunit');
-exports.exports = require('./exports');
-
-}); // module: interfaces/index.js
-
-require.register("interfaces/qunit.js", function(module, exports, require){
-
-/**
- * Module dependencies.
- */
-
-var Suite = require('../suite')
-  , Test = require('../test');
-
-/**
- * QUnit-style interface:
- *
- *     suite('Array');
- *
- *     test('#length', function(){
- *       var arr = [1,2,3];
- *       ok(arr.length == 3);
- *     });
- *
- *     test('#indexOf()', function(){
- *       var arr = [1,2,3];
- *       ok(arr.indexOf(1) == 0);
- *       ok(arr.indexOf(2) == 1);
- *       ok(arr.indexOf(3) == 2);
- *     });
- *
- *     suite('String');
- *
- *     test('#length', function(){
- *       ok('foo'.length == 3);
- *     });
- *
- */
-
-module.exports = function(suite){
-  var suites = [suite];
-
-  suite.on('pre-require', function(context){
-
-    /**
-     * Execute before running tests.
-     */
-
-    context.before = function(fn){
-      suites[0].beforeAll(fn);
-    };
-
-    /**
-     * Execute after running tests.
-     */
-
-    context.after = function(fn){
-      suites[0].afterAll(fn);
-    };
-
-    /**
-     * Execute before each test case.
-     */
-
-    context.beforeEach = function(fn){
-      suites[0].beforeEach(fn);
-    };
-
-    /**
-     * Execute after each test case.
-     */
-
-    context.afterEach = function(fn){
-      suites[0].afterEach(fn);
-    };
-
-    /**
-     * Describe a "suite" with the given `title`.
-     */
-
-    context.suite = function(title){
-      if (suites.length > 1) suites.shift();
-      var suite = Suite.create(suites[0], title);
-      suites.unshift(suite);
-    };
-
-    /**
-     * Describe a specification or test-case
-     * with the given `title` and callback `fn`
-     * acting as a thunk.
-     */
-
-    context.test = function(title, fn){
-      suites[0].addTest(new Test(title, fn));
-    };
-  });
-};
-
-}); // module: interfaces/qunit.js
-
-require.register("interfaces/tdd.js", function(module, exports, require){
-
-/**
- * Module dependencies.
- */
-
-var Suite = require('../suite')
-  , Test = require('../test');
-
-/**
- * TDD-style interface:
- *
- *      suite('Array', function(){
- *        suite('#indexOf()', function(){
- *          suiteSetup(function(){
- *
- *          });
- *
- *          test('should return -1 when not present', function(){
- *
- *          });
- *
- *          test('should return the index when present', function(){
- *
- *          });
- *
- *          suiteTeardown(function(){
- *
- *          });
- *        });
- *      });
- *
- */
-
-module.exports = function(suite){
-  var suites = [suite];
-
-  suite.on('pre-require', function(context){
-
-    /**
-     * Execute before each test case.
-     */
-
-    context.setup = function(fn){
-      suites[0].beforeEach(fn);
-    };
-
-    /**
-     * Execute after each test case.
-     */
-
-    context.teardown = function(fn){
-      suites[0].afterEach(fn);
-    };
-
-    /**
-     * Execute before the suite.
-     */
-
-    context.suiteSetup = function(fn){
-      suites[0].beforeAll(fn);
-    };
-
-    /**
-     * Execute after the suite.
-     */
-
-    context.suiteTeardown = function(fn){
-      suites[0].afterAll(fn);
-    };
-
-    /**
-     * Describe a "suite" with the given `title`
-     * and callback `fn` containing nested suites
-     * and/or tests.
-     */
-
-    context.suite = function(title, fn){
-      var suite = Suite.create(suites[0], title);
-      suites.unshift(suite);
-      fn();
-      suites.shift();
-    };
-
-    /**
-     * Describe a specification or test-case
-     * with the given `title` and callback `fn`
-     * acting as a thunk.
-     */
-
-    context.test = function(title, fn){
-      suites[0].addTest(new Test(title, fn));
-    };
-  });
-};
-
-}); // module: interfaces/tdd.js
-
-require.register("mocha.js", function(module, exports, require){
-/*!
- * mocha
- * Copyright(c) 2011 TJ Holowaychuk <tj@vision-media.ca>
- * MIT Licensed
- */
-
-/**
- * Module dependencies.
- */
-
-var path = require('browser/path');
-
-/**
- * Expose `Mocha`.
- */
-
-exports = module.exports = Mocha;
-
-/**
- * Library version.
- */
-
-exports.version = '1.2.0';
-
-/**
- * Expose internals.
- */
-
-exports.utils = require('./utils');
-exports.interfaces = require('./interfaces');
-exports.reporters = require('./reporters');
-exports.Runnable = require('./runnable');
-exports.Context = require('./context');
-exports.Runner = require('./runner');
-exports.Suite = require('./suite');
-exports.Hook = require('./hook');
-exports.Test = require('./test');
-
-/**
- * Return image `name` path.
- *
- * @param {String} name
- * @return {String}
- * @api private
- */
-
-function image(name) {
-  return __dirname + '/../images/' + name + '.png';
-}
-
-/**
- * Setup mocha with `options`.
- *
- * Options:
- *
- *   - `ui` name "bdd", "tdd", "exports" etc
- *   - `reporter` reporter instance, defaults to `mocha.reporters.Dot`
- *   - `globals` array of accepted globals
- *   - `timeout` timeout in milliseconds
- *   - `ignoreLeaks` ignore global leaks
- *   - `grep` string or regexp to filter tests with
- *
- * @param {Object} options
- * @api public
- */
-
-function Mocha(options) {
-  options = options || {};
-  this.files = [];
-  this.options = options;
-  this.grep(options.grep);
-  this.suite = new exports.Suite('', new exports.Context);
-  this.ui(options.ui);
-  this.reporter(options.reporter);
-  if (options.timeout) this.suite.timeout(options.timeout);
-}
-
-/**
- * Add test `file`.
- *
- * @param {String} file
- * @api public
- */
-
-Mocha.prototype.addFile = function(file){
-  this.files.push(file);
-  return this;
-};
-
-/**
- * Set reporter to `name`, defaults to "dot".
- *
- * @param {String} name
- * @api public
- */
-
-Mocha.prototype.reporter = function(name){
-  name = name || 'dot';
-  this._reporter = require('./reporters/' + name);
-  if (!this._reporter) throw new Error('invalid reporter "' + name + '"');
-  return this;
-};
-
-/**
- * Set test UI `name`, defaults to "bdd".
- *
- * @param {String} bdd
- * @api public
- */
-
-Mocha.prototype.ui = function(name){
-  name = name || 'bdd';
-  this._ui = exports.interfaces[name];
-  if (!this._ui) throw new Error('invalid interface "' + name + '"');
-  this._ui = this._ui(this.suite);
-  return this;
-};
-
-/**
- * Load registered files.
- *
- * @api private
- */
-
-Mocha.prototype.loadFiles = function(){
-  var suite = this.suite;
-  this.files.forEach(function(file){
-    file = path.resolve(file);
-    suite.emit('pre-require', global, file);
-    suite.emit('require', require(file), file);
-    suite.emit('post-require', global, file);
-  });
-};
-
-/**
- * Enable growl support.
- *
- * @api private
- */
-
-Mocha.prototype.growl = function(runner, reporter) {
-  var notify = require('growl');
-
-  runner.on('end', function(){
-    var stats = reporter.stats;
-    if (stats.failures) {
-      var msg = stats.failures + ' of ' + runner.total + ' tests failed';
-      notify(msg, { name: 'mocha', title: 'Failed', image: image('error') });
-    } else {
-      notify(stats.passes + ' tests passed in ' + stats.duration + 'ms', {
-          name: 'mocha'
-        , title: 'Passed'
-        , image: image('ok')
-      });
-    }
-  });
-};
-
-/**
- * Add regexp to grep for to the options object
- *
- * @param {RegExp} or {String} re
- * @return {Mocha}
- * @api public
- */
-
-Mocha.prototype.grep = function(re){
-  this.options.grep = 'string' == typeof re
-    ? new RegExp(re)
-    : re;
-  return this;
-};
-
-/**
- * Run tests and invoke `fn()` when complete.
- *
- * @param {Function} fn
- * @return {Runner}
- * @api public
- */
-
-Mocha.prototype.run = function(fn){
-  this.loadFiles();
-  var suite = this.suite;
-  var options = this.options;
-  var runner = new exports.Runner(suite);
-  var reporter = new this._reporter(runner);
-  runner.ignoreLeaks = options.ignoreLeaks;
-  if (options.grep) runner.grep(options.grep);
-  if (options.globals) runner.globals(options.globals);
-  if (options.growl) this.growl(runner, reporter);
-  return runner.run(fn);
-};
-
-}); // module: mocha.js
-
-require.register("reporters/base.js", function(module, exports, require){
-
-/**
- * Module dependencies.
- */
-
-var tty = require('browser/tty')
-  , diff = require('browser/diff');
-
-/**
- * Save timer references to avoid Sinon interfering (see GH-237).
- */
-
-var Date = global.Date
-  , setTimeout = global.setTimeout
-  , setInterval = global.setInterval
-  , clearTimeout = global.clearTimeout
-  , clearInterval = global.clearInterval;
-
-/**
- * Check if both stdio streams are associated with a tty.
- */
-
-var isatty = tty.isatty(1) && tty.isatty(2);
-
-/**
- * Expose `Base`.
- */
-
-exports = module.exports = Base;
-
-/**
- * Enable coloring by default.
- */
-
-exports.useColors = isatty;
-
-/**
- * Default color map.
- */
-
-exports.colors = {
-    'pass': 90
-  , 'fail': 31
-  , 'bright pass': 92
-  , 'bright fail': 91
-  , 'bright yellow': 93
-  , 'pending': 36
-  , 'suite': 0
-  , 'error title': 0
-  , 'error message': 31
-  , 'error stack': 90
-  , 'checkmark': 32
-  , 'fast': 90
-  , 'medium': 33
-  , 'slow': 31
-  , 'green': 32
-  , 'light': 90
-  , 'diff gutter': 90
-  , 'diff added': 42
-  , 'diff removed': 41
-};
-
-/**
- * Color `str` with the given `type`,
- * allowing colors to be disabled,
- * as well as user-defined color
- * schemes.
- *
- * @param {String} type
- * @param {String} str
- * @return {String}
- * @api private
- */
-
-var color = exports.color = function(type, str) {
-  if (!exports.useColors) return str;
-  return '\033[' + exports.colors[type] + 'm' + str + '\033[0m';
-};
-
-/**
- * Expose term window size, with some
- * defaults for when stderr is not a tty.
- */
-
-exports.window = {
-  width: isatty
-    ? process.stdout.getWindowSize
-      ? process.stdout.getWindowSize(1)[0]
-      : tty.getWindowSize()[1]
-    : 75
-};
-
-/**
- * Expose some basic cursor interactions
- * that are common among reporters.
- */
-
-exports.cursor = {
-  hide: function(){
-    process.stdout.write('\033[?25l');
-  },
-
-  show: function(){
-    process.stdout.write('\033[?25h');
-  },
-
-  deleteLine: function(){
-    process.stdout.write('\033[2K');
-  },
-
-  beginningOfLine: function(){
-    process.stdout.write('\033[0G');
-  },
-
-  CR: function(){
-    exports.cursor.deleteLine();
-    exports.cursor.beginningOfLine();
-  }
-};
-
-/**
- * A test is considered slow if it
- * exceeds the following value in milliseconds.
- */
-
-exports.slow = 75;
-
-/**
- * Outut the given `failures` as a list.
- *
- * @param {Array} failures
- * @api public
- */
-
-exports.list = function(failures){
-  console.error();
-  failures.forEach(function(test, i){
-    // format
-    var fmt = color('error title', '  %s) %s:\n')
-      + color('error message', '     %s')
-      + color('error stack', '\n%s\n');
-
-    // msg
-    var err = test.err
-      , message = err.message || ''
-      , stack = err.stack || message
-      , index = stack.indexOf(message) + message.length
-      , msg = stack.slice(0, index)
-      , actual = err.actual
-      , expected = err.expected;
-
-    // actual / expected diff
-    if ('string' == typeof actual && 'string' == typeof expected) {
-      var len = Math.max(actual.length, expected.length);
-
-      if (len < 20) msg = errorDiff(err, 'Chars');
-      else msg = errorDiff(err, 'Words');
-
-      // linenos
-      var lines = msg.split('\n');
-      if (lines.length > 4) {
-        var width = String(lines.length).length;
-        msg = lines.map(function(str, i){
-          return pad(++i, width) + ' |' + ' ' + str;
-        }).join('\n');
-      }
-
-      // legend
-      msg = '\n'
-        + color('diff removed', 'actual')
-        + ' '
-        + color('diff added', 'expected')
-        + '\n\n'
-        + msg
-        + '\n';
-
-      // indent
-      msg = msg.replace(/^/gm, '      ');
-
-      fmt = color('error title', '  %s) %s:\n%s')
-        + color('error stack', '\n%s\n');
-    }
-
-    // indent stack trace without msg
-    stack = stack.slice(index ? index + 1 : index)
-      .replace(/^/gm, '  ');
-
-    console.error(fmt, (i + 1), test.fullTitle(), msg, stack);
-  });
-};
-
-/**
- * Initialize a new `Base` reporter.
- *
- * All other reporters generally
- * inherit from this reporter, providing
- * stats such as test duration, number
- * of tests passed / failed etc.
- *
- * @param {Runner} runner
- * @api public
- */
-
-function Base(runner) {
-  var self = this
-    , stats = this.stats = { suites: 0, tests: 0, passes: 0, pending: 0, failures: 0 }
-    , failures = this.failures = [];
-
-  if (!runner) return;
-  this.runner = runner;
-
-  runner.on('start', function(){
-    stats.start = new Date;
-  });
-
-  runner.on('suite', function(suite){
-    stats.suites = stats.suites || 0;
-    suite.root || stats.suites++;
-  });
-
-  runner.on('test end', function(test){
-    stats.tests = stats.tests || 0;
-    stats.tests++;
-  });
-
-  runner.on('pass', function(test){
-    stats.passes = stats.passes || 0;
-
-    var medium = exports.slow / 2;
-    test.speed = test.duration > exports.slow
-      ? 'slow'
-      : test.duration > medium
-        ? 'medium'
-        : 'fast';
-
-    stats.passes++;
-  });
-
-  runner.on('fail', function(test, err){
-    stats.failures = stats.failures || 0;
-    stats.failures++;
-    test.err = err;
-    failures.push(test);
-  });
-
-  runner.on('end', function(){
-    stats.end = new Date;
-    stats.duration = new Date - stats.start;
-  });
-
-  runner.on('pending', function(){
-    stats.pending++;
-  });
-}
-
-/**
- * Output common epilogue used by many of
- * the bundled reporters.
- *
- * @api public
- */
-
-Base.prototype.epilogue = function(){
-  var stats = this.stats
-    , fmt
-    , tests;
-
-  console.log();
-
-  function pluralize(n) {
-    return 1 == n ? 'test' : 'tests';
-  }
-
-  // failure
-  if (stats.failures) {
-    fmt = color('bright fail', '  ✖')
-      + color('fail', ' %d of %d %s failed')
-      + color('light', ':')
-
-    console.error(fmt,
-      stats.failures,
-      this.runner.total,
-      pluralize(this.runner.total));
-
-    Base.list(this.failures);
-    console.error();
-    return;
-  }
-
-  // pass
-  fmt = color('bright pass', '  ✔')
-    + color('green', ' %d %s complete')
-    + color('light', ' (%dms)');
-
-  console.log(fmt,
-    stats.tests || 0,
-    pluralize(stats.tests),
-    stats.duration);
-
-  // pending
-  if (stats.pending) {
-    fmt = color('pending', '  •')
-      + color('pending', ' %d %s pending');
-
-    console.log(fmt, stats.pending, pluralize(stats.pending));
-  }
-
-  console.log();
-};
-
-/**
- * Pad the given `str` to `len`.
- *
- * @param {String} str
- * @param {String} len
- * @return {String}
- * @api private
- */
-
-function pad(str, len) {
-  str = String(str);
-  return Array(len - str.length + 1).join(' ') + str;
-}
-
-/**
- * Return a character diff for `err`.
- *
- * @param {Error} err
- * @return {String}
- * @api private
- */
-
-function errorDiff(err, type) {
-  return diff['diff' + type](err.actual, err.expected).map(function(str){
-    if (/^(\n+)$/.test(str.value)) str.value = Array(++RegExp.$1.length).join('<newline>');
-    if (str.added) return colorLines('diff added', str.value);
-    if (str.removed) return colorLines('diff removed', str.value);
-    return str.value;
-  }).join('');
-}
-
-/**
- * Color lines for `str`, using the color `name`.
- *
- * @param {String} name
- * @param {String} str
- * @return {String}
- * @api private
- */
-
-function colorLines(name, str) {
-  return str.split('\n').map(function(str){
-    return color(name, str);
-  }).join('\n');
-}
-
-}); // module: reporters/base.js
-
-require.register("reporters/doc.js", function(module, exports, require){
-
-/**
- * Module dependencies.
- */
-
-var Base = require('./base')
-  , utils = require('../utils');
-
-/**
- * Expose `Doc`.
- */
-
-exports = module.exports = Doc;
-
-/**
- * Initialize a new `Doc` reporter.
- *
- * @param {Runner} runner
- * @api public
- */
-
-function Doc(runner) {
-  Base.call(this, runner);
-
-  var self = this
-    , stats = this.stats
-    , total = runner.total
-    , indents = 2;
-
-  function indent() {
-    return Array(indents).join('  ');
-  }
-
-  runner.on('suite', function(suite){
-    if (suite.root) return;
-    ++indents;
-    console.log('%s<section class="suite">', indent());
-    ++indents;
-    console.log('%s<h1>%s</h1>', indent(), suite.title);
-    console.log('%s<dl>', indent());
-  });
-
-  runner.on('suite end', function(suite){
-    if (suite.root) return;
-    console.log('%s</dl>', indent());
-    --indents;
-    console.log('%s</section>', indent());
-    --indents;
-  });
-
-  runner.on('pass', function(test){
-    console.log('%s  <dt>%s</dt>', indent(), test.title);
-    var code = utils.escape(utils.clean(test.fn.toString()));
-    console.log('%s  <dd><pre><code>%s</code></pre></dd>', indent(), code);
-  });
-}
-
-}); // module: reporters/doc.js
-
-require.register("reporters/dot.js", function(module, exports, require){
-
-/**
- * Module dependencies.
- */
-
-var Base = require('./base')
-  , color = Base.color;
-
-/**
- * Expose `Dot`.
- */
-
-exports = module.exports = Dot;
-
-/**
- * Initialize a new `Dot` matrix test reporter.
- *
- * @param {Runner} runner
- * @api public
- */
-
-function Dot(runner) {
-  Base.call(this, runner);
-
-  var self = this
-    , stats = this.stats
-    , width = Base.window.width * .75 | 0
-    , n = 0;
-
-  runner.on('start', function(){
-    process.stdout.write('\n  ');
-  });
-
-  runner.on('pending', function(test){
-    process.stdout.write(color('pending', '.'));
-  });
-
-  runner.on('pass', function(test){
-    if (++n % width == 0) process.stdout.write('\n  ');
-    if ('slow' == test.speed) {
-      process.stdout.write(color('bright yellow', '.'));
-    } else {
-      process.stdout.write(color(test.speed, '.'));
-    }
-  });
-
-  runner.on('fail', function(test, err){
-    if (++n % width == 0) process.stdout.write('\n  ');
-    process.stdout.write(color('fail', '.'));
-  });
-
-  runner.on('end', function(){
-    console.log();
-    self.epilogue();
-  });
-}
-
-/**
- * Inherit from `Base.prototype`.
- */
-
-Dot.prototype = new Base;
-Dot.prototype.constructor = Dot;
-
-}); // module: reporters/dot.js
-
-require.register("reporters/html-cov.js", function(module, exports, require){
-
-/**
- * Module dependencies.
- */
-
-var JSONCov = require('./json-cov')
-  , fs = require('browser/fs');
-
-/**
- * Expose `HTMLCov`.
- */
-
-exports = module.exports = HTMLCov;
-
-/**
- * Initialize a new `JsCoverage` reporter.
- *
- * @param {Runner} runner
- * @api public
- */
-
-function HTMLCov(runner) {
-  var jade = require('jade')
-    , file = __dirname + '/templates/coverage.jade'
-    , str = fs.readFileSync(file, 'utf8')
-    , fn = jade.compile(str, { filename: file })
-    , self = this;
-
-  JSONCov.call(this, runner, false);
-
-  runner.on('end', function(){
-    process.stdout.write(fn({
-        cov: self.cov
-      , coverageClass: coverageClass
-    }));
-  });
-}
-
-/**
- * Return coverage class for `n`.
- *
- * @return {String}
- * @api private
- */
-
-function coverageClass(n) {
-  if (n >= 75) return 'high';
-  if (n >= 50) return 'medium';
-  if (n >= 25) return 'low';
-  return 'terrible';
-}
-}); // module: reporters/html-cov.js
-
-require.register("reporters/html.js", function(module, exports, require){
-
-/**
- * Module dependencies.
- */
-
-var Base = require('./base')
-  , utils = require('../utils')
-  , Progress = require('../browser/progress')
-  , escape = utils.escape;
-
-/**
- * Save timer references to avoid Sinon interfering (see GH-237).
- */
-
-var Date = global.Date
-  , setTimeout = global.setTimeout
-  , setInterval = global.setInterval
-  , clearTimeout = global.clearTimeout
-  , clearInterval = global.clearInterval;
-
-/**
- * Expose `Doc`.
- */
-
-exports = module.exports = HTML;
-
-/**
- * Stats template.
- */
-
-var statsTemplate = '<ul id="stats">'
-  + '<li class="progress"><canvas width="40" height="40"></canvas></li>'
-  + '<li class="passes">passes: <em>0</em></li>'
-  + '<li class="failures">failures: <em>0</em></li>'
-  + '<li class="duration">duration: <em>0</em>s</li>'
-  + '</ul>';
-
-/**
- * Initialize a new `Doc` reporter.
- *
- * @param {Runner} runner
- * @api public
- */
-
-function HTML(runner) {
-  Base.call(this, runner);
-
-  var self = this
-    , stats = this.stats
-    , total = runner.total
-    , root = document.getElementById('mocha')
-    , stat = fragment(statsTemplate)
-    , items = stat.getElementsByTagName('li')
-    , passes = items[1].getElementsByTagName('em')[0]
-    , failures = items[2].getElementsByTagName('em')[0]
-    , duration = items[3].getElementsByTagName('em')[0]
-    , canvas = stat.getElementsByTagName('canvas')[0]
-    , report = fragment('<ul id="report"></ul>')
-    , stack = [report]
-    , progress
-    , ctx
-
-  if (canvas.getContext) {
-    ctx = canvas.getContext('2d');
-    progress = new Progress;
-  }
-
-  if (!root) return error('#mocha div missing, add it to your document');
-
-  root.appendChild(stat);
-  root.appendChild(report);
-
-  if (progress) progress.size(40);
-
-  runner.on('suite', function(suite){
-    if (suite.root) return;
-
-    // suite
-    var url = location.protocol + '//' + location.host + location.pathname + '?grep=^' + utils.escapeRegexp(suite.fullTitle());
-    var el = fragment('<li class="suite"><h1><a href="%s">%s</a></h1></li>', url, suite.title);
-
-    // container
-    stack[0].appendChild(el);
-    stack.unshift(document.createElement('ul'));
-    el.appendChild(stack[0]);
-  });
-
-  runner.on('suite end', function(suite){
-    if (suite.root) return;
-    stack.shift();
-  });
-
-  runner.on('fail', function(test, err){
-    if ('hook' == test.type || err.uncaught) runner.emit('test end', test);
-  });
-
-  runner.on('test end', function(test){
-    // TODO: add to stats
-    var percent = stats.tests / total * 100 | 0;
-    if (progress) progress.update(percent).draw(ctx);
-
-    // update stats
-    var ms = new Date - stats.start;
-    text(passes, stats.passes);
-    text(failures, stats.failures);
-    text(duration, (ms / 1000).toFixed(2));
-
-    // test
-    if ('passed' == test.state) {
-      var el = fragment('<li class="test pass %e"><h2>%e<span class="duration">%ems</span></h2></li>', test.speed, test.title, test.duration);
-    } else if (test.pending) {
-      var el = fragment('<li class="test pass pending"><h2>%e</h2></li>', test.title);
-    } else {
-      var el = fragment('<li class="test fail"><h2>%e</h2></li>', test.title);
-      var str = test.err.stack || test.err.toString();
-
-      // FF / Opera do not add the message
-      if (!~str.indexOf(test.err.message)) {
-        str = test.err.message + '\n' + str;
-      }
-
-      // <=IE7 stringifies to [Object Error]. Since it can be overloaded, we
-      // check for the result of the stringifying.
-      if ('[object Error]' == str) str = test.err.message;
-
-      // Safari doesn't give you a stack. Let's at least provide a source line.
-      if (!test.err.stack && test.err.sourceURL && test.err.line !== undefined) {
-        str += "\n(" + test.err.sourceURL + ":" + test.err.line + ")";
-      }
-
-      el.appendChild(fragment('<pre class="error">%e</pre>', str));
-    }
-
-    // toggle code
-    var h2 = el.getElementsByTagName('h2')[0];
-
-    on(h2, 'click', function(){
-      pre.style.display = 'none' == pre.style.display
-        ? 'block'
-        : 'none';
-    });
-
-    // code
-    // TODO: defer
-    if (!test.pending) {
-      var pre = fragment('<pre><code>%e</code></pre>', utils.clean(test.fn.toString()));
-      el.appendChild(pre);
-      pre.style.display = 'none';
-    }
-
-    stack[0].appendChild(el);
-  });
-}
-
-/**
- * Display error `msg`.
- */
-
-function error(msg) {
-  document.body.appendChild(fragment('<div id="error">%s</div>', msg));
-}
-
-/**
- * Return a DOM fragment from `html`.
- */
-
-function fragment(html) {
-  var args = arguments
-    , div = document.createElement('div')
-    , i = 1;
-
-  div.innerHTML = html.replace(/%([se])/g, function(_, type){
-    switch (type) {
-      case 's': return String(args[i++]);
-      case 'e': return escape(args[i++]);
-    }
-  });
-
-  return div.firstChild;
-}
-
-/**
- * Set `el` text to `str`.
- */
-
-function text(el, str) {
-  if (el.textContent) {
-    el.textContent = str;
-  } else {
-    el.innerText = str;
-  }
-}
-
-/**
- * Listen on `event` with callback `fn`.
- */
-
-function on(el, event, fn) {
-  if (el.addEventListener) {
-    el.addEventListener(event, fn, false);
-  } else {
-    el.attachEvent('on' + event, fn);
-  }
-}
-}); // module: reporters/html.js
-
-require.register("reporters/index.js", function(module, exports, require){
-
-exports.Base = require('./base');
-exports.Dot = require('./dot');
-exports.Doc = require('./doc');
-exports.TAP = require('./tap');
-exports.JSON = require('./json');
-exports.HTML = require('./html');
-exports.List = require('./list');
-exports.Min = require('./min');
-exports.Spec = require('./spec');
-exports.Progress = require('./progress');
-exports.Landing = require('./landing');
-exports.JSONCov = require('./json-cov');
-exports.HTMLCov = require('./html-cov');
-exports.JSONStream = require('./json-stream');
-exports.XUnit = require('./xunit')
-exports.Teamcity = require('./teamcity')
-
-}); // module: reporters/index.js
-
-require.register("reporters/json-cov.js", function(module, exports, require){
-
-/**
- * Module dependencies.
- */
-
-var Base = require('./base');
-
-/**
- * Expose `JSONCov`.
- */
-
-exports = module.exports = JSONCov;
-
-/**
- * Initialize a new `JsCoverage` reporter.
- *
- * @param {Runner} runner
- * @param {Boolean} output
- * @api public
- */
-
-function JSONCov(runner, output) {
-  var self = this
-    , output = 1 == arguments.length ? true : output;
-
-  Base.call(this, runner);
-
-  var tests = []
-    , failures = []
-    , passes = [];
-
-  runner.on('test end', function(test){
-    tests.push(test);
-  });
-
-  runner.on('pass', function(test){
-    passes.push(test);
-  });
-
-  runner.on('fail', function(test){
-    failures.push(test);
-  });
-
-  runner.on('end', function(){
-    var cov = global._$jscoverage || {};
-    var result = self.cov = map(cov);
-    result.stats = self.stats;
-    result.tests = tests.map(clean);
-    result.failures = failures.map(clean);
-    result.passes = passes.map(clean);
-    if (!output) return;
-    process.stdout.write(JSON.stringify(result, null, 2 ));
-  });
-}
-
-/**
- * Map jscoverage data to a JSON structure
- * suitable for reporting.
- *
- * @param {Object} cov
- * @return {Object}
- * @api private
- */
-
-function map(cov) {
-  var ret = {
-      instrumentation: 'node-jscoverage'
-    , sloc: 0
-    , hits: 0
-    , misses: 0
-    , coverage: 0
-    , files: []
-  };
-
-  for (var filename in cov) {
-    var data = coverage(filename, cov[filename]);
-    ret.files.push(data);
-    ret.hits += data.hits;
-    ret.misses += data.misses;
-    ret.sloc += data.sloc;
-  }
-
-  if (ret.sloc > 0) {
-    ret.coverage = (ret.hits / ret.sloc) * 100;
-  }
-
-  return ret;
-};
-
-/**
- * Map jscoverage data for a single source file
- * to a JSON structure suitable for reporting.
- *
- * @param {String} filename name of the source file
- * @param {Object} data jscoverage coverage data
- * @return {Object}
- * @api private
- */
-
-function coverage(filename, data) {
-  var ret = {
-    filename: filename,
-    coverage: 0,
-    hits: 0,
-    misses: 0,
-    sloc: 0,
-    source: {}
-  };
-
-  data.source.forEach(function(line, num){
-    num++;
-
-    if (data[num] === 0) {
-      ret.misses++;
-      ret.sloc++;
-    } else if (data[num] !== undefined) {
-      ret.hits++;
-      ret.sloc++;
-    }
-
-    ret.source[num] = {
-        source: line
-      , coverage: data[num] === undefined
-        ? ''
-        : data[num]
-    };
-  });
-
-  ret.coverage = ret.hits / ret.sloc * 100;
-
-  return ret;
-}
-
-/**
- * Return a plain-object representation of `test`
- * free of cyclic properties etc.
- *
- * @param {Object} test
- * @return {Object}
- * @api private
- */
-
-function clean(test) {
-  return {
-      title: test.title
-    , fullTitle: test.fullTitle()
-    , duration: test.duration
-  }
-}
-
-}); // module: reporters/json-cov.js
-
-require.register("reporters/json-stream.js", function(module, exports, require){
-
-/**
- * Module dependencies.
- */
-
-var Base = require('./base')
-  , color = Base.color;
-
-/**
- * Expose `List`.
- */
-
-exports = module.exports = List;
-
-/**
- * Initialize a new `List` test reporter.
- *
- * @param {Runner} runner
- * @api public
- */
-
-function List(runner) {
-  Base.call(this, runner);
-
-  var self = this
-    , stats = this.stats
-    , total = runner.total;
-
-  runner.on('start', function(){
-    console.log(JSON.stringify(['start', { total: total }]));
-  });
-
-  runner.on('pass', function(test){
-    console.log(JSON.stringify(['pass', clean(test)]));
-  });
-
-  runner.on('fail', function(test, err){
-    console.log(JSON.stringify(['fail', clean(test)]));
-  });
-
-  runner.on('end', function(){
-    process.stdout.write(JSON.stringify(['end', self.stats]));
-  });
-}
-
-/**
- * Return a plain-object representation of `test`
- * free of cyclic properties etc.
- *
- * @param {Object} test
- * @return {Object}
- * @api private
- */
-
-function clean(test) {
-  return {
-      title: test.title
-    , fullTitle: test.fullTitle()
-    , duration: test.duration
-  }
-}
-}); // module: reporters/json-stream.js
-
-require.register("reporters/json.js", function(module, exports, require){
-
-/**
- * Module dependencies.
- */
-
-var Base = require('./base')
-  , cursor = Base.cursor
-  , color = Base.color;
-
-/**
- * Expose `JSON`.
- */
-
-exports = module.exports = JSONReporter;
-
-/**
- * Initialize a new `JSON` reporter.
- *
- * @param {Runner} runner
- * @api public
- */
-
-function JSONReporter(runner) {
-  var self = this;
-  Base.call(this, runner);
-
-  var tests = []
-    , failures = []
-    , passes = [];
-
-  runner.on('test end', function(test){
-    tests.push(test);
-  });
-
-  runner.on('pass', function(test){
-    passes.push(test);
-  });
-
-  runner.on('fail', function(test){
-    failures.push(test);
-  });
-
-  runner.on('end', function(){
-    var obj = {
-        stats: self.stats
-      , tests: tests.map(clean)
-      , failures: failures.map(clean)
-      , passes: passes.map(clean)
-    };
-
-    process.stdout.write(JSON.stringify(obj, null, 2));
-  });
-}
-
-/**
- * Return a plain-object representation of `test`
- * free of cyclic properties etc.
- *
- * @param {Object} test
- * @return {Object}
- * @api private
- */
-
-function clean(test) {
-  return {
-      title: test.title
-    , fullTitle: test.fullTitle()
-    , duration: test.duration
-  }
-}
-}); // module: reporters/json.js
-
-require.register("reporters/landing.js", function(module, exports, require){
-
-/**
- * Module dependencies.
- */
-
-var Base = require('./base')
-  , cursor = Base.cursor
-  , color = Base.color;
-
-/**
- * Expose `Landing`.
- */
-
-exports = module.exports = Landing;
-
-/**
- * Airplane color.
- */
-
-Base.colors.plane = 0;
-
-/**
- * Airplane crash color.
- */
-
-Base.colors['plane crash'] = 31;
-
-/**
- * Runway color.
- */
-
-Base.colors.runway = 90;
-
-/**
- * Initialize a new `Landing` reporter.
- *
- * @param {Runner} runner
- * @api public
- */
-
-function Landing(runner) {
-  Base.call(this, runner);
-
-  var self = this
-    , stats = this.stats
-    , width = Base.window.width * .75 | 0
-    , total = runner.total
-    , stream = process.stdout
-    , plane = color('plane', '✈')
-    , crashed = -1
-    , n = 0;
-
-  function runway() {
-    var buf = Array(width).join('-');
-    return '  ' + color('runway', buf);
-  }
-
-  runner.on('start', function(){
-    stream.write('\n  ');
-    cursor.hide();
-  });
-
-  runner.on('test end', function(test){
-    // check if the plane crashed
-    var col = -1 == crashed
-      ? width * ++n / total | 0
-      : crashed;
-
-    // show the crash
-    if ('failed' == test.state) {
-      plane = color('plane crash', '✈');
-      crashed = col;
-    }
-
-    // render landing strip
-    stream.write('\033[4F\n\n');
-    stream.write(runway());
-    stream.write('\n  ');
-    stream.write(color('runway', Array(col).join('⋅')));
-    stream.write(plane)
-    stream.write(color('runway', Array(width - col).join('⋅') + '\n'));
-    stream.write(runway());
-    stream.write('\033[0m');
-  });
-
-  runner.on('end', function(){
-    cursor.show();
-    console.log();
-    self.epilogue();
-  });
-}
-
-/**
- * Inherit from `Base.prototype`.
- */
-
-Landing.prototype = new Base;
-Landing.prototype.constructor = Landing;
-
-}); // module: reporters/landing.js
-
-require.register("reporters/list.js", function(module, exports, require){
-
-/**
- * Module dependencies.
- */
-
-var Base = require('./base')
-  , cursor = Base.cursor
-  , color = Base.color;
-
-/**
- * Expose `List`.
- */
-
-exports = module.exports = List;
-
-/**
- * Initialize a new `List` test reporter.
- *
- * @param {Runner} runner
- * @api public
- */
-
-function List(runner) {
-  Base.call(this, runner);
-
-  var self = this
-    , stats = this.stats
-    , n = 0;
-
-  runner.on('start', function(){
-    console.log();
-  });
-
-  runner.on('test', function(test){
-    process.stdout.write(color('pass', '    ' + test.fullTitle() + ': '));
-  });
-
-  runner.on('pending', function(test){
-    var fmt = color('checkmark', '  -')
-      + color('pending', ' %s');
-    console.log(fmt, test.fullTitle());
-  });
-
-  runner.on('pass', function(test){
-    var fmt = color('checkmark', '  ✓')
-      + color('pass', ' %s: ')
-      + color(test.speed, '%dms');
-    cursor.CR();
-    console.log(fmt, test.fullTitle(), test.duration);
-  });
-
-  runner.on('fail', function(test, err){
-    cursor.CR();
-    console.log(color('fail', '  %d) %s'), ++n, test.fullTitle());
-  });
-
-  runner.on('end', self.epilogue.bind(self));
-}
-
-/**
- * Inherit from `Base.prototype`.
- */
-
-List.prototype = new Base;
-List.prototype.constructor = List;
-
-
-}); // module: reporters/list.js
-
-require.register("reporters/markdown.js", function(module, exports, require){
-
-/**
- * Module dependencies.
- */
-
-var Base = require('./base')
-  , utils = require('../utils');
-
-/**
- * Expose `Markdown`.
- */
-
-exports = module.exports = Markdown;
-
-/**
- * Initialize a new `Markdown` reporter.
- *
- * @param {Runner} runner
- * @api public
- */
-
-function Markdown(runner) {
-  Base.call(this, runner);
-
-  var self = this
-    , stats = this.stats
-    , total = runner.total
-    , level = 0
-    , buf = '';
-
-  function title(str) {
-    return Array(level).join('#') + ' ' + str;
-  }
-
-  function indent() {
-    return Array(level).join('  ');
-  }
-
-  function mapTOC(suite, obj) {
-    var ret = obj;
-    obj = obj[suite.title] = obj[suite.title] || { suite: suite };
-    suite.suites.forEach(function(suite){
-      mapTOC(suite, obj);
-    });
-    return ret;
-  }
-
-  function stringifyTOC(obj, level) {
-    ++level;
-    var buf = '';
-    var link;
-    for (var key in obj) {
-      if ('suite' == key) continue;
-      if (key) link = ' - [' + key + '](#' + utils.slug(obj[key].suite.fullTitle()) + ')\n';
-      if (key) buf += Array(level).join('  ') + link;
-      buf += stringifyTOC(obj[key], level);
-    }
-    --level;
-    return buf;
-  }
-
-  function generateTOC(suite) {
-    var obj = mapTOC(suite, {});
-    return stringifyTOC(obj, 0);
-  }
-
-  generateTOC(runner.suite);
-
-  runner.on('suite', function(suite){
-    ++level;
-    var slug = utils.slug(suite.fullTitle());
-    buf += '<a name="' + slug + '" />' + '\n';
-    buf += title(suite.title) + '\n';
-  });
-
-  runner.on('suite end', function(suite){
-    --level;
-  });
-
-  runner.on('pass', function(test){
-    var code = utils.clean(test.fn.toString());
-    buf += test.title + '.\n';
-    buf += '\n```js';
-    buf += code + '\n';
-    buf += '```\n\n';
-  });
-
-  runner.on('end', function(){
-    process.stdout.write('# TOC\n');
-    process.stdout.write(generateTOC(runner.suite));
-    process.stdout.write(buf);
-  });
-}
-}); // module: reporters/markdown.js
-
-require.register("reporters/min.js", function(module, exports, require){
-/**
- * Module dependencies.
- */
-
-var Base = require('./base');
-
-/**
- * Expose `Min`.
- */
-
-exports = module.exports = Min;
-
-/**
- * Initialize a new `Min` minimal test reporter (best used with --watch).
- *
- * @param {Runner} runner
- * @api public
- */
-
-function Min(runner) {
-  Base.call(this, runner);
-
-  runner.on('start', function(){
-    // clear screen
-    process.stdout.write('\033[2J');
-    // set cursor position
-    process.stdout.write('\033[1;3H');
-  });
-
-  runner.on('end', this.epilogue.bind(this));
-}
-
-/**
- * Inherit from `Base.prototype`.
- */
-
-Min.prototype = new Base;
-Min.prototype.constructor = Min;
-
-}); // module: reporters/min.js
-
-require.register("reporters/nyan.js", function(module, exports, require){
-
-/**
- * Module dependencies.
- */
-
-var Base = require('./base')
-  , color = Base.color;
-
-/**
- * Expose `Dot`.
- */
-
-exports = module.exports = NyanCat;
-
-/**
- * Initialize a new `Dot` matrix test reporter.
- *
- * @param {Runner} runner
- * @api public
- */
-
-function NyanCat(runner) {
-  Base.call(this, runner);
-
-  var self = this
-    , stats = this.stats
-    , width = Base.window.width * .75 | 0
-    , rainbowColors = this.rainbowColors = self.generateColors()
-    , colorIndex = this.colorIndex = 0
-    , numerOfLines = this.numberOfLines = 4
-    , trajectories = this.trajectories = [[], [], [], []]
-    , nyanCatWidth = this.nyanCatWidth = 11
-    , trajectoryWidthMax = this.trajectoryWidthMax = (width - nyanCatWidth)
-    , scoreboardWidth = this.scoreboardWidth = 5
-    , tick = this.tick = 0
-    , n = 0;
-
-  runner.on('start', function(){
-    Base.cursor.hide();
-    self.draw('start');
-  });
-
-  runner.on('pending', function(test){
-    self.draw('pending');
-  });
-
-  runner.on('pass', function(test){
-    self.draw('pass');
-  });
-
-  runner.on('fail', function(test, err){
-    self.draw('fail');
-  });
-
-  runner.on('end', function(){
-    Base.cursor.show();
-    for (var i = 0; i < self.numberOfLines; i++) write('\n');
-    self.epilogue();
-  });
-}
-
-/**
- * Draw the nyan cat with runner `status`.
- *
- * @param {String} status
- * @api private
- */
-
-NyanCat.prototype.draw = function(status){
-  this.appendRainbow();
-  this.drawScoreboard();
-  this.drawRainbow();
-  this.drawNyanCat(status);
-  this.tick = !this.tick;
-};
-
-/**
- * Draw the "scoreboard" showing the number
- * of passes, failures and pending tests.
- *
- * @api private
- */
-
-NyanCat.prototype.drawScoreboard = function(){
-  var stats = this.stats;
-  var colors = Base.colors;
-
-  function draw(color, n) {
-    write(' ');
-    write('\033[' + color + 'm' + n + '\033[0m');
-    write('\n');
-  }
-
-  draw(colors.green, stats.passes);
-  draw(colors.fail, stats.failures);
-  draw(colors.pending, stats.pending);
-  write('\n');
-
-  this.cursorUp(this.numberOfLines);
-};
-
-/**
- * Append the rainbow.
- *
- * @api private
- */
-
-NyanCat.prototype.appendRainbow = function(){
-  var segment = this.tick ? '_' : '-';
-  var rainbowified = this.rainbowify(segment);
-
-  for (var index = 0; index < this.numberOfLines; index++) {
-    var trajectory = this.trajectories[index];
-    if (trajectory.length >= this.trajectoryWidthMax) trajectory.shift();
-    trajectory.push(rainbowified);
-  }
-};
-
-/**
- * Draw the rainbow.
- *
- * @api private
- */
-
-NyanCat.prototype.drawRainbow = function(){
-  var self = this;
-
-  this.trajectories.forEach(function(line, index) {
-    write('\033[' + self.scoreboardWidth + 'C');
-    write(line.join(''));
-    write('\n');
-  });
-
-  this.cursorUp(this.numberOfLines);
-};
-
-/**
- * Draw the nyan cat with `status`.
- *
- * @param {String} status
- * @api private
- */
-
-NyanCat.prototype.drawNyanCat = function(status) {
-  var self = this;
-  var startWidth = this.scoreboardWidth + this.trajectories[0].length;
-
-  [0, 1, 2, 3].forEach(function(index) {
-    write('\033[' + startWidth + 'C');
-
-    switch (index) {
-      case 0:
-        write('_,------,');
-        write('\n');
-        break;
-      case 1:
-        var padding = self.tick ? '  ' : '   ';
-        write('_|' + padding + '/\\_/\\');
-        write('\n');
-        break;
-      case 2:
-        var padding = self.tick ? '_' : '__';
-        var tail = self.tick ? '~' : '^';
-        var face;
-        switch (status) {
-          case 'pass':
-            face = '( ^ .^)';
-            break;
-          case 'fail':
-            face = '( o .o)';
-            break;
-          default:
-            face = '( - .-)';
-        }
-        write(tail + '|' + padding + face);
-        write('\n');
-        break;
-      case 3:
-        var padding = self.tick ? ' ' : '  ';
-        write(padding + '""  ""');
-        write('\n');
-        break;
-    }
-  });
-
-  this.cursorUp(this.numberOfLines);
-};
-
-/**
- * Move cursor up `n`.
- *
- * @param {Number} n
- * @api private
- */
-
-NyanCat.prototype.cursorUp = function(n) {
-  write('\033[' + n + 'A');
-};
-
-/**
- * Move cursor down `n`.
- *
- * @param {Number} n
- * @api private
- */
-
-NyanCat.prototype.cursorDown = function(n) {
-  write('\033[' + n + 'B');
-};
-
-/**
- * Generate rainbow colors.
- *
- * @return {Array}
- * @api private
- */
-
-NyanCat.prototype.generateColors = function(){
-  var colors = [];
-
-  for (var i = 0; i < (6 * 7); i++) {
-    var pi3 = Math.floor(Math.PI / 3);
-    var n = (i * (1.0 / 6));
-    var r = Math.floor(3 * Math.sin(n) + 3);
-    var g = Math.floor(3 * Math.sin(n + 2 * pi3) + 3);
-    var b = Math.floor(3 * Math.sin(n + 4 * pi3) + 3);
-    colors.push(36 * r + 6 * g + b + 16);
-  }
-
-  return colors;
-};
-
-/**
- * Apply rainbow to the given `str`.
- *
- * @param {String} str
- * @return {String}
- * @api private
- */
-
-NyanCat.prototype.rainbowify = function(str){
-  var color = this.rainbowColors[this.colorIndex % this.rainbowColors.length];
-  this.colorIndex += 1;
-  return '\033[38;5;' + color + 'm' + str + '\033[0m';
-};
-
-/**
- * Stdout helper.
- */
-
-function write(string) {
-  process.stdout.write(string);
-}
-
-/**
- * Inherit from `Base.prototype`.
- */
-
-NyanCat.prototype = new Base;
-NyanCat.prototype.constructor = NyanCat;
-
-
-}); // module: reporters/nyan.js
-
-require.register("reporters/progress.js", function(module, exports, require){
-
-/**
- * Module dependencies.
- */
-
-var Base = require('./base')
-  , cursor = Base.cursor
-  , color = Base.color;
-
-/**
- * Expose `Progress`.
- */
-
-exports = module.exports = Progress;
-
-/**
- * General progress bar color.
- */
-
-Base.colors.progress = 90;
-
-/**
- * Initialize a new `Progress` bar test reporter.
- *
- * @param {Runner} runner
- * @param {Object} options
- * @api public
- */
-
-function Progress(runner, options) {
-  Base.call(this, runner);
-
-  var self = this
-    , options = options || {}
-    , stats = this.stats
-    , width = Base.window.width * .50 | 0
-    , total = runner.total
-    , complete = 0
-    , max = Math.max;
-
-  // default chars
-  options.open = options.open || '[';
-  options.complete = options.complete || '▬';
-  options.incomplete = options.incomplete || '⋅';
-  options.close = options.close || ']';
-  options.verbose = false;
-
-  // tests started
-  runner.on('start', function(){
-    console.log();
-    cursor.hide();
-  });
-
-  // tests complete
-  runner.on('test end', function(){
-    complete++;
-    var incomplete = total - complete
-      , percent = complete / total
-      , n = width * percent | 0
-      , i = width - n;
-
-    cursor.CR();
-    process.stdout.write('\033[J');
-    process.stdout.write(color('progress', '  ' + options.open));
-    process.stdout.write(Array(n).join(options.complete));
-    process.stdout.write(Array(i).join(options.incomplete));
-    process.stdout.write(color('progress', options.close));
-    if (options.verbose) {
-      process.stdout.write(color('progress', ' ' + complete + ' of ' + total));
-    }
-  });
-
-  // tests are complete, output some stats
-  // and the failures if any
-  runner.on('end', function(){
-    cursor.show();
-    console.log();
-    self.epilogue();
-  });
-}
-
-/**
- * Inherit from `Base.prototype`.
- */
-
-Progress.prototype = new Base;
-Progress.prototype.constructor = Progress;
-
-
-}); // module: reporters/progress.js
-
-require.register("reporters/spec.js", function(module, exports, require){
-
-/**
- * Module dependencies.
- */
-
-var Base = require('./base')
-  , cursor = Base.cursor
-  , color = Base.color;
-
-/**
- * Expose `Spec`.
- */
-
-exports = module.exports = Spec;
-
-/**
- * Initialize a new `Spec` test reporter.
- *
- * @param {Runner} runner
- * @api public
- */
-
-function Spec(runner) {
-  Base.call(this, runner);
-
-  var self = this
-    , stats = this.stats
-    , indents = 0
-    , n = 0;
-
-  function indent() {
-    return Array(indents).join('  ')
-  }
-
-  runner.on('start', function(){
-    console.log();
-  });
-
-  runner.on('suite', function(suite){
-    ++indents;
-    console.log(color('suite', '%s%s'), indent(), suite.title);
-  });
-
-  runner.on('suite end', function(suite){
-    --indents;
-    if (1 == indents) console.log();
-  });
-
-  runner.on('test', function(test){
-    process.stdout.write(indent() + color('pass', '  ◦ ' + test.title + ': '));
-  });
-
-  runner.on('pending', function(test){
-    var fmt = indent() + color('pending', '  - %s');
-    console.log(fmt, test.title);
-  });
-
-  runner.on('pass', function(test){
-    if ('fast' == test.speed) {
-      var fmt = indent()
-        + color('checkmark', '  ✓')
-        + color('pass', ' %s ');
-      cursor.CR();
-      console.log(fmt, test.title);
-    } else {
-      var fmt = indent()
-        + color('checkmark', '  ✓')
-        + color('pass', ' %s ')
-        + color(test.speed, '(%dms)');
-      cursor.CR();
-      console.log(fmt, test.title, test.duration);
-    }
-  });
-
-  runner.on('fail', function(test, err){
-    cursor.CR();
-    console.log(indent() + color('fail', '  %d) %s'), ++n, test.title);
-  });
-
-  runner.on('end', self.epilogue.bind(self));
-}
-
-/**
- * Inherit from `Base.prototype`.
- */
-
-Spec.prototype = new Base;
-Spec.prototype.constructor = Spec;
-
-
-}); // module: reporters/spec.js
-
-require.register("reporters/tap.js", function(module, exports, require){
-
-/**
- * Module dependencies.
- */
-
-var Base = require('./base')
-  , cursor = Base.cursor
-  , color = Base.color;
-
-/**
- * Expose `TAP`.
- */
-
-exports = module.exports = TAP;
-
-/**
- * Initialize a new `TAP` reporter.
- *
- * @param {Runner} runner
- * @api public
- */
-
-function TAP(runner) {
-  Base.call(this, runner);
-
-  var self = this
-    , stats = this.stats
-    , total = runner.total
-    , n = 1;
-
-  runner.on('start', function(){
-    console.log('%d..%d', 1, total);
-  });
-
-  runner.on('test end', function(){
-    ++n;
-  });
-
-  runner.on('pending', function(test){
-    console.log('ok %d %s # SKIP -', n, title(test));
-  });
-
-  runner.on('pass', function(test){
-    console.log('ok %d %s', n, title(test));
-  });
-
-  runner.on('fail', function(test, err){
-    console.log('not ok %d %s', n, title(test));
-    console.log(err.stack.replace(/^/gm, '  '));
-  });
-}
-
-/**
- * Return a TAP-safe title of `test`
- *
- * @param {Object} test
- * @return {String}
- * @api private
- */
-
-function title(test) {
-  return test.fullTitle().replace(/#/g, '');
-}
-
-}); // module: reporters/tap.js
-
-require.register("reporters/teamcity.js", function(module, exports, require){
-
-/**
- * Module dependencies.
- */
-
-var Base = require('./base');
-
-/**
- * Expose `Teamcity`.
- */
-
-exports = module.exports = Teamcity;
-
-/**
- * Initialize a new `Teamcity` reporter.
- *
- * @param {Runner} runner
- * @api public
- */
-
-function Teamcity(runner) {
-  Base.call(this, runner);
-  var stats = this.stats;
-
-  runner.on('start', function() {
-    console.log("##teamcity[testSuiteStarted name='mocha.suite']");
-  });
-
-  runner.on('test', function(test) {
-    console.log("##teamcity[testStarted name='" + escape(test.fullTitle()) + "']");
-  });
-
-  runner.on('fail', function(test, err) {
-    console.log("##teamcity[testFailed name='" + escape(test.fullTitle()) + "' message='" + escape(err.message) + "']");
-  });
-
-  runner.on('pending', function(test) {
-    console.log("##teamcity[testIgnored name='" + escape(test.fullTitle()) + "' message='pending']");
-  });
-
-  runner.on('test end', function(test) {
-    console.log("##teamcity[testFinished name='" + escape(test.fullTitle()) + "' duration='" + test.duration + "']");
-  });
-
-  runner.on('end', function() {
-    console.log("##teamcity[testSuiteFinished name='mocha.suite' duration='" + stats.duration + "']");
-  });
-}
-
-/**
- * Escape the given `str`.
- */
-
-function escape(str) {
-  return str
-    .replace(/\|/g, "||")
-    .replace(/\n/g, "|n")
-    .replace(/\r/g, "|r")
-    .replace(/\[/g, "|[")
-    .replace(/\]/g, "|]")
-    .replace(/\u0085/g, "|x")
-    .replace(/\u2028/g, "|l")
-    .replace(/\u2029/g, "|p")
-    .replace(/'/g, "|'");
-}
-
-}); // module: reporters/teamcity.js
-
-require.register("reporters/xunit.js", function(module, exports, require){
-
-/**
- * Module dependencies.
- */
-
-var Base = require('./base')
-  , utils = require('../utils')
-  , escape = utils.escape;
-
-/**
- * Save timer references to avoid Sinon interfering (see GH-237).
- */
-
-var Date = global.Date
-  , setTimeout = global.setTimeout
-  , setInterval = global.setInterval
-  , clearTimeout = global.clearTimeout
-  , clearInterval = global.clearInterval;
-
-/**
- * Expose `XUnit`.
- */
-
-exports = module.exports = XUnit;
-
-/**
- * Initialize a new `XUnit` reporter.
- *
- * @param {Runner} runner
- * @api public
- */
-
-function XUnit(runner) {
-  Base.call(this, runner);
-  var stats = this.stats
-    , tests = []
-    , self = this;
-
-  runner.on('test end', function(test){
-    tests.push(test);
-  });
-
-  runner.on('end', function(){
-    console.log(tag('testsuite', {
-        name: 'Mocha Tests'
-      , tests: stats.tests
-      , failures: stats.failures
-      , errors: stats.failures
-      , skip: stats.tests - stats.failures - stats.passes
-      , timestamp: (new Date).toUTCString()
-      , time: stats.duration / 1000
-    }, false));
-
-    tests.forEach(test);
-    console.log('</testsuite>');
-  });
-}
-
-/**
- * Inherit from `Base.prototype`.
- */
-
-XUnit.prototype = new Base;
-XUnit.prototype.constructor = XUnit;
-
-
-/**
- * Output tag for the given `test.`
- */
-
-function test(test) {
-  var attrs = {
-      classname: test.parent.fullTitle()
-    , name: test.title
-    , time: test.duration / 1000
-  };
-
-  if ('failed' == test.state) {
-    var err = test.err;
-    attrs.message = escape(err.message);
-    console.log(tag('testcase', attrs, false, tag('failure', attrs, false, cdata(err.stack))));
-  } else if (test.pending) {
-    console.log(tag('testcase', attrs, false, tag('skipped', {}, true)));
-  } else {
-    console.log(tag('testcase', attrs, true) );
-  }
-}
-
-/**
- * HTML tag helper.
- */
-
-function tag(name, attrs, close, content) {
-  var end = close ? '/>' : '>'
-    , pairs = []
-    , tag;
-
-  for (var key in attrs) {
-    pairs.push(key + '="' + escape(attrs[key]) + '"');
-  }
-
-  tag = '<' + name + (pairs.length ? ' ' + pairs.join(' ') : '') + end;
-  if (content) tag += content + '</' + name + end;
-  return tag;
-}
-
-/**
- * Return cdata escaped CDATA `str`.
- */
-
-function cdata(str) {
-  return '<![CDATA[' + escape(str) + ']]>';
-}
-
-}); // module: reporters/xunit.js
-
-require.register("runnable.js", function(module, exports, require){
-
-/**
- * Module dependencies.
- */
-
-var EventEmitter = require('browser/events').EventEmitter
-  , debug = require('browser/debug')('runnable');
-
-/**
- * Save timer references to avoid Sinon interfering (see GH-237).
- */
-
-var Date = global.Date
-  , setTimeout = global.setTimeout
-  , setInterval = global.setInterval
-  , clearTimeout = global.clearTimeout
-  , clearInterval = global.clearInterval;
-
-/**
- * Expose `Runnable`.
- */
-
-module.exports = Runnable;
-
-/**
- * Initialize a new `Runnable` with the given `title` and callback `fn`.
- *
- * @param {String} title
- * @param {Function} fn
- * @api private
- */
-
-function Runnable(title, fn) {
-  this.title = title;
-  this.fn = fn;
-  this.async = fn && fn.length;
-  this.sync = ! this.async;
-  this._timeout = 2000;
-  this.timedOut = false;
-}
-
-/**
- * Inherit from `EventEmitter.prototype`.
- */
-
-Runnable.prototype = new EventEmitter;
-Runnable.prototype.constructor = Runnable;
-
-
-/**
- * Set & get timeout `ms`.
- *
- * @param {Number} ms
- * @return {Runnable|Number} ms or self
- * @api private
- */
-
-Runnable.prototype.timeout = function(ms){
-  if (0 == arguments.length) return this._timeout;
-  debug('timeout %d', ms);
-  this._timeout = ms;
-  if (this.timer) this.resetTimeout();
-  return this;
-};
-
-/**
- * Return the full title generated by recursively
- * concatenating the parent's full title.
- *
- * @return {String}
- * @api public
- */
-
-Runnable.prototype.fullTitle = function(){
-  return this.parent.fullTitle() + ' ' + this.title;
-};
-
-/**
- * Clear the timeout.
- *
- * @api private
- */
-
-Runnable.prototype.clearTimeout = function(){
-  clearTimeout(this.timer);
-};
-
-/**
- * Reset the timeout.
- *
- * @api private
- */
-
-Runnable.prototype.resetTimeout = function(){
-  var self = this
-    , ms = this.timeout();
-
-  this.clearTimeout();
-  if (ms) {
-    this.timer = setTimeout(function(){
-      self.callback(new Error('timeout of ' + ms + 'ms exceeded'));
-      self.timedOut = true;
-    }, ms);
-  }
-};
-
-/**
- * Run the test and invoke `fn(err)`.
- *
- * @param {Function} fn
- * @api private
- */
-
-Runnable.prototype.run = function(fn){
-  var self = this
-    , ms = this.timeout()
-    , start = new Date
-    , ctx = this.ctx
-    , finished
-    , emitted;
-
-  if (ctx) ctx.runnable(this);
-
-  // timeout
-  if (this.async) {
-    if (ms) {
-      this.timer = setTimeout(function(){
-        done(new Error('timeout of ' + ms + 'ms exceeded'));
-        self.timedOut = true;
-      }, ms);
-    }
-  }
-
-  // called multiple times
-  function multiple() {
-    if (emitted) return;
-    emitted = true;
-    self.emit('error', new Error('done() called multiple times'));
-  }
-
-  // finished
-  function done(err) {
-    if (self.timedOut) return;
-    if (finished) return multiple();
-    self.clearTimeout();
-    self.duration = new Date - start;
-    finished = true;
-    fn(err);
-  }
-
-  // for .resetTimeout()
-  this.callback = done;
-
-  // async
-  if (this.async) {
-    try {
-      this.fn.call(ctx, function(err){
-        if (err instanceof Error) return done(err);
-        if (null != err) return done(new Error('done() invoked with non-Error: ' + err));
-        done();
-      });
-    } catch (err) {
-      done(err);
-    }
-    return;
-  }
-
-  // sync
-  try {
-    if (!this.pending) this.fn.call(ctx);
-    this.duration = new Date - start;
-    fn();
-  } catch (err) {
-    fn(err);
-  }
-};
-
-}); // module: runnable.js
-
-require.register("runner.js", function(module, exports, require){
-
-/**
- * Module dependencies.
- */
-
-var EventEmitter = require('browser/events').EventEmitter
-  , debug = require('browser/debug')('runner')
-  , Test = require('./test')
-  , utils = require('./utils')
-  , filter = utils.filter
-  , keys = utils.keys
-  , noop = function(){};
-
-/**
- * Expose `Runner`.
- */
-
-module.exports = Runner;
-
-/**
- * Initialize a `Runner` for the given `suite`.
- *
- * Events:
- *
- *   - `start`  execution started
- *   - `end`  execution complete
- *   - `suite`  (suite) test suite execution started
- *   - `suite end`  (suite) all tests (and sub-suites) have finished
- *   - `test`  (test) test execution started
- *   - `test end`  (test) test completed
- *   - `hook`  (hook) hook execution started
- *   - `hook end`  (hook) hook complete
- *   - `pass`  (test) test passed
- *   - `fail`  (test, err) test failed
- *
- * @api public
- */
-
-function Runner(suite) {
-  var self = this;
-  this._globals = [];
-  this.suite = suite;
-  this.total = suite.total();
-  this.failures = 0;
-  this.on('test end', function(test){ self.checkGlobals(test); });
-  this.on('hook end', function(hook){ self.checkGlobals(hook); });
-  this.grep(/.*/);
-  this.globals(utils.keys(global).concat(['errno']));
-}
-
-/**
- * Inherit from `EventEmitter.prototype`.
- */
-
-Runner.prototype = new EventEmitter;
-Runner.prototype.constructor = Runner;
-
-
-/**
- * Run tests with full titles matching `re`. Updates runner.total
- * with number of tests matched.
- *
- * @param {RegExp} re
- * @return {Runner} for chaining
- * @api public
- */
-
-Runner.prototype.grep = function(re){
-  debug('grep %s', re);
-  this._grep = re;
-  this.total = this.grepTotal(this.suite);
-  return this;
-};
-
-/**
- * Returns the number of tests matching the grep search for the
- * given suite.
- *
- * @param {Suite} suite
- * @return {Number}
- * @api public
- */
-
-Runner.prototype.grepTotal = function(suite) {
-  var self = this;
-  var total = 0;
-
-  suite.eachTest(function(test){
-    if (self._grep.test(test.fullTitle())) total++;
-  });
-
-  return total;
-};
-
-/**
- * Allow the given `arr` of globals.
- *
- * @param {Array} arr
- * @return {Runner} for chaining
- * @api public
- */
-
-Runner.prototype.globals = function(arr){
-  if (0 == arguments.length) return this._globals;
-  debug('globals %j', arr);
-  utils.forEach(arr, function(arr){
-    this._globals.push(arr);
-  }, this);
-  return this;
-};
-
-/**
- * Check for global variable leaks.
- *
- * @api private
- */
-
-Runner.prototype.checkGlobals = function(test){
-  if (this.ignoreLeaks) return;
-  var leaks = filterLeaks(this._globals);
-
-  this._globals = this._globals.concat(leaks);
-
-  if (leaks.length > 1) {
-    this.fail(test, new Error('global leaks detected: ' + leaks.join(', ') + ''));
-  } else if (leaks.length) {
-    this.fail(test, new Error('global leak detected: ' + leaks[0]));
-  }
-};
-
-/**
- * Fail the given `test`.
- *
- * @param {Test} test
- * @param {Error} err
- * @api private
- */
-
-Runner.prototype.fail = function(test, err){
-  ++this.failures;
-  test.state = 'failed';
-  if ('string' == typeof err) {
-    err = new Error('the string "' + err + '" was thrown, throw an Error :)');
-  }
-  this.emit('fail', test, err);
-};
-
-/**
- * Fail the given `hook` with `err`.
- *
- * Hook failures (currently) hard-end due
- * to that fact that a failing hook will
- * surely cause subsequent tests to fail,
- * causing jumbled reporting.
- *
- * @param {Hook} hook
- * @param {Error} err
- * @api private
- */
-
-Runner.prototype.failHook = function(hook, err){
-  this.fail(hook, err);
-  this.emit('end');
-};
-
-/**
- * Run hook `name` callbacks and then invoke `fn()`.
- *
- * @param {String} name
- * @param {Function} function
- * @api private
- */
-
-Runner.prototype.hook = function(name, fn){
-  var suite = this.suite
-    , hooks = suite['_' + name]
-    , ms = suite._timeout
-    , self = this
-    , timer;
-
-  function next(i) {
-    var hook = hooks[i];
-    if (!hook) return fn();
-    self.currentRunnable = hook;
-
-    self.emit('hook', hook);
-
-    hook.on('error', function(err){
-      self.failHook(hook, err);
-    });
-
-    hook.run(function(err){
-      hook.removeAllListeners('error');
-      if (err) return self.failHook(hook, err);
-      self.emit('hook end', hook);
-      next(++i);
-    });
-  }
-
-  process.nextTick(function(){
-    next(0);
-  });
-};
-
-/**
- * Run hook `name` for the given array of `suites`
- * in order, and callback `fn(err)`.
- *
- * @param {String} name
- * @param {Array} suites
- * @param {Function} fn
- * @api private
- */
-
-Runner.prototype.hooks = function(name, suites, fn){
-  var self = this
-    , orig = this.suite;
-
-  function next(suite) {
-    self.suite = suite;
-
-    if (!suite) {
-      self.suite = orig;
-      return fn();
-    }
-
-    self.hook(name, function(err){
-      if (err) {
-        self.suite = orig;
-        return fn(err);
-      }
-
-      next(suites.pop());
-    });
-  }
-
-  next(suites.pop());
-};
-
-/**
- * Run hooks from the top level down.
- *
- * @param {String} name
- * @param {Function} fn
- * @api private
- */
-
-Runner.prototype.hookUp = function(name, fn){
-  var suites = [this.suite].concat(this.parents()).reverse();
-  this.hooks(name, suites, fn);
-};
-
-/**
- * Run hooks from the bottom up.
- *
- * @param {String} name
- * @param {Function} fn
- * @api private
- */
-
-Runner.prototype.hookDown = function(name, fn){
-  var suites = [this.suite].concat(this.parents());
-  this.hooks(name, suites, fn);
-};
-
-/**
- * Return an array of parent Suites from
- * closest to furthest.
- *
- * @return {Array}
- * @api private
- */
-
-Runner.prototype.parents = function(){
-  var suite = this.suite
-    , suites = [];
-  while (suite = suite.parent) suites.push(suite);
-  return suites;
-};
-
-/**
- * Run the current test and callback `fn(err)`.
- *
- * @param {Function} fn
- * @api private
- */
-
-Runner.prototype.runTest = function(fn){
-  var test = this.test
-    , self = this;
-
-  try {
-    test.on('error', function(err){
-      self.fail(test, err);
-    });
-    test.run(fn);
-  } catch (err) {
-    fn(err);
-  }
-};
-
-/**
- * Run tests in the given `suite` and invoke
- * the callback `fn()` when complete.
- *
- * @param {Suite} suite
- * @param {Function} fn
- * @api private
- */
-
-Runner.prototype.runTests = function(suite, fn){
-  var self = this
-    , tests = suite.tests
-    , test;
-
-  function next(err) {
-    // if we bail after first err
-    if (self.failures && suite._bail) return fn();
-
-    // next test
-    test = tests.shift();
-
-    // all done
-    if (!test) return fn();
-
-    // grep
-    if (!self._grep.test(test.fullTitle())) return next();
-
-    // pending
-    if (test.pending) {
-      self.emit('pending', test);
-      self.emit('test end', test);
-      return next();
-    }
-
-    // execute test and hook(s)
-    self.emit('test', self.test = test);
-    self.hookDown('beforeEach', function(){
-      self.currentRunnable = self.test;
-      self.runTest(function(err){
-        test = self.test;
-
-        if (err) {
-          self.fail(test, err);
-          self.emit('test end', test);
-          return self.hookUp('afterEach', next);
-        }
-
-        test.state = 'passed';
-        self.emit('pass', test);
-        self.emit('test end', test);
-        self.hookUp('afterEach', next);
-      });
-    });
-  }
-
-  this.next = next;
-  next();
-};
-
-/**
- * Run the given `suite` and invoke the
- * callback `fn()` when complete.
- *
- * @param {Suite} suite
- * @param {Function} fn
- * @api private
- */
-
-Runner.prototype.runSuite = function(suite, fn){
-  var total = this.grepTotal(suite)
-    , self = this
-    , i = 0;
-
-  debug('run suite %s', suite.fullTitle());
-
-  if (!total) return fn();
-
-  this.emit('suite', this.suite = suite);
-
-  function next() {
-    var curr = suite.suites[i++];
-    if (!curr) return done();
-    self.runSuite(curr, next);
-  }
-
-  function done() {
-    self.suite = suite;
-    self.hook('afterAll', function(){
-      self.emit('suite end', suite);
-      fn();
-    });
-  }
-
-  this.hook('beforeAll', function(){
-    self.runTests(suite, next);
-  });
-};
-
-/**
- * Handle uncaught exceptions.
- *
- * @param {Error} err
- * @api private
- */
-
-Runner.prototype.uncaught = function(err){
-  debug('uncaught exception');
-  var runnable = this.currentRunnable;
-  if ('failed' == runnable.state) return;
-  runnable.clearTimeout();
-  err.uncaught = true;
-  this.fail(runnable, err);
-
-  // recover from test
-  if ('test' == runnable.type) {
-    this.emit('test end', runnable);
-    this.hookUp('afterEach', this.next);
-    return;
-  }
-
-  // bail on hooks
-  this.emit('end');
-};
-
-/**
- * Run the root suite and invoke `fn(failures)`
- * on completion.
- *
- * @param {Function} fn
- * @return {Runner} for chaining
- * @api public
- */
-
-Runner.prototype.run = function(fn){
-  var self = this
-    , fn = fn || function(){};
-
-  debug('start');
-
-  // uncaught callback
-  function uncaught(err) {
-    self.uncaught(err);
-  }
-
-  // callback
-  this.on('end', function(){
-    debug('end');
-    process.removeListener('uncaughtException', uncaught);
-    fn(self.failures);
-  });
-
-  // run suites
-  this.emit('start');
-  this.runSuite(this.suite, function(){
-    debug('finished running');
-    self.emit('end');
-  });
-
-  // uncaught exception
-  process.on('uncaughtException', uncaught);
-
-  return this;
-};
-
-/**
- * Filter leaks with the given globals flagged as `ok`.
- *
- * @param {Array} ok
- * @return {Array}
- * @api private
- */
-
-function filterLeaks(ok) {
-  return filter(keys(global), function(key){
-    var matched = filter(ok, function(ok){
-      return 0 == key.indexOf(ok.split('*')[0]);
-    });
-    return matched.length == 0 && (!global.navigator || 'onerror' !== key);
-  });
-}
-}); // module: runner.js
-
-require.register("suite.js", function(module, exports, require){
-
-/**
- * Module dependencies.
- */
-
-var EventEmitter = require('browser/events').EventEmitter
-  , debug = require('browser/debug')('suite')
-  , utils = require('./utils')
-  , Hook = require('./hook');
-
-/**
- * Expose `Suite`.
- */
-
-exports = module.exports = Suite;
-
-/**
- * Create a new `Suite` with the given `title`
- * and parent `Suite`. When a suite with the
- * same title is already present, that suite
- * is returned to provide nicer reporter
- * and more flexible meta-testing.
- *
- * @param {Suite} parent
- * @param {String} title
- * @return {Suite}
- * @api public
- */
-
-exports.create = function(parent, title){
-  var suite = new Suite(title, parent.ctx);
-  suite.parent = parent;
-  title = suite.fullTitle();
-  parent.addSuite(suite);
-  return suite;
-};
-
-/**
- * Initialize a new `Suite` with the given
- * `title` and `ctx`.
- *
- * @param {String} title
- * @param {Context} ctx
- * @api private
- */
-
-function Suite(title, ctx) {
-  this.title = title;
-  this.ctx = ctx;
-  this.suites = [];
-  this.tests = [];
-  this._beforeEach = [];
-  this._beforeAll = [];
-  this._afterEach = [];
-  this._afterAll = [];
-  this.root = !title;
-  this._timeout = 2000;
-  this._bail = false;
-}
-
-/**
- * Inherit from `EventEmitter.prototype`.
- */
-
-Suite.prototype = new EventEmitter;
-Suite.prototype.constructor = Suite;
-
-
-/**
- * Return a clone of this `Suite`.
- *
- * @return {Suite}
- * @api private
- */
-
-Suite.prototype.clone = function(){
-  var suite = new Suite(this.title);
-  debug('clone');
-  suite.ctx = this.ctx;
-  suite.timeout(this.timeout());
-  suite.bail(this.bail());
-  return suite;
-};
-
-/**
- * Set timeout `ms` or short-hand such as "2s".
- *
- * @param {Number|String} ms
- * @return {Suite|Number} for chaining
- * @api private
- */
-
-Suite.prototype.timeout = function(ms){
-  if (0 == arguments.length) return this._timeout;
-  if (String(ms).match(/s$/)) ms = parseFloat(ms) * 1000;
-  debug('timeout %d', ms);
-  this._timeout = parseInt(ms, 10);
-  return this;
-};
-
-/**
- * Sets whether to bail after first error.
- *
- * @parma {Boolean} bail
- * @return {Suite|Number} for chaining
- * @api private
- */
-
-Suite.prototype.bail = function(bail){
-  if (0 == arguments.length) return this._bail;
-  debug('bail %s', bail);
-  this._bail = bail;
-  return this;
-};
-
-/**
- * Run `fn(test[, done])` before running tests.
- *
- * @param {Function} fn
- * @return {Suite} for chaining
- * @api private
- */
-
-Suite.prototype.beforeAll = function(fn){
-  var hook = new Hook('"before all" hook', fn);
-  hook.parent = this;
-  hook.timeout(this.timeout());
-  hook.ctx = this.ctx;
-  this._beforeAll.push(hook);
-  this.emit('beforeAll', hook);
-  return this;
-};
-
-/**
- * Run `fn(test[, done])` after running tests.
- *
- * @param {Function} fn
- * @return {Suite} for chaining
- * @api private
- */
-
-Suite.prototype.afterAll = function(fn){
-  var hook = new Hook('"after all" hook', fn);
-  hook.parent = this;
-  hook.timeout(this.timeout());
-  hook.ctx = this.ctx;
-  this._afterAll.push(hook);
-  this.emit('afterAll', hook);
-  return this;
-};
-
-/**
- * Run `fn(test[, done])` before each test case.
- *
- * @param {Function} fn
- * @return {Suite} for chaining
- * @api private
- */
-
-Suite.prototype.beforeEach = function(fn){
-  var hook = new Hook('"before each" hook', fn);
-  hook.parent = this;
-  hook.timeout(this.timeout());
-  hook.ctx = this.ctx;
-  this._beforeEach.push(hook);
-  this.emit('beforeEach', hook);
-  return this;
-};
-
-/**
- * Run `fn(test[, done])` after each test case.
- *
- * @param {Function} fn
- * @return {Suite} for chaining
- * @api private
- */
-
-Suite.prototype.afterEach = function(fn){
-  var hook = new Hook('"after each" hook', fn);
-  hook.parent = this;
-  hook.timeout(this.timeout());
-  hook.ctx = this.ctx;
-  this._afterEach.push(hook);
-  this.emit('afterEach', hook);
-  return this;
-};
-
-/**
- * Add a test `suite`.
- *
- * @param {Suite} suite
- * @return {Suite} for chaining
- * @api private
- */
-
-Suite.prototype.addSuite = function(suite){
-  suite.parent = this;
-  suite.timeout(this.timeout());
-  suite.bail(this.bail());
-  this.suites.push(suite);
-  this.emit('suite', suite);
-  return this;
-};
-
-/**
- * Add a `test` to this suite.
- *
- * @param {Test} test
- * @return {Suite} for chaining
- * @api private
- */
-
-Suite.prototype.addTest = function(test){
-  test.parent = this;
-  test.timeout(this.timeout());
-  test.ctx = this.ctx;
-  this.tests.push(test);
-  this.emit('test', test);
-  return this;
-};
-
-/**
- * Return the full title generated by recursively
- * concatenating the parent's full title.
- *
- * @return {String}
- * @api public
- */
-
-Suite.prototype.fullTitle = function(){
-  if (this.parent) {
-    var full = this.parent.fullTitle();
-    if (full) return full + ' ' + this.title;
-  }
-  return this.title;
-};
-
-/**
- * Return the total number of tests.
- *
- * @return {Number}
- * @api public
- */
-
-Suite.prototype.total = function(){
-  return utils.reduce(this.suites, function(sum, suite){
-    return sum + suite.total();
-  }, 0) + this.tests.length;
-};
-
-/**
- * Iterates through each suite recursively to find
- * all tests. Applies a function in the format
- * `fn(test)`.
- *
- * @param {Function} fn
- * @return {Suite}
- * @api private
- */
-
-Suite.prototype.eachTest = function(fn){
-  utils.forEach(this.tests, fn);
-  utils.forEach(this.suites, function(suite){
-    suite.eachTest(fn);
-  });
-  return this;
-};
-
-}); // module: suite.js
-
-require.register("test.js", function(module, exports, require){
-
-/**
- * Module dependencies.
- */
-
-var Runnable = require('./runnable');
-
-/**
- * Expose `Test`.
- */
-
-module.exports = Test;
-
-/**
- * Initialize a new `Test` with the given `title` and callback `fn`.
- *
- * @param {String} title
- * @param {Function} fn
- * @api private
- */
-
-function Test(title, fn) {
-  Runnable.call(this, title, fn);
-  this.pending = !fn;
-  this.type = 'test';
-}
-
-/**
- * Inherit from `Runnable.prototype`.
- */
-
-Test.prototype = new Runnable;
-Test.prototype.constructor = Test;
-
-
-/**
- * Inspect the context void of private properties.
- *
- * @return {String}
- * @api private
- */
-
-Test.prototype.inspect = function(){
-  return JSON.stringify(this, function(key, val){
-    return '_' == key[0]
-      ? undefined
-      : 'parent' == key
-        ? '#<Suite>'
-        : val;
-  }, 2);
-};
-}); // module: test.js
-
-require.register("utils.js", function(module, exports, require){
-
-/**
- * Module dependencies.
- */
-
-var fs = require('browser/fs')
-  , path = require('browser/path')
-  , join = path.join
-  , debug = require('browser/debug')('watch');
-
-/**
- * Ignored directories.
- */
-
-var ignore = ['node_modules', '.git'];
-
-/**
- * Escape special characters in the given string of html.
- *
- * @param  {String} html
- * @return {String}
- * @api private
- */
-
-exports.escape = function(html) {
-  return String(html)
-    .replace(/&/g, '&amp;')
-    .replace(/"/g, '&quot;')
-    .replace(/</g, '&lt;')
-    .replace(/>/g, '&gt;');
-};
-
-/**
- * Array#forEach (<=IE8)
- *
- * @param {Array} array
- * @param {Function} fn
- * @param {Object} scope
- * @api private
- */
-
-exports.forEach = function(arr, fn, scope) {
-  for (var i = 0, l = arr.length; i < l; i++)
-    fn.call(scope, arr[i], i);
-};
-
-/**
- * Array#indexOf (<=IE8)
- *
- * @parma {Array} arr
- * @param {Object} obj to find index of
- * @param {Number} start
- * @api private
- */
-
-exports.indexOf = function (arr, obj, start) {
-  for (var i = start || 0, l = arr.length; i < l; i++) {
-    if (arr[i] === obj)
-      return i;
-  }
-  return -1;
-};
-
-/**
- * Array#reduce (<=IE8)
- *
- * @param {Array} array
- * @param {Function} fn
- * @param {Object} initial value
- * @param {Object} scope
- * @api private
- */
-
-exports.reduce = function(arr, fn, val, scope) {
-  var rval = val;
-
-  for (var i = 0, l = arr.length; i < l; i++) {
-    rval = fn.call(scope, rval, arr[i], i, arr);
-  }
-
-  return rval;
-};
-
-/**
- * Array#filter (<=IE8)
- *
- * @param {Array} array
- * @param {Function} fn
- * @param {Object} scope
- * @api private
- */
-
-exports.filter = function(arr, fn, scope) {
-  var ret = [];
-
-  for (var i = 0, l = arr.length; i < l; i++) {
-    var val = arr[i];
-    if (fn.call(scope, val, i, arr))
-      ret.push(val);
-  }
-
-  return ret;
-};
-
-/**
- * Object.keys (<=IE8)
- *
- * @param {Object} obj
- * @return {Array} keys
- * @api private
- */
-
-exports.keys = Object.keys || function(obj) {
-  var keys = []
-    , has = Object.prototype.hasOwnProperty // for `window` on <=IE8
-
-  for (var key in obj) {
-    if (has.call(obj, key)) {
-      keys.push(key);
-    }
-  }
-
-  return keys;
-};
-
-/**
- * Watch the given `files` for changes
- * and invoke `fn(file)` on modification.
- *
- * @param {Array} files
- * @param {Function} fn
- * @api private
- */
-
-exports.watch = function(files, fn){
-  var options = { interval: 100 };
-  files.forEach(function(file){
-    debug('file %s', file);
-    fs.watchFile(file, options, function(curr, prev){
-      if (prev.mtime < curr.mtime) fn(file);
-    });
-  });
-};
-
-/**
- * Ignored files.
- */
-
-function ignored(path){
-  return !~ignore.indexOf(path);
-}
-
-/**
- * Lookup files in the given `dir`.
- *
- * @return {Array}
- * @api private
- */
-
-exports.files = function(dir, ret){
-  ret = ret || [];
-
-  fs.readdirSync(dir)
-  .filter(ignored)
-  .forEach(function(path){
-    path = join(dir, path);
-    if (fs.statSync(path).isDirectory()) {
-      exports.files(path, ret);
-    } else if (path.match(/\.(js|coffee)$/)) {
-      ret.push(path);
-    }
-  });
-
-  return ret;
-};
-
-/**
- * Compute a slug from the given `str`.
- *
- * @param {String} str
- * @return {String}
- * @api private
- */
-
-exports.slug = function(str){
-  return str
-    .toLowerCase()
-    .replace(/ +/g, '-')
-    .replace(/[^-\w]/g, '');
-};
-
-/**
- * Strip the function definition from `str`,
- * and re-indent for pre whitespace.
- */
-
-exports.clean = function(str) {
-  str = str
-    .replace(/^function *\(.*\) *{/, '')
-    .replace(/\s+\}$/, '');
-
-  var spaces = str.match(/^\n?( *)/)[1].length
-    , re = new RegExp('^ {' + spaces + '}', 'gm');
-
-  str = str.replace(re, '');
-
-  return str.trim();
-};
-
-/**
- * Escape regular expression characters in `str`.
- *
- * @param {String} str
- * @return {String}
- * @api private
- */
-
-exports.escapeRegexp = function(str){
-  return str.replace(/[-\\^$*+?.()|[\]{}]/g, "\\$&");
-};
-}); // module: utils.js
-/**
- * Node shims.
- *
- * These are meant only to allow
- * mocha.js to run untouched, not
- * to allow running node code in
- * the browser.
- */
-
-process = {};
-process.exit = function(status){};
-process.stdout = {};
-global = window;
-
-/**
- * next tick implementation.
- */
-
-process.nextTick = (function(){
-  // postMessage behaves badly on IE8
-  if (window.ActiveXObject || !window.postMessage) {
-    return function(fn){ fn() };
-  }
-
-  // based on setZeroTimeout by David Baron
-  // - http://dbaron.org/log/20100309-faster-timeouts
-  var timeouts = []
-    , name = 'mocha-zero-timeout'
-
-  window.addEventListener('message', function(e){
-    if (e.source == window && e.data == name) {
-      if (e.stopPropagation) e.stopPropagation();
-      if (timeouts.length) timeouts.shift()();
-    }
-  }, true);
-
-  return function(fn){
-    timeouts.push(fn);
-    window.postMessage(name, '*');
-  }
-})();
-
-/**
- * Remove uncaughtException listener.
- */
-
-process.removeListener = function(e){
-  if ('uncaughtException' == e) {
-    window.onerror = null;
-  }
-};
-
-/**
- * Implements uncaughtException listener.
- */
-
-process.on = function(e, fn){
-  if ('uncaughtException' == e) {
-    window.onerror = fn;
-  }
-};
-
-/**
- * Expose mocha.
- */
-
-window.mocha = require('mocha');
-
-// boot
-;(function(){
-  var suite = new mocha.Suite('', new mocha.Context)
-    , utils = mocha.utils
-    , options = {}
-
-  /**
-   * Highlight the given string of `js`.
-   */
-
-  function highlight(js) {
-    return js
-      .replace(/</g, '&lt;')
-      .replace(/>/g, '&gt;')
-      .replace(/\/\/(.*)/gm, '<span class="comment">//$1</span>')
-      .replace(/('.*?')/gm, '<span class="string">$1</span>')
-      .replace(/(\d+\.\d+)/gm, '<span class="number">$1</span>')
-      .replace(/(\d+)/gm, '<span class="number">$1</span>')
-      .replace(/\bnew *(\w+)/gm, '<span class="keyword">new</span> <span class="init">$1</span>')
-      .replace(/\b(function|new|throw|return|var|if|else)\b/gm, '<span class="keyword">$1</span>')
-  }
-
-  /**
-   * Highlight code contents.
-   */
-
-  function highlightCode() {
-    var code = document.getElementsByTagName('code');
-    for (var i = 0, len = code.length; i < len; ++i) {
-      code[i].innerHTML = highlight(code[i].innerHTML);
-    }
-  }
-
-  /**
-   * Parse the given `qs`.
-   */
-
-  function parse(qs) {
-    return utils.reduce(qs.replace('?', '').split('&'), function(obj, pair){
-      var i = pair.indexOf('=')
-        , key = pair.slice(0, i)
-        , val = pair.slice(++i);
-
-      obj[key] = decodeURIComponent(val);
-      return obj;
-    }, {});
-  }
-
-  /**
-   * Setup mocha with the given setting options.
-   */
-
-  mocha.setup = function(opts){
-    if ('string' === typeof opts) options.ui = opts;
-    else options = opts;
-
-    ui = mocha.interfaces[options.ui];
-    if (!ui) throw new Error('invalid mocha interface "' + ui + '"');
-    if (options.timeout) suite.timeout(options.timeout);
-    ui(suite);
-    suite.emit('pre-require', window);
-  };
-
-  /**
-   * Run mocha, returning the Runner.
-   */
-
-  mocha.run = function(fn){
-    suite.emit('run');
-    var runner = new mocha.Runner(suite);
-    var Reporter = options.reporter || mocha.reporters.HTML;
-    var reporter = new Reporter(runner);
-    var query = parse(window.location.search || "");
-    if (query.grep) runner.grep(new RegExp(query.grep));
-    if (options.ignoreLeaks) runner.ignoreLeaks = true;
-    if (options.globals) runner.globals(options.globals);
-    runner.globals(['location']);
-    runner.on('end', highlightCode);
-    return runner.run(fn);
-  };
-})();
-})();
-
diff --git a/assets/javascripts/spec/vendor/sinon.js b/assets/javascripts/spec/vendor/sinon.js
new file mode 100644
index 00000000..d50830c4
--- /dev/null
+++ b/assets/javascripts/spec/vendor/sinon.js
@@ -0,0 +1,3555 @@
+/**
+ * Sinon.JS 1.3.4, 2012/04/16
+ *
+ * @author Christian Johansen (christian@cjohansen.no)
+ *
+ * (The BSD License)
+ *
+ * Copyright (c) 2010-2011, Christian Johansen, christian@cjohansen.no
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ *
+ *     * Redistributions of source code must retain the above copyright notice,
+ *       this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright notice,
+ *       this list of conditions and the following disclaimer in the documentation
+ *       and/or other materials provided with the distribution.
+ *     * Neither the name of Christian Johansen nor the names of his contributors
+ *       may be used to endorse or promote products derived from this software
+ *       without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+"use strict";
+var sinon = (function () {
+var buster = (function (buster, setTimeout) {
+    function extend(target) {
+        if (!target) {
+            return;
+        }
+
+        for (var i = 1, l = arguments.length, prop; i < l; ++i) {
+            for (prop in arguments[i]) {
+                target[prop] = arguments[i][prop];
+            }
+        }
+
+        return target;
+    }
+
+    var div = typeof document != "undefined" && document.createElement("div");
+
+    return extend(buster, {
+        bind: function (obj, methOrProp) {
+            var method = typeof methOrProp == "string" ? obj[methOrProp] : methOrProp;
+            var args = Array.prototype.slice.call(arguments, 2);
+
+            return function () {
+                var allArgs = args.concat(Array.prototype.slice.call(arguments));
+                return method.apply(obj, allArgs);
+            };
+        },
+
+        create: (function () {
+            function F() {}
+
+            return function create(object) {
+                F.prototype = object;
+                return new F();
+            }
+        }()),
+
+        extend: extend,
+
+        nextTick: function (callback) {
+            if (typeof process != "undefined" && process.nextTick) {
+                return process.nextTick(callback);
+            }
+
+            setTimeout(callback, 0);
+        },
+
+        functionName: function (func) {
+            if (!func) return "";
+            if (func.displayName) return func.displayName;
+            if (func.name) return func.name;
+
+            var matches = func.toString().match(/function\s+([^\(]+)/m);
+            return matches && matches[1] || "";
+        },
+
+        isNode: function (obj) {
+            if (!div) return false;
+
+            try {
+                obj.appendChild(div);
+                obj.removeChild(div);
+            } catch (e) {
+                return false;
+            }
+
+            return true;
+        },
+
+        isElement: function (obj) {
+            return obj && buster.isNode(obj) && obj.nodeType === 1;
+        }
+    });
+}(buster || {}, setTimeout));
+
+if (typeof module == "object" && typeof require == "function") {
+    module.exports = buster;
+    buster.eventEmitter = require("./buster-event-emitter");
+
+    Object.defineProperty(buster, "defineVersionGetter", {
+        get: function () {
+            return require("./define-version-getter");
+        }
+    });
+}
+if (typeof buster === "undefined") {
+    var buster = {};
+}
+
+if (typeof module === "object" && typeof require === "function") {
+    buster = require("buster-core");
+}
+
+buster.format = buster.format || {};
+buster.format.excludeConstructors = ["Object", /^.$/];
+buster.format.quoteStrings = true;
+
+buster.format.ascii = (function () {
+
+    function keys(object) {
+        var k = Object.keys && Object.keys(object) || [];
+
+        if (k.length == 0) {
+            for (var prop in object) {
+                if (object.hasOwnProperty(prop)) {
+                    k.push(prop);
+                }
+            }
+        }
+
+        return k.sort();
+    }
+
+    function isCircular(object, objects) {
+        if (typeof object != "object") {
+            return false;
+        }
+
+        for (var i = 0, l = objects.length; i < l; ++i) {
+            if (objects[i] === object) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    function ascii(object, processed, indent) {
+        if (typeof object == "string") {
+            var quote = typeof this.quoteStrings != "boolean" || this.quoteStrings;
+            return processed || quote ? '"' + object + '"' : object;
+        }
+
+        if (typeof object == "function" && !(object instanceof RegExp)) {
+            return ascii.func(object);
+        }
+
+        processed = processed || [];
+
+        if (isCircular(object, processed)) {
+            return "[Circular]";
+        }
+
+        if (Object.prototype.toString.call(object) == "[object Array]") {
+            return ascii.array.call(this, object);
+        }
+
+        if (!object) {
+            return "" + object;
+        }
+
+        if (buster.isElement(object)) {
+            return ascii.element(object);
+        }
+
+        if (typeof object.toString == "function" &&
+            object.toString !== Object.prototype.toString) {
+            return object.toString();
+        }
+
+        return ascii.object.call(this, object, processed, indent);
+    }
+
+    ascii.func = function (func) {
+        return "function " + buster.functionName(func) + "() {}";
+    };
+
+    ascii.array = function (array, processed) {
+        processed = processed || [];
+        processed.push(array);
+        var pieces = [];
+
+        for (var i = 0, l = array.length; i < l; ++i) {
+            pieces.push(ascii.call(this, array[i], processed));
+        }
+
+        return "[" + pieces.join(", ") + "]";
+    };
+
+    ascii.object = function (object, processed, indent) {
+        processed = processed || [];
+        processed.push(object);
+        indent = indent || 0;
+        var pieces = [], properties = keys(object), prop, str, obj;
+        var is = "";
+        var length = 3;
+
+        for (var i = 0, l = indent; i < l; ++i) {
+            is += " ";
+        }
+
+        for (i = 0, l = properties.length; i < l; ++i) {
+            prop = properties[i];
+            obj = object[prop];
+
+            if (isCircular(obj, processed)) {
+                str = "[Circular]";
+            } else {
+                str = ascii.call(this, obj, processed, indent + 2);
+            }
+
+            str = (/\s/.test(prop) ? '"' + prop + '"' : prop) + ": " + str;
+            length += str.length;
+            pieces.push(str);
+        }
+
+        var cons = ascii.constructorName.call(this, object);
+        var prefix = cons ? "[" + cons + "] " : ""
+
+        return (length + indent) > 80 ?
+            prefix + "{\n  " + is + pieces.join(",\n  " + is) + "\n" + is + "}" :
+            prefix + "{ " + pieces.join(", ") + " }";
+    };
+
+    ascii.element = function (element) {
+        var tagName = element.tagName.toLowerCase();
+        var attrs = element.attributes, attribute, pairs = [], attrName;
+
+        for (var i = 0, l = attrs.length; i < l; ++i) {
+            attribute = attrs.item(i);
+            attrName = attribute.nodeName.toLowerCase().replace("html:", "");
+
+            if (attrName == "contenteditable" && attribute.nodeValue == "inherit") {
+                continue;
+            }
+
+            if (!!attribute.nodeValue) {
+                pairs.push(attrName + "=\"" + attribute.nodeValue + "\"");
+            }
+        }
+
+        var formatted = "<" + tagName + (pairs.length > 0 ? " " : "");
+        var content = element.innerHTML;
+
+        if (content.length > 20) {
+            content = content.substr(0, 20) + "[...]";
+        }
+
+        var res = formatted + pairs.join(" ") + ">" + content + "</" + tagName + ">";
+
+        return res.replace(/ contentEditable="inherit"/, "");
+    };
+
+    ascii.constructorName = function (object) {
+        var name = buster.functionName(object && object.constructor);
+        var excludes = this.excludeConstructors || buster.format.excludeConstructors || [];
+
+        for (var i = 0, l = excludes.length; i < l; ++i) {
+            if (typeof excludes[i] == "string" && excludes[i] == name) {
+                return "";
+            } else if (excludes[i].test && excludes[i].test(name)) {
+                return "";
+            }
+        }
+
+        return name;
+    };
+
+    return ascii;
+}());
+
+if (typeof module != "undefined") {
+    module.exports = buster.format;
+}
+/*jslint eqeqeq: false, onevar: false, forin: true, nomen: false, regexp: false, plusplus: false*/
+/*global module, require, __dirname, document*/
+/**
+ * Sinon core utilities. For internal use only.
+ *
+ * @author Christian Johansen (christian@cjohansen.no)
+ * @license BSD
+ *
+ * Copyright (c) 2010-2011 Christian Johansen
+ */
+
+var sinon = (function (buster) {
+    var div = typeof document != "undefined" && document.createElement("div");
+    var hasOwn = Object.prototype.hasOwnProperty;
+
+    function isDOMNode(obj) {
+        var success = false;
+
+        try {
+            obj.appendChild(div);
+            success = div.parentNode == obj;
+        } catch (e) {
+            return false;
+        } finally {
+            try {
+                obj.removeChild(div);
+            } catch (e) {
+                // Remove failed, not much we can do about that
+            }
+        }
+
+        return success;
+    }
+
+    function isElement(obj) {
+        return div && obj && obj.nodeType === 1 && isDOMNode(obj);
+    }
+
+    function isFunction(obj) {
+        return !!(obj && obj.constructor && obj.call && obj.apply);
+    }
+
+    function mirrorProperties(target, source) {
+        for (var prop in source) {
+            if (!hasOwn.call(target, prop)) {
+                target[prop] = source[prop];
+            }
+        }
+    }
+
+    var sinon = {
+        wrapMethod: function wrapMethod(object, property, method) {
+            if (!object) {
+                throw new TypeError("Should wrap property of object");
+            }
+
+            if (typeof method != "function") {
+                throw new TypeError("Method wrapper should be function");
+            }
+
+            var wrappedMethod = object[property];
+
+            if (!isFunction(wrappedMethod)) {
+                throw new TypeError("Attempted to wrap " + (typeof wrappedMethod) + " property " +
+                                    property + " as function");
+            }
+
+            if (wrappedMethod.restore && wrappedMethod.restore.sinon) {
+                throw new TypeError("Attempted to wrap " + property + " which is already wrapped");
+            }
+
+            if (wrappedMethod.calledBefore) {
+                var verb = !!wrappedMethod.returns ? "stubbed" : "spied on";
+                throw new TypeError("Attempted to wrap " + property + " which is already " + verb);
+            }
+
+            // IE 8 does not support hasOwnProperty on the window object.
+            var owned = hasOwn.call(object, property);
+            object[property] = method;
+            method.displayName = property;
+
+            method.restore = function () {
+                if(owned) {
+                    object[property] = wrappedMethod;
+                } else {
+                    delete object[property];
+                }
+            };
+
+            method.restore.sinon = true;
+            mirrorProperties(method, wrappedMethod);
+
+            return method;
+        },
+
+        extend: function extend(target) {
+            for (var i = 1, l = arguments.length; i < l; i += 1) {
+                for (var prop in arguments[i]) {
+                    if (arguments[i].hasOwnProperty(prop)) {
+                        target[prop] = arguments[i][prop];
+                    }
+
+                    // DONT ENUM bug, only care about toString
+                    if (arguments[i].hasOwnProperty("toString") &&
+                        arguments[i].toString != target.toString) {
+                        target.toString = arguments[i].toString;
+                    }
+                }
+            }
+
+            return target;
+        },
+
+        create: function create(proto) {
+            var F = function () {};
+            F.prototype = proto;
+            return new F();
+        },
+
+        deepEqual: function deepEqual(a, b) {
+            if (typeof a != "object" || typeof b != "object") {
+                return a === b;
+            }
+
+            if (isElement(a) || isElement(b)) {
+                return a === b;
+            }
+
+            if (a === b) {
+                return true;
+            }
+
+            var aString = Object.prototype.toString.call(a);
+            if (aString != Object.prototype.toString.call(b)) {
+                return false;
+            }
+
+            if (aString == "[object Array]") {
+                if (a.length !== b.length) {
+                    return false;
+                }
+
+                for (var i = 0, l = a.length; i < l; i += 1) {
+                    if (!deepEqual(a[i], b[i])) {
+                        return false;
+                    }
+                }
+
+                return true;
+            }
+
+            var prop, aLength = 0, bLength = 0;
+
+            for (prop in a) {
+                aLength += 1;
+
+                if (!deepEqual(a[prop], b[prop])) {
+                    return false;
+                }
+            }
+
+            for (prop in b) {
+                bLength += 1;
+            }
+
+            if (aLength != bLength) {
+                return false;
+            }
+
+            return true;
+        },
+
+        functionName: function functionName(func) {
+            var name = func.displayName || func.name;
+
+            // Use function decomposition as a last resort to get function
+            // name. Does not rely on function decomposition to work - if it
+            // doesn't debugging will be slightly less informative
+            // (i.e. toString will say 'spy' rather than 'myFunc').
+            if (!name) {
+                var matches = func.toString().match(/function ([^\s\(]+)/);
+                name = matches && matches[1];
+            }
+
+            return name;
+        },
+
+        functionToString: function toString() {
+            if (this.getCall && this.callCount) {
+                var thisValue, prop, i = this.callCount;
+
+                while (i--) {
+                    thisValue = this.getCall(i).thisValue;
+
+                    for (prop in thisValue) {
+                        if (thisValue[prop] === this) {
+                            return prop;
+                        }
+                    }
+                }
+            }
+
+            return this.displayName || "sinon fake";
+        },
+
+        getConfig: function (custom) {
+            var config = {};
+            custom = custom || {};
+            var defaults = sinon.defaultConfig;
+
+            for (var prop in defaults) {
+                if (defaults.hasOwnProperty(prop)) {
+                    config[prop] = custom.hasOwnProperty(prop) ? custom[prop] : defaults[prop];
+                }
+            }
+
+            return config;
+        },
+
+        format: function (val) {
+            return "" + val;
+        },
+
+        defaultConfig: {
+            injectIntoThis: true,
+            injectInto: null,
+            properties: ["spy", "stub", "mock", "clock", "server", "requests"],
+            useFakeTimers: true,
+            useFakeServer: true
+        },
+
+        timesInWords: function timesInWords(count) {
+            return count == 1 && "once" ||
+                count == 2 && "twice" ||
+                count == 3 && "thrice" ||
+                (count || 0) + " times";
+        },
+
+        calledInOrder: function (spies) {
+            for (var i = 1, l = spies.length; i < l; i++) {
+                if (!spies[i - 1].calledBefore(spies[i])) {
+                    return false;
+                }
+            }
+
+            return true;
+        },
+
+        orderByFirstCall: function (spies) {
+            return spies.sort(function (a, b) {
+                // uuid, won't ever be equal
+                var aCall = a.getCall(0);
+                var bCall = b.getCall(0);
+                var aId = aCall && aCall.callId || -1;
+                var bId = bCall && bCall.callId || -1;
+
+                return aId < bId ? -1 : 1;
+            });
+        },
+
+        log: function () {},
+
+        logError: function (label, err) {
+            var msg = label + " threw exception: "
+            sinon.log(msg + "[" + err.name + "] " + err.message);
+            if (err.stack) { sinon.log(err.stack); }
+
+            setTimeout(function () {
+                err.message = msg + err.message;
+                throw err;
+            }, 0);
+        }
+    };
+
+    var isNode = typeof module == "object" && typeof require == "function";
+
+    if (isNode) {
+        try {
+            buster = { format: require("buster-format") };
+        } catch (e) {}
+        module.exports = sinon;
+        module.exports.spy = require("./sinon/spy");
+        module.exports.stub = require("./sinon/stub");
+        module.exports.mock = require("./sinon/mock");
+        module.exports.collection = require("./sinon/collection");
+        module.exports.assert = require("./sinon/assert");
+        module.exports.sandbox = require("./sinon/sandbox");
+        module.exports.test = require("./sinon/test");
+        module.exports.testCase = require("./sinon/test_case");
+        module.exports.assert = require("./sinon/assert");
+    }
+
+    if (buster) {
+        var formatter = sinon.create(buster.format);
+        formatter.quoteStrings = false;
+        sinon.format = function () {
+            return formatter.ascii.apply(formatter, arguments);
+        };
+    } else if (isNode) {
+        try {
+            var util = require("util");
+            sinon.format = function (value) {
+                return typeof value == "object" ? util.inspect(value) : value;
+            };
+        } catch (e) {
+            /* Node, but no util module - would be very old, but better safe than
+             sorry */
+        }
+    }
+
+    return sinon;
+}(typeof buster == "object" && buster));
+
+/* @depend ../sinon.js */
+/*jslint eqeqeq: false, onevar: false, plusplus: false*/
+/*global module, require, sinon*/
+/**
+ * Spy functions
+ *
+ * @author Christian Johansen (christian@cjohansen.no)
+ * @license BSD
+ *
+ * Copyright (c) 2010-2011 Christian Johansen
+ */
+
+(function (sinon) {
+    var commonJSModule = typeof module == "object" && typeof require == "function";
+    var spyCall;
+    var callId = 0;
+    var push = [].push;
+    var slice = Array.prototype.slice;
+
+    if (!sinon && commonJSModule) {
+        sinon = require("../sinon");
+    }
+
+    if (!sinon) {
+        return;
+    }
+
+    function spy(object, property) {
+        if (!property && typeof object == "function") {
+            return spy.create(object);
+        }
+
+        if (!object || !property) {
+            return spy.create(function () {});
+        }
+
+        var method = object[property];
+        return sinon.wrapMethod(object, property, spy.create(method));
+    }
+
+    sinon.extend(spy, (function () {
+
+        function delegateToCalls(api, method, matchAny, actual, notCalled) {
+            api[method] = function () {
+                if (!this.called) {
+                    if (notCalled) {
+                        return notCalled.apply(this, arguments);
+                    }
+                    return false;
+                }
+
+                var currentCall;
+                var matches = 0;
+
+                for (var i = 0, l = this.callCount; i < l; i += 1) {
+                    currentCall = this.getCall(i);
+
+                    if (currentCall[actual || method].apply(currentCall, arguments)) {
+                        matches += 1;
+
+                        if (matchAny) {
+                            return true;
+                        }
+                    }
+                }
+
+                return matches === this.callCount;
+            };
+        }
+
+        function matchingFake(fakes, args, strict) {
+            if (!fakes) {
+                return;
+            }
+
+            var alen = args.length;
+
+            for (var i = 0, l = fakes.length; i < l; i++) {
+                if (fakes[i].matches(args, strict)) {
+                    return fakes[i];
+                }
+            }
+        }
+
+        function incrementCallCount() {
+            this.called = true;
+            this.callCount += 1;
+            this.calledOnce = this.callCount == 1;
+            this.calledTwice = this.callCount == 2;
+            this.calledThrice = this.callCount == 3;
+        }
+
+        function createCallProperties() {
+            this.firstCall = this.getCall(0);
+            this.secondCall = this.getCall(1);
+            this.thirdCall = this.getCall(2);
+            this.lastCall = this.getCall(this.callCount - 1);
+        }
+
+        var uuid = 0;
+
+        // Public API
+        var spyApi = {
+            reset: function () {
+                this.called = false;
+                this.calledOnce = false;
+                this.calledTwice = false;
+                this.calledThrice = false;
+                this.callCount = 0;
+                this.firstCall = null;
+                this.secondCall = null;
+                this.thirdCall = null;
+                this.lastCall = null;
+                this.args = [];
+                this.returnValues = [];
+                this.thisValues = [];
+                this.exceptions = [];
+                this.callIds = [];
+            },
+
+            create: function create(func) {
+                var name;
+
+                if (typeof func != "function") {
+                    func = function () {};
+                } else {
+                    name = sinon.functionName(func);
+                }
+
+                function proxy() {
+                    return proxy.invoke(func, this, slice.call(arguments));
+                }
+
+                sinon.extend(proxy, spy);
+                delete proxy.create;
+                sinon.extend(proxy, func);
+
+                proxy.reset();
+                proxy.prototype = func.prototype;
+                proxy.displayName = name || "spy";
+                proxy.toString = sinon.functionToString;
+                proxy._create = sinon.spy.create;
+                proxy.id = "spy#" + uuid++;
+
+                return proxy;
+            },
+
+            invoke: function invoke(func, thisValue, args) {
+                var matching = matchingFake(this.fakes, args);
+                var exception, returnValue;
+
+                incrementCallCount.call(this);
+                push.call(this.thisValues, thisValue);
+                push.call(this.args, args);
+                push.call(this.callIds, callId++);
+
+                try {
+                    if (matching) {
+                        returnValue = matching.invoke(func, thisValue, args);
+                    } else {
+                        returnValue = (this.func || func).apply(thisValue, args);
+                    }
+                } catch (e) {
+                    push.call(this.returnValues, undefined);
+                    exception = e;
+                    throw e;
+                } finally {
+                    push.call(this.exceptions, exception);
+                }
+
+                push.call(this.returnValues, returnValue);
+
+                createCallProperties.call(this);
+
+                return returnValue;
+            },
+
+            getCall: function getCall(i) {
+                if (i < 0 || i >= this.callCount) {
+                    return null;
+                }
+
+                return spyCall.create(this, this.thisValues[i], this.args[i],
+                                      this.returnValues[i], this.exceptions[i],
+                                      this.callIds[i]);
+            },
+
+            calledBefore: function calledBefore(spyFn) {
+                if (!this.called) {
+                    return false;
+                }
+
+                if (!spyFn.called) {
+                    return true;
+                }
+
+                return this.callIds[0] < spyFn.callIds[spyFn.callIds.length - 1];
+            },
+
+            calledAfter: function calledAfter(spyFn) {
+                if (!this.called || !spyFn.called) {
+                    return false;
+                }
+
+                return this.callIds[this.callCount - 1] > spyFn.callIds[spyFn.callCount - 1];
+            },
+
+            withArgs: function () {
+                var args = slice.call(arguments);
+
+                if (this.fakes) {
+                    var match = matchingFake(this.fakes, args, true);
+
+                    if (match) {
+                        return match;
+                    }
+                } else {
+                    this.fakes = [];
+                }
+
+                var original = this;
+                var fake = this._create();
+                fake.matchingAguments = args;
+                push.call(this.fakes, fake);
+
+                fake.withArgs = function () {
+                    return original.withArgs.apply(original, arguments);
+                };
+
+                for (var i = 0; i < this.args.length; i++) {
+                    if (fake.matches(this.args[i])) {
+                        incrementCallCount.call(fake);
+                        push.call(fake.thisValues, this.thisValues[i]);
+                        push.call(fake.args, this.args[i]);
+                        push.call(fake.returnValues, this.returnValues[i]);
+                        push.call(fake.exceptions, this.exceptions[i]);
+                        push.call(fake.callIds, this.callIds[i]);
+                    }
+                }
+                createCallProperties.call(fake);
+
+                return fake;
+            },
+
+            matches: function (args, strict) {
+                var margs = this.matchingAguments;
+
+                if (margs.length <= args.length &&
+                    sinon.deepEqual(margs, args.slice(0, margs.length))) {
+                    return !strict || margs.length == args.length;
+                }
+            },
+
+            printf: function (format) {
+                var spy = this;
+                var args = slice.call(arguments, 1);
+                var formatter;
+
+                return (format || "").replace(/%(.)/g, function (match, specifyer) {
+                    formatter = spyApi.formatters[specifyer];
+
+                    if (typeof formatter == "function") {
+                        return formatter.call(null, spy, args);
+                    } else if (!isNaN(parseInt(specifyer), 10)) {
+                        return sinon.format(args[specifyer - 1]);
+                    }
+
+                    return "%" + specifyer;
+                });
+            }
+        };
+
+        delegateToCalls(spyApi, "calledOn", true);
+        delegateToCalls(spyApi, "alwaysCalledOn", false, "calledOn");
+        delegateToCalls(spyApi, "calledWith", true);
+        delegateToCalls(spyApi, "alwaysCalledWith", false, "calledWith");
+        delegateToCalls(spyApi, "calledWithExactly", true);
+        delegateToCalls(spyApi, "alwaysCalledWithExactly", false, "calledWithExactly");
+        delegateToCalls(spyApi, "neverCalledWith", false, "notCalledWith",
+            function () { return true; });
+        delegateToCalls(spyApi, "threw", true);
+        delegateToCalls(spyApi, "alwaysThrew", false, "threw");
+        delegateToCalls(spyApi, "returned", true);
+        delegateToCalls(spyApi, "alwaysReturned", false, "returned");
+        delegateToCalls(spyApi, "calledWithNew", true);
+        delegateToCalls(spyApi, "alwaysCalledWithNew", false, "calledWithNew");
+        delegateToCalls(spyApi, "callArg", false, "callArgWith", function () {
+            throw new Error(this.toString() + " cannot call arg since it was not yet invoked.");
+        });
+        spyApi.callArgWith = spyApi.callArg;
+        delegateToCalls(spyApi, "yield", false, "yield", function () {
+            throw new Error(this.toString() + " cannot yield since it was not yet invoked.");
+        });
+        // "invokeCallback" is an alias for "yield" since "yield" is invalid in strict mode.
+        spyApi.invokeCallback = spyApi.yield;
+        delegateToCalls(spyApi, "yieldTo", false, "yieldTo", function (property) {
+            throw new Error(this.toString() + " cannot yield to '" + property +
+                "' since it was not yet invoked.");
+        });
+
+        spyApi.formatters = {
+            "c": function (spy) {
+                return sinon.timesInWords(spy.callCount);
+            },
+
+            "n": function (spy) {
+                return spy.toString();
+            },
+
+            "C": function (spy) {
+                var calls = [];
+
+                for (var i = 0, l = spy.callCount; i < l; ++i) {
+                    push.call(calls, "    " + spy.getCall(i).toString());
+                }
+
+                return calls.length > 0 ? "\n" + calls.join("\n") : "";
+            },
+
+            "t": function (spy) {
+                var objects = [];
+
+                for (var i = 0, l = spy.callCount; i < l; ++i) {
+                    push.call(objects, sinon.format(spy.thisValues[i]));
+                }
+
+                return objects.join(", ");
+            },
+
+            "*": function (spy, args) {
+                return args.join(", ");
+            }
+        };
+
+        return spyApi;
+    }()));
+
+    spyCall = (function () {
+
+        function throwYieldError(proxy, text, args) {
+            var msg = sinon.functionName(proxy) + text;
+            if (args.length) {
+                msg += " Received [" + slice.call(args).join(", ") + "]";
+            }
+            throw new Error(msg);
+        }
+
+        return {
+            create: function create(spy, thisValue, args, returnValue, exception, id) {
+                var proxyCall = sinon.create(spyCall);
+                delete proxyCall.create;
+                proxyCall.proxy = spy;
+                proxyCall.thisValue = thisValue;
+                proxyCall.args = args;
+                proxyCall.returnValue = returnValue;
+                proxyCall.exception = exception;
+                proxyCall.callId = typeof id == "number" && id || callId++;
+
+                return proxyCall;
+            },
+
+            calledOn: function calledOn(thisValue) {
+                return this.thisValue === thisValue;
+            },
+
+            calledWith: function calledWith() {
+                for (var i = 0, l = arguments.length; i < l; i += 1) {
+                    if (!sinon.deepEqual(arguments[i], this.args[i])) {
+                        return false;
+                    }
+                }
+
+                return true;
+            },
+
+            calledWithExactly: function calledWithExactly() {
+                return arguments.length == this.args.length &&
+                    this.calledWith.apply(this, arguments);
+            },
+
+            notCalledWith: function notCalledWith() {
+                for (var i = 0, l = arguments.length; i < l; i += 1) {
+                    if (!sinon.deepEqual(arguments[i], this.args[i])) {
+                        return true;
+                    }
+                }
+                return false;
+            },
+
+            returned: function returned(value) {
+                return this.returnValue === value;
+            },
+
+            threw: function threw(error) {
+                if (typeof error == "undefined" || !this.exception) {
+                    return !!this.exception;
+                }
+
+                if (typeof error == "string") {
+                    return this.exception.name == error;
+                }
+
+                return this.exception === error;
+            },
+
+            calledWithNew: function calledWithNew(thisValue) {
+                return this.thisValue instanceof this.proxy;
+            },
+
+            calledBefore: function (other) {
+                return this.callId < other.callId;
+            },
+
+            calledAfter: function (other) {
+                return this.callId > other.callId;
+            },
+
+            callArg: function (pos) {
+                this.args[pos]();
+            },
+
+            callArgWith: function (pos) {
+                var args = slice.call(arguments, 1);
+                this.args[pos].apply(null, args);
+            },
+
+            "yield": function () {
+                var args = this.args;
+                for (var i = 0, l = args.length; i < l; ++i) {
+                    if (typeof args[i] === "function") {
+                        args[i].apply(null, slice.call(arguments));
+                        return;
+                    }
+                }
+                throwYieldError(this.proxy, " cannot yield since no callback was passed.", args);
+            },
+
+            yieldTo: function (prop) {
+                var args = this.args;
+                for (var i = 0, l = args.length; i < l; ++i) {
+                    if (args[i] && typeof args[i][prop] === "function") {
+                        args[i][prop].apply(null, slice.call(arguments, 1));
+                        return;
+                    }
+                }
+                throwYieldError(this.proxy, " cannot yield to '" + prop +
+                    "' since no callback was passed.", args);
+            },
+
+            toString: function () {
+                var callStr = this.proxy.toString() + "(";
+                var args = [];
+
+                for (var i = 0, l = this.args.length; i < l; ++i) {
+                    push.call(args, sinon.format(this.args[i]));
+                }
+
+                callStr = callStr + args.join(", ") + ")";
+
+                if (typeof this.returnValue != "undefined") {
+                    callStr += " => " + sinon.format(this.returnValue);
+                }
+
+                if (this.exception) {
+                    callStr += " !" + this.exception.name;
+
+                    if (this.exception.message) {
+                        callStr += "(" + this.exception.message + ")";
+                    }
+                }
+
+                return callStr;
+            }
+        };
+    }());
+
+    spy.spyCall = spyCall;
+
+    // This steps outside the module sandbox and will be removed
+    sinon.spyCall = spyCall;
+
+    if (commonJSModule) {
+        module.exports = spy;
+    } else {
+        sinon.spy = spy;
+    }
+}(typeof sinon == "object" && sinon || null));
+
+/**
+ * @depend ../sinon.js
+ * @depend spy.js
+ */
+/*jslint eqeqeq: false, onevar: false*/
+/*global module, require, sinon*/
+/**
+ * Stub functions
+ *
+ * @author Christian Johansen (christian@cjohansen.no)
+ * @license BSD
+ *
+ * Copyright (c) 2010-2011 Christian Johansen
+ */
+
+(function (sinon) {
+    var commonJSModule = typeof module == "object" && typeof require == "function";
+
+    if (!sinon && commonJSModule) {
+        sinon = require("../sinon");
+    }
+
+    if (!sinon) {
+        return;
+    }
+
+    function stub(object, property, func) {
+        if (!!func && typeof func != "function") {
+            throw new TypeError("Custom stub should be function");
+        }
+
+        var wrapper;
+
+        if (func) {
+            wrapper = sinon.spy && sinon.spy.create ? sinon.spy.create(func) : func;
+        } else {
+            wrapper = stub.create();
+        }
+
+        if (!object && !property) {
+            return sinon.stub.create();
+        }
+
+        if (!property && !!object && typeof object == "object") {
+            for (var prop in object) {
+                if (typeof object[prop] === "function") {
+                    stub(object, prop);
+                }
+            }
+
+            return object;
+        }
+
+        return sinon.wrapMethod(object, property, wrapper);
+    }
+
+    function getCallback(stub, args) {
+        if (stub.callArgAt < 0) {
+            for (var i = 0, l = args.length; i < l; ++i) {
+                if (!stub.callArgProp && typeof args[i] == "function") {
+                    return args[i];
+                }
+
+                if (stub.callArgProp && args[i] &&
+                    typeof args[i][stub.callArgProp] == "function") {
+                    return args[i][stub.callArgProp];
+                }
+            }
+
+            return null;
+        }
+
+        return args[stub.callArgAt];
+    }
+
+    var join = Array.prototype.join;
+
+    function getCallbackError(stub, func, args) {
+        if (stub.callArgAt < 0) {
+            var msg;
+
+            if (stub.callArgProp) {
+                msg = sinon.functionName(stub) +
+                    " expected to yield to '" + stub.callArgProp +
+                    "', but no object with such a property was passed."
+            } else {
+                msg = sinon.functionName(stub) +
+                            " expected to yield, but no callback was passed."
+            }
+
+            if (args.length > 0) {
+                msg += " Received [" + join.call(args, ", ") + "]";
+            }
+
+            return msg;
+        }
+
+        return "argument at index " + stub.callArgAt + " is not a function: " + func;
+    }
+
+    function callCallback(stub, args) {
+        if (typeof stub.callArgAt == "number") {
+            var func = getCallback(stub, args);
+
+            if (typeof func != "function") {
+                throw new TypeError(getCallbackError(stub, func, args));
+            }
+
+            func.apply(stub.callbackContext, stub.callbackArguments);
+        }
+    }
+
+    var uuid = 0;
+
+    sinon.extend(stub, (function () {
+        var slice = Array.prototype.slice;
+
+        function throwsException(error, message) {
+            if (typeof error == "string") {
+                this.exception = new Error(message || "");
+                this.exception.name = error;
+            } else if (!error) {
+                this.exception = new Error("Error");
+            } else {
+                this.exception = error;
+            }
+
+            return this;
+        }
+
+        return {
+            create: function create() {
+                var functionStub = function () {
+                    if (functionStub.exception) {
+                        throw functionStub.exception;
+                    } else if (typeof functionStub.returnArgAt == 'number') {
+                        return arguments[functionStub.returnArgAt];
+                    }
+
+                    callCallback(functionStub, arguments);
+
+                    return functionStub.returnValue;
+                };
+
+                functionStub.id = "stub#" + uuid++;
+                var orig = functionStub;
+                functionStub = sinon.spy.create(functionStub);
+                functionStub.func = orig;
+
+                sinon.extend(functionStub, stub);
+                functionStub._create = sinon.stub.create;
+                functionStub.displayName = "stub";
+                functionStub.toString = sinon.functionToString;
+
+                return functionStub;
+            },
+
+            returns: function returns(value) {
+                this.returnValue = value;
+
+                return this;
+            },
+
+            returnsArg: function returnsArg(pos) {
+                if (typeof pos != "number") {
+                    throw new TypeError("argument index is not number");
+                }
+
+                this.returnArgAt = pos;
+
+                return this;
+            },
+
+            "throws": throwsException,
+            throwsException: throwsException,
+
+            callsArg: function callsArg(pos) {
+                if (typeof pos != "number") {
+                    throw new TypeError("argument index is not number");
+                }
+
+                this.callArgAt = pos;
+                this.callbackArguments = [];
+
+                return this;
+            },
+
+            callsArgOn: function callsArgOn(pos, context) {
+                if (typeof pos != "number") {
+                    throw new TypeError("argument index is not number");
+                }
+                if (typeof context != "object") {
+                    throw new TypeError("argument context is not an object");
+                }
+
+                this.callArgAt = pos;
+                this.callbackArguments = [];
+                this.callbackContext = context;
+
+                return this;
+            },
+
+            callsArgWith: function callsArgWith(pos) {
+                if (typeof pos != "number") {
+                    throw new TypeError("argument index is not number");
+                }
+
+                this.callArgAt = pos;
+                this.callbackArguments = slice.call(arguments, 1);
+
+                return this;
+            },
+
+            callsArgOnWith: function callsArgWith(pos, context) {
+                if (typeof pos != "number") {
+                    throw new TypeError("argument index is not number");
+                }
+                if (typeof context != "object") {
+                    throw new TypeError("argument context is not an object");
+                }
+
+                this.callArgAt = pos;
+                this.callbackArguments = slice.call(arguments, 2);
+                this.callbackContext = context;
+
+                return this;
+            },
+
+            yields: function () {
+                this.callArgAt = -1;
+                this.callbackArguments = slice.call(arguments, 0);
+
+                return this;
+            },
+
+            yieldsOn: function (context) {
+                if (typeof context != "object") {
+                    throw new TypeError("argument context is not an object");
+                }
+
+                this.callArgAt = -1;
+                this.callbackArguments = slice.call(arguments, 1);
+                this.callbackContext = context;
+
+                return this;
+            },
+
+            yieldsTo: function (prop) {
+                this.callArgAt = -1;
+                this.callArgProp = prop;
+                this.callbackArguments = slice.call(arguments, 1);
+
+                return this;
+            },
+
+            yieldsToOn: function (prop, context) {
+                if (typeof context != "object") {
+                    throw new TypeError("argument context is not an object");
+                }
+
+                this.callArgAt = -1;
+                this.callArgProp = prop;
+                this.callbackArguments = slice.call(arguments, 2);
+                this.callbackContext = context;
+
+                return this;
+            }
+        };
+    }()));
+
+    if (commonJSModule) {
+        module.exports = stub;
+    } else {
+        sinon.stub = stub;
+    }
+}(typeof sinon == "object" && sinon || null));
+
+/**
+ * @depend ../sinon.js
+ * @depend stub.js
+ */
+/*jslint eqeqeq: false, onevar: false, nomen: false*/
+/*global module, require, sinon*/
+/**
+ * Mock functions.
+ *
+ * @author Christian Johansen (christian@cjohansen.no)
+ * @license BSD
+ *
+ * Copyright (c) 2010-2011 Christian Johansen
+ */
+
+(function (sinon) {
+    var commonJSModule = typeof module == "object" && typeof require == "function";
+    var push = [].push;
+
+    if (!sinon && commonJSModule) {
+        sinon = require("../sinon");
+    }
+
+    if (!sinon) {
+        return;
+    }
+
+    function mock(object) {
+        if (!object) {
+            return sinon.expectation.create("Anonymous mock");
+        }
+
+        return mock.create(object);
+    }
+
+    sinon.mock = mock;
+
+    sinon.extend(mock, (function () {
+        function each(collection, callback) {
+            if (!collection) {
+                return;
+            }
+
+            for (var i = 0, l = collection.length; i < l; i += 1) {
+                callback(collection[i]);
+            }
+        }
+
+        return {
+            create: function create(object) {
+                if (!object) {
+                    throw new TypeError("object is null");
+                }
+
+                var mockObject = sinon.extend({}, mock);
+                mockObject.object = object;
+                delete mockObject.create;
+
+                return mockObject;
+            },
+
+            expects: function expects(method) {
+                if (!method) {
+                    throw new TypeError("method is falsy");
+                }
+
+                if (!this.expectations) {
+                    this.expectations = {};
+                    this.proxies = [];
+                }
+
+                if (!this.expectations[method]) {
+                    this.expectations[method] = [];
+                    var mockObject = this;
+
+                    sinon.wrapMethod(this.object, method, function () {
+                        return mockObject.invokeMethod(method, this, arguments);
+                    });
+
+                    push.call(this.proxies, method);
+                }
+
+                var expectation = sinon.expectation.create(method);
+                push.call(this.expectations[method], expectation);
+
+                return expectation;
+            },
+
+            restore: function restore() {
+                var object = this.object;
+
+                each(this.proxies, function (proxy) {
+                    if (typeof object[proxy].restore == "function") {
+                        object[proxy].restore();
+                    }
+                });
+            },
+
+            verify: function verify() {
+                var expectations = this.expectations || {};
+                var messages = [], met = [];
+
+                each(this.proxies, function (proxy) {
+                    each(expectations[proxy], function (expectation) {
+                        if (!expectation.met()) {
+                            push.call(messages, expectation.toString());
+                        } else {
+                            push.call(met, expectation.toString());
+                        }
+                    });
+                });
+
+                this.restore();
+
+                if (messages.length > 0) {
+                    sinon.expectation.fail(messages.concat(met).join("\n"));
+                }
+
+                return true;
+            },
+
+            invokeMethod: function invokeMethod(method, thisValue, args) {
+                var expectations = this.expectations && this.expectations[method];
+                var length = expectations && expectations.length || 0;
+
+                for (var i = 0; i < length; i += 1) {
+                    if (!expectations[i].met() &&
+                        expectations[i].allowsCall(thisValue, args)) {
+                        return expectations[i].apply(thisValue, args);
+                    }
+                }
+
+                var messages = [];
+
+                for (i = 0; i < length; i += 1) {
+                    push.call(messages, "    " + expectations[i].toString());
+                }
+
+                messages.unshift("Unexpected call: " + sinon.spyCall.toString.call({
+                    proxy: method,
+                    args: args
+                }));
+
+                sinon.expectation.fail(messages.join("\n"));
+            }
+        };
+    }()));
+
+    var times = sinon.timesInWords;
+
+    sinon.expectation = (function () {
+        var slice = Array.prototype.slice;
+        var _invoke = sinon.spy.invoke;
+
+        function callCountInWords(callCount) {
+            if (callCount == 0) {
+                return "never called";
+            } else {
+                return "called " + times(callCount);
+            }
+        }
+
+        function expectedCallCountInWords(expectation) {
+            var min = expectation.minCalls;
+            var max = expectation.maxCalls;
+
+            if (typeof min == "number" && typeof max == "number") {
+                var str = times(min);
+
+                if (min != max) {
+                    str = "at least " + str + " and at most " + times(max);
+                }
+
+                return str;
+            }
+
+            if (typeof min == "number") {
+                return "at least " + times(min);
+            }
+
+            return "at most " + times(max);
+        }
+
+        function receivedMinCalls(expectation) {
+            var hasMinLimit = typeof expectation.minCalls == "number";
+            return !hasMinLimit || expectation.callCount >= expectation.minCalls;
+        }
+
+        function receivedMaxCalls(expectation) {
+            if (typeof expectation.maxCalls != "number") {
+                return false;
+            }
+
+            return expectation.callCount == expectation.maxCalls;
+        }
+
+        return {
+            minCalls: 1,
+            maxCalls: 1,
+
+            create: function create(methodName) {
+                var expectation = sinon.extend(sinon.stub.create(), sinon.expectation);
+                delete expectation.create;
+                expectation.method = methodName;
+
+                return expectation;
+            },
+
+            invoke: function invoke(func, thisValue, args) {
+                this.verifyCallAllowed(thisValue, args);
+
+                return _invoke.apply(this, arguments);
+            },
+
+            atLeast: function atLeast(num) {
+                if (typeof num != "number") {
+                    throw new TypeError("'" + num + "' is not number");
+                }
+
+                if (!this.limitsSet) {
+                    this.maxCalls = null;
+                    this.limitsSet = true;
+                }
+
+                this.minCalls = num;
+
+                return this;
+            },
+
+            atMost: function atMost(num) {
+                if (typeof num != "number") {
+                    throw new TypeError("'" + num + "' is not number");
+                }
+
+                if (!this.limitsSet) {
+                    this.minCalls = null;
+                    this.limitsSet = true;
+                }
+
+                this.maxCalls = num;
+
+                return this;
+            },
+
+            never: function never() {
+                return this.exactly(0);
+            },
+
+            once: function once() {
+                return this.exactly(1);
+            },
+
+            twice: function twice() {
+                return this.exactly(2);
+            },
+
+            thrice: function thrice() {
+                return this.exactly(3);
+            },
+
+            exactly: function exactly(num) {
+                if (typeof num != "number") {
+                    throw new TypeError("'" + num + "' is not a number");
+                }
+
+                this.atLeast(num);
+                return this.atMost(num);
+            },
+
+            met: function met() {
+                return !this.failed && receivedMinCalls(this);
+            },
+
+            verifyCallAllowed: function verifyCallAllowed(thisValue, args) {
+                if (receivedMaxCalls(this)) {
+                    this.failed = true;
+                    sinon.expectation.fail(this.method + " already called " + times(this.maxCalls));
+                }
+
+                if ("expectedThis" in this && this.expectedThis !== thisValue) {
+                    sinon.expectation.fail(this.method + " called with " + thisValue + " as thisValue, expected " +
+                        this.expectedThis);
+                }
+
+                if (!("expectedArguments" in this)) {
+                    return;
+                }
+
+                if (!args || args.length === 0) {
+                    sinon.expectation.fail(this.method + " received no arguments, expected " +
+                        this.expectedArguments.join());
+                }
+
+                if (args.length < this.expectedArguments.length) {
+                    sinon.expectation.fail(this.method + " received too few arguments (" + args.join() +
+                        "), expected " + this.expectedArguments.join());
+                }
+
+                if (this.expectsExactArgCount &&
+                    args.length != this.expectedArguments.length) {
+                    sinon.expectation.fail(this.method + " received too many arguments (" + args.join() +
+                        "), expected " + this.expectedArguments.join());
+                }
+
+                for (var i = 0, l = this.expectedArguments.length; i < l; i += 1) {
+                    if (!sinon.deepEqual(this.expectedArguments[i], args[i])) {
+                        sinon.expectation.fail(this.method + " received wrong arguments (" + args.join() +
+                            "), expected " + this.expectedArguments.join());
+                    }
+                }
+            },
+
+            allowsCall: function allowsCall(thisValue, args) {
+                if (this.met()) {
+                    return false;
+                }
+
+                if ("expectedThis" in this && this.expectedThis !== thisValue) {
+                    return false;
+                }
+
+                if (!("expectedArguments" in this)) {
+                    return true;
+                }
+
+                args = args || [];
+
+                if (args.length < this.expectedArguments.length) {
+                    return false;
+                }
+
+                if (this.expectsExactArgCount &&
+                    args.length != this.expectedArguments.length) {
+                    return false;
+                }
+
+                for (var i = 0, l = this.expectedArguments.length; i < l; i += 1) {
+                    if (!sinon.deepEqual(this.expectedArguments[i], args[i])) {
+                        return false;
+                    }
+                }
+
+                return true;
+            },
+
+            withArgs: function withArgs() {
+                this.expectedArguments = slice.call(arguments);
+                return this;
+            },
+
+            withExactArgs: function withExactArgs() {
+                this.withArgs.apply(this, arguments);
+                this.expectsExactArgCount = true;
+                return this;
+            },
+
+            on: function on(thisValue) {
+                this.expectedThis = thisValue;
+                return this;
+            },
+
+            toString: function () {
+                var args = (this.expectedArguments || []).slice();
+
+                if (!this.expectsExactArgCount) {
+                    push.call(args, "[...]");
+                }
+
+                var callStr = sinon.spyCall.toString.call({
+                    proxy: this.method, args: args
+                });
+
+                var message = callStr.replace(", [...", "[, ...") + " " +
+                    expectedCallCountInWords(this);
+
+                if (this.met()) {
+                    return "Expectation met: " + message;
+                }
+
+                return "Expected " + message + " (" +
+                    callCountInWords(this.callCount) + ")";
+            },
+
+            verify: function verify() {
+                if (!this.met()) {
+                    sinon.expectation.fail(this.toString());
+                }
+
+                return true;
+            },
+
+            fail: function (message) {
+                var exception = new Error(message);
+                exception.name = "ExpectationError";
+
+                throw exception;
+            }
+        };
+    }());
+
+    if (commonJSModule) {
+        module.exports = mock;
+    } else {
+        sinon.mock = mock;
+    }
+}(typeof sinon == "object" && sinon || null));
+
+/**
+ * @depend ../sinon.js
+ * @depend stub.js
+ * @depend mock.js
+ */
+/*jslint eqeqeq: false, onevar: false, forin: true*/
+/*global module, require, sinon*/
+/**
+ * Collections of stubs, spies and mocks.
+ *
+ * @author Christian Johansen (christian@cjohansen.no)
+ * @license BSD
+ *
+ * Copyright (c) 2010-2011 Christian Johansen
+ */
+
+(function (sinon) {
+    var commonJSModule = typeof module == "object" && typeof require == "function";
+    var push = [].push;
+
+    if (!sinon && commonJSModule) {
+        sinon = require("../sinon");
+    }
+
+    if (!sinon) {
+        return;
+    }
+
+    function getFakes(fakeCollection) {
+        if (!fakeCollection.fakes) {
+            fakeCollection.fakes = [];
+        }
+
+        return fakeCollection.fakes;
+    }
+
+    function each(fakeCollection, method) {
+        var fakes = getFakes(fakeCollection);
+
+        for (var i = 0, l = fakes.length; i < l; i += 1) {
+            if (typeof fakes[i][method] == "function") {
+                fakes[i][method]();
+            }
+        }
+    }
+
+    function compact(fakeCollection) {
+        var fakes = getFakes(fakeCollection);
+        var i = 0;
+        while (i < fakes.length) {
+          fakes.splice(i, 1);
+        }
+    }
+
+    var collection = {
+        verify: function resolve() {
+            each(this, "verify");
+        },
+
+        restore: function restore() {
+            each(this, "restore");
+            compact(this);
+        },
+
+        verifyAndRestore: function verifyAndRestore() {
+            var exception;
+
+            try {
+                this.verify();
+            } catch (e) {
+                exception = e;
+            }
+
+            this.restore();
+
+            if (exception) {
+                throw exception;
+            }
+        },
+
+        add: function add(fake) {
+            push.call(getFakes(this), fake);
+            return fake;
+        },
+
+        spy: function spy() {
+            return this.add(sinon.spy.apply(sinon, arguments));
+        },
+
+        stub: function stub(object, property, value) {
+            if (property) {
+                var original = object[property];
+
+                if (typeof original != "function") {
+                    if (!object.hasOwnProperty(property)) {
+                        throw new TypeError("Cannot stub non-existent own property " + property);
+                    }
+
+                    object[property] = value;
+
+                    return this.add({
+                        restore: function () {
+                            object[property] = original;
+                        }
+                    });
+                }
+            }
+
+            return this.add(sinon.stub.apply(sinon, arguments));
+        },
+
+        mock: function mock() {
+            return this.add(sinon.mock.apply(sinon, arguments));
+        },
+
+        inject: function inject(obj) {
+            var col = this;
+
+            obj.spy = function () {
+                return col.spy.apply(col, arguments);
+            };
+
+            obj.stub = function () {
+                return col.stub.apply(col, arguments);
+            };
+
+            obj.mock = function () {
+                return col.mock.apply(col, arguments);
+            };
+
+            return obj;
+        }
+    };
+
+    if (commonJSModule) {
+        module.exports = collection;
+    } else {
+        sinon.collection = collection;
+    }
+}(typeof sinon == "object" && sinon || null));
+
+/*jslint eqeqeq: false, plusplus: false, evil: true, onevar: false, browser: true, forin: false*/
+/*global module, require, window*/
+/**
+ * Fake timer API
+ * setTimeout
+ * setInterval
+ * clearTimeout
+ * clearInterval
+ * tick
+ * reset
+ * Date
+ *
+ * Inspired by jsUnitMockTimeOut from JsUnit
+ *
+ * @author Christian Johansen (christian@cjohansen.no)
+ * @license BSD
+ *
+ * Copyright (c) 2010-2011 Christian Johansen
+ */
+
+if (typeof sinon == "undefined") {
+    var sinon = {};
+}
+
+(function (global) {
+    var id = 1;
+
+    function addTimer(args, recurring) {
+        if (args.length === 0) {
+            throw new Error("Function requires at least 1 parameter");
+        }
+
+        var toId = id++;
+        var delay = args[1] || 0;
+
+        if (!this.timeouts) {
+            this.timeouts = {};
+        }
+
+        this.timeouts[toId] = {
+            id: toId,
+            func: args[0],
+            callAt: this.now + delay
+        };
+
+        if (recurring === true) {
+            this.timeouts[toId].interval = delay;
+        }
+
+        return toId;
+    }
+
+    function parseTime(str) {
+        if (!str) {
+            return 0;
+        }
+
+        var strings = str.split(":");
+        var l = strings.length, i = l;
+        var ms = 0, parsed;
+
+        if (l > 3 || !/^(\d\d:){0,2}\d\d?$/.test(str)) {
+            throw new Error("tick only understands numbers and 'h:m:s'");
+        }
+
+        while (i--) {
+            parsed = parseInt(strings[i], 10);
+
+            if (parsed >= 60) {
+                throw new Error("Invalid time " + str);
+            }
+
+            ms += parsed * Math.pow(60, (l - i - 1));
+        }
+
+        return ms * 1000;
+    }
+
+    function createObject(object) {
+        var newObject;
+
+        if (Object.create) {
+            newObject = Object.create(object);
+        } else {
+            var F = function () {};
+            F.prototype = object;
+            newObject = new F();
+        }
+
+        newObject.Date.clock = newObject;
+        return newObject;
+    }
+
+    sinon.clock = {
+        now: 0,
+
+        create: function create(now) {
+            var clock = createObject(this);
+
+            if (typeof now == "number") {
+                clock.now = now;
+            }
+
+            if (!!now && typeof now == "object") {
+                throw new TypeError("now should be milliseconds since UNIX epoch");
+            }
+
+            return clock;
+        },
+
+        setTimeout: function setTimeout(callback, timeout) {
+            return addTimer.call(this, arguments, false);
+        },
+
+        clearTimeout: function clearTimeout(timerId) {
+            if (!this.timeouts) {
+                this.timeouts = [];
+            }
+
+            if (timerId in this.timeouts) {
+                delete this.timeouts[timerId];
+            }
+        },
+
+        setInterval: function setInterval(callback, timeout) {
+            return addTimer.call(this, arguments, true);
+        },
+
+        clearInterval: function clearInterval(timerId) {
+            this.clearTimeout(timerId);
+        },
+
+        tick: function tick(ms) {
+            ms = typeof ms == "number" ? ms : parseTime(ms);
+            var tickFrom = this.now, tickTo = this.now + ms, previous = this.now;
+            var timer = this.firstTimerInRange(tickFrom, tickTo);
+
+            var firstException;
+            while (timer && tickFrom <= tickTo) {
+                if (this.timeouts[timer.id]) {
+                    tickFrom = this.now = timer.callAt;
+                    try {
+                      this.callTimer(timer);
+                    } catch (e) {
+                      firstException = firstException || e;
+                    }
+                }
+
+                timer = this.firstTimerInRange(previous, tickTo);
+                previous = tickFrom;
+            }
+
+            this.now = tickTo;
+
+            if (firstException) {
+              throw firstException;
+            }
+        },
+
+        firstTimerInRange: function (from, to) {
+            var timer, smallest, originalTimer;
+
+            for (var id in this.timeouts) {
+                if (this.timeouts.hasOwnProperty(id)) {
+                    if (this.timeouts[id].callAt < from || this.timeouts[id].callAt > to) {
+                        continue;
+                    }
+
+                    if (!smallest || this.timeouts[id].callAt < smallest) {
+                        originalTimer = this.timeouts[id];
+                        smallest = this.timeouts[id].callAt;
+
+                        timer = {
+                            func: this.timeouts[id].func,
+                            callAt: this.timeouts[id].callAt,
+                            interval: this.timeouts[id].interval,
+                            id: this.timeouts[id].id
+                        };
+                    }
+                }
+            }
+
+            return timer || null;
+        },
+
+        callTimer: function (timer) {
+            try {
+                if (typeof timer.func == "function") {
+                    timer.func.call(null);
+                } else {
+                    eval(timer.func);
+                }
+            } catch (e) {
+              var exception = e;
+            }
+
+            if (!this.timeouts[timer.id]) {
+                if (exception) {
+                  throw exception;
+                }
+                return;
+            }
+
+            if (typeof timer.interval == "number") {
+                this.timeouts[timer.id].callAt += timer.interval;
+            } else {
+                delete this.timeouts[timer.id];
+            }
+
+            if (exception) {
+              throw exception;
+            }
+        },
+
+        reset: function reset() {
+            this.timeouts = {};
+        },
+
+        Date: (function () {
+            var NativeDate = Date;
+
+            function ClockDate(year, month, date, hour, minute, second, ms) {
+                // Defensive and verbose to avoid potential harm in passing
+                // explicit undefined when user does not pass argument
+                switch (arguments.length) {
+                case 0:
+                    return new NativeDate(ClockDate.clock.now);
+                case 1:
+                    return new NativeDate(year);
+                case 2:
+                    return new NativeDate(year, month);
+                case 3:
+                    return new NativeDate(year, month, date);
+                case 4:
+                    return new NativeDate(year, month, date, hour);
+                case 5:
+                    return new NativeDate(year, month, date, hour, minute);
+                case 6:
+                    return new NativeDate(year, month, date, hour, minute, second);
+                default:
+                    return new NativeDate(year, month, date, hour, minute, second, ms);
+                }
+            }
+
+            return mirrorDateProperties(ClockDate, NativeDate);
+        }())
+    };
+
+    function mirrorDateProperties(target, source) {
+        if (source.now) {
+            target.now = function now() {
+                return target.clock.now;
+            };
+        } else {
+            delete target.now;
+        }
+
+        if (source.toSource) {
+            target.toSource = function toSource() {
+                return source.toSource();
+            };
+        } else {
+            delete target.toSource;
+        }
+
+        target.toString = function toString() {
+            return source.toString();
+        };
+
+        target.prototype = source.prototype;
+        target.parse = source.parse;
+        target.UTC = source.UTC;
+        target.prototype.toUTCString = source.prototype.toUTCString;
+        return target;
+    }
+
+    var methods = ["Date", "setTimeout", "setInterval",
+                   "clearTimeout", "clearInterval"];
+
+    function restore() {
+        var method;
+
+        for (var i = 0, l = this.methods.length; i < l; i++) {
+            method = this.methods[i];
+            global[method] = this["_" + method];
+        }
+    }
+
+    function stubGlobal(method, clock) {
+        clock["_" + method] = global[method];
+
+        if (method == "Date") {
+            var date = mirrorDateProperties(clock[method], global[method]);
+            global[method] = date;
+        } else {
+            global[method] = function () {
+                return clock[method].apply(clock, arguments);
+            };
+
+            for (var prop in clock[method]) {
+                if (clock[method].hasOwnProperty(prop)) {
+                    global[method][prop] = clock[method][prop];
+                }
+            }
+        }
+
+        global[method].clock = clock;
+    }
+
+    sinon.useFakeTimers = function useFakeTimers(now) {
+        var clock = sinon.clock.create(now);
+        clock.restore = restore;
+        clock.methods = Array.prototype.slice.call(arguments,
+                                                   typeof now == "number" ? 1 : 0);
+
+        if (clock.methods.length === 0) {
+            clock.methods = methods;
+        }
+
+        for (var i = 0, l = clock.methods.length; i < l; i++) {
+            stubGlobal(clock.methods[i], clock);
+        }
+
+        return clock;
+    };
+}(typeof global != "undefined" && typeof global !== "function" ? global : this));
+
+sinon.timers = {
+    setTimeout: setTimeout,
+    clearTimeout: clearTimeout,
+    setInterval: setInterval,
+    clearInterval: clearInterval,
+    Date: Date
+};
+
+if (typeof module == "object" && typeof require == "function") {
+    module.exports = sinon;
+}
+
+/*jslint eqeqeq: false, onevar: false*/
+/*global sinon, module, require, ActiveXObject, XMLHttpRequest, DOMParser*/
+/**
+ * Minimal Event interface implementation
+ *
+ * Original implementation by Sven Fuchs: https://gist.github.com/995028
+ * Modifications and tests by Christian Johansen.
+ *
+ * @author Sven Fuchs (svenfuchs@artweb-design.de)
+ * @author Christian Johansen (christian@cjohansen.no)
+ * @license BSD
+ *
+ * Copyright (c) 2011 Sven Fuchs, Christian Johansen
+ */
+
+if (typeof sinon == "undefined") {
+    this.sinon = {};
+}
+
+(function () {
+    var push = [].push;
+
+    sinon.Event = function Event(type, bubbles, cancelable) {
+        this.initEvent(type, bubbles, cancelable);
+    };
+
+    sinon.Event.prototype = {
+        initEvent: function(type, bubbles, cancelable) {
+            this.type = type;
+            this.bubbles = bubbles;
+            this.cancelable = cancelable;
+        },
+
+        stopPropagation: function () {},
+
+        preventDefault: function () {
+            this.defaultPrevented = true;
+        }
+    };
+
+    sinon.EventTarget = {
+        addEventListener: function addEventListener(event, listener, useCapture) {
+            this.eventListeners = this.eventListeners || {};
+            this.eventListeners[event] = this.eventListeners[event] || [];
+            push.call(this.eventListeners[event], listener);
+        },
+
+        removeEventListener: function removeEventListener(event, listener, useCapture) {
+            var listeners = this.eventListeners && this.eventListeners[event] || [];
+
+            for (var i = 0, l = listeners.length; i < l; ++i) {
+                if (listeners[i] == listener) {
+                    return listeners.splice(i, 1);
+                }
+            }
+        },
+
+        dispatchEvent: function dispatchEvent(event) {
+            var type = event.type;
+            var listeners = this.eventListeners && this.eventListeners[type] || [];
+
+            for (var i = 0; i < listeners.length; i++) {
+                if (typeof listeners[i] == "function") {
+                    listeners[i].call(this, event);
+                } else {
+                    listeners[i].handleEvent(event);
+                }
+            }
+
+            return !!event.defaultPrevented;
+        }
+    };
+}());
+
+/**
+ * @depend event.js
+ */
+/*jslint eqeqeq: false, onevar: false*/
+/*global sinon, module, require, ActiveXObject, XMLHttpRequest, DOMParser*/
+/**
+ * Fake XMLHttpRequest object
+ *
+ * @author Christian Johansen (christian@cjohansen.no)
+ * @license BSD
+ *
+ * Copyright (c) 2010-2011 Christian Johansen
+ */
+
+if (typeof sinon == "undefined") {
+    this.sinon = {};
+}
+sinon.xhr = { XMLHttpRequest: this.XMLHttpRequest };
+
+// wrapper for global
+(function(global) {
+    var xhr = sinon.xhr;
+    xhr.GlobalXMLHttpRequest = global.XMLHttpRequest;
+    xhr.GlobalActiveXObject = global.ActiveXObject;
+    xhr.supportsActiveX = typeof xhr.GlobalActiveXObject != "undefined";
+    xhr.supportsXHR = typeof xhr.GlobalXMLHttpRequest != "undefined";
+    xhr.workingXHR = xhr.supportsXHR ? xhr.GlobalXMLHttpRequest : xhr.supportsActiveX
+                                     ? function() { return new xhr.GlobalActiveXObject("MSXML2.XMLHTTP.3.0") } : false;
+
+    /*jsl:ignore*/
+    var unsafeHeaders = {
+        "Accept-Charset": true,
+        "Accept-Encoding": true,
+        "Connection": true,
+        "Content-Length": true,
+        "Cookie": true,
+        "Cookie2": true,
+        "Content-Transfer-Encoding": true,
+        "Date": true,
+        "Expect": true,
+        "Host": true,
+        "Keep-Alive": true,
+        "Referer": true,
+        "TE": true,
+        "Trailer": true,
+        "Transfer-Encoding": true,
+        "Upgrade": true,
+        "User-Agent": true,
+        "Via": true
+    };
+    /*jsl:end*/
+
+    function FakeXMLHttpRequest() {
+        this.readyState = FakeXMLHttpRequest.UNSENT;
+        this.requestHeaders = {};
+        this.requestBody = null;
+        this.status = 0;
+        this.statusText = "";
+
+        if (typeof FakeXMLHttpRequest.onCreate == "function") {
+            FakeXMLHttpRequest.onCreate(this);
+        }
+    }
+
+    function verifyState(xhr) {
+        if (xhr.readyState !== FakeXMLHttpRequest.OPENED) {
+            throw new Error("INVALID_STATE_ERR");
+        }
+
+        if (xhr.sendFlag) {
+            throw new Error("INVALID_STATE_ERR");
+        }
+    }
+
+    // filtering to enable a white-list version of Sinon FakeXhr,
+    // where whitelisted requests are passed through to real XHR
+    function each(collection, callback) {
+        if (!collection) return;
+        for (var i = 0, l = collection.length; i < l; i += 1) {
+            callback(collection[i]);
+        }
+    }
+    function some(collection, callback) {
+        for (var index = 0; index < collection.length; index++) {
+            if(callback(collection[index]) === true) return true;
+        };
+        return false;
+    }
+    // largest arity in XHR is 5 - XHR#open
+    var apply = function(obj,method,args) {
+        switch(args.length) {
+        case 0: return obj[method]();
+        case 1: return obj[method](args[0]);
+        case 2: return obj[method](args[0],args[1]);
+        case 3: return obj[method](args[0],args[1],args[2]);
+        case 4: return obj[method](args[0],args[1],args[2],args[3]);
+        case 5: return obj[method](args[0],args[1],args[2],args[3],args[4]);
+        };
+    };
+
+    FakeXMLHttpRequest.filters = [];
+    FakeXMLHttpRequest.addFilter = function(fn) {
+        this.filters.push(fn)
+    };
+    var IE6Re = /MSIE 6/;
+    FakeXMLHttpRequest.defake = function(fakeXhr,xhrArgs) {
+        var xhr = new sinon.xhr.workingXHR();
+        each(["open","setRequestHeader","send","abort","getResponseHeader",
+              "getAllResponseHeaders","addEventListener","overrideMimeType","removeEventListener"],
+             function(method) {
+                 fakeXhr[method] = function() {
+                   return apply(xhr,method,arguments);
+                 };
+             });
+
+        var copyAttrs = function(args) {
+            each(args, function(attr) {
+              try {
+                fakeXhr[attr] = xhr[attr]
+              } catch(e) {
+                if(!IE6Re.test(navigator.userAgent)) throw e;
+              }
+            });
+        };
+
+        var stateChange = function() {
+            fakeXhr.readyState = xhr.readyState;
+            if(xhr.readyState >= FakeXMLHttpRequest.HEADERS_RECEIVED) {
+                copyAttrs(["status","statusText"]);
+            }
+            if(xhr.readyState >= FakeXMLHttpRequest.LOADING) {
+                copyAttrs(["responseText"]);
+            }
+            if(xhr.readyState === FakeXMLHttpRequest.DONE) {
+                copyAttrs(["responseXML"]);
+            }
+            if(fakeXhr.onreadystatechange) fakeXhr.onreadystatechange.call(fakeXhr);
+        };
+        if(xhr.addEventListener) {
+          for(var event in fakeXhr.eventListeners) {
+              if(fakeXhr.eventListeners.hasOwnProperty(event)) {
+                  each(fakeXhr.eventListeners[event],function(handler) {
+                      xhr.addEventListener(event, handler);
+                  });
+              }
+          }
+          xhr.addEventListener("readystatechange",stateChange);
+        } else {
+          xhr.onreadystatechange = stateChange;
+        }
+        apply(xhr,"open",xhrArgs);
+    };
+    FakeXMLHttpRequest.useFilters = false;
+
+    function verifyRequestSent(xhr) {
+        if (xhr.readyState == FakeXMLHttpRequest.DONE) {
+            throw new Error("Request done");
+        }
+    }
+
+    function verifyHeadersReceived(xhr) {
+        if (xhr.async && xhr.readyState != FakeXMLHttpRequest.HEADERS_RECEIVED) {
+            throw new Error("No headers received");
+        }
+    }
+
+    function verifyResponseBodyType(body) {
+        if (typeof body != "string") {
+            var error = new Error("Attempted to respond to fake XMLHttpRequest with " +
+                                 body + ", which is not a string.");
+            error.name = "InvalidBodyException";
+            throw error;
+        }
+    }
+
+    sinon.extend(FakeXMLHttpRequest.prototype, sinon.EventTarget, {
+        async: true,
+
+        open: function open(method, url, async, username, password) {
+            this.method = method;
+            this.url = url;
+            this.async = typeof async == "boolean" ? async : true;
+            this.username = username;
+            this.password = password;
+            this.responseText = null;
+            this.responseXML = null;
+            this.requestHeaders = {};
+            this.sendFlag = false;
+            if(sinon.FakeXMLHttpRequest.useFilters === true) {
+                var xhrArgs = arguments;
+                var defake = some(FakeXMLHttpRequest.filters,function(filter) {
+                    return filter.apply(this,xhrArgs)
+                });
+                if (defake) {
+                  return sinon.FakeXMLHttpRequest.defake(this,arguments);
+                }
+            }
+            this.readyStateChange(FakeXMLHttpRequest.OPENED);
+        },
+
+        readyStateChange: function readyStateChange(state) {
+            this.readyState = state;
+
+            if (typeof this.onreadystatechange == "function") {
+                try {
+                    this.onreadystatechange();
+                } catch (e) {
+                    sinon.logError("Fake XHR onreadystatechange handler", e);
+                }
+            }
+
+            this.dispatchEvent(new sinon.Event("readystatechange"));
+        },
+
+        setRequestHeader: function setRequestHeader(header, value) {
+            verifyState(this);
+
+            if (unsafeHeaders[header] || /^(Sec-|Proxy-)/.test(header)) {
+                throw new Error("Refused to set unsafe header \"" + header + "\"");
+            }
+
+            if (this.requestHeaders[header]) {
+                this.requestHeaders[header] += "," + value;
+            } else {
+                this.requestHeaders[header] = value;
+            }
+        },
+
+        // Helps testing
+        setResponseHeaders: function setResponseHeaders(headers) {
+            this.responseHeaders = {};
+
+            for (var header in headers) {
+                if (headers.hasOwnProperty(header)) {
+                    this.responseHeaders[header] = headers[header];
+                }
+            }
+
+            if (this.async) {
+                this.readyStateChange(FakeXMLHttpRequest.HEADERS_RECEIVED);
+            }
+        },
+
+        // Currently treats ALL data as a DOMString (i.e. no Document)
+        send: function send(data) {
+            verifyState(this);
+
+            if (!/^(get|head)$/i.test(this.method)) {
+                if (this.requestHeaders["Content-Type"]) {
+                    var value = this.requestHeaders["Content-Type"].split(";");
+                    this.requestHeaders["Content-Type"] = value[0] + ";charset=utf-8";
+                } else {
+                    this.requestHeaders["Content-Type"] = "text/plain;charset=utf-8";
+                }
+
+                this.requestBody = data;
+            }
+
+            this.errorFlag = false;
+            this.sendFlag = this.async;
+            this.readyStateChange(FakeXMLHttpRequest.OPENED);
+
+            if (typeof this.onSend == "function") {
+                this.onSend(this);
+            }
+        },
+
+        abort: function abort() {
+            this.aborted = true;
+            this.responseText = null;
+            this.errorFlag = true;
+            this.requestHeaders = {};
+
+            if (this.readyState > sinon.FakeXMLHttpRequest.UNSENT && this.sendFlag) {
+                this.readyStateChange(sinon.FakeXMLHttpRequest.DONE);
+                this.sendFlag = false;
+            }
+
+            this.readyState = sinon.FakeXMLHttpRequest.UNSENT;
+        },
+
+        getResponseHeader: function getResponseHeader(header) {
+            if (this.readyState < FakeXMLHttpRequest.HEADERS_RECEIVED) {
+                return null;
+            }
+
+            if (/^Set-Cookie2?$/i.test(header)) {
+                return null;
+            }
+
+            header = header.toLowerCase();
+
+            for (var h in this.responseHeaders) {
+                if (h.toLowerCase() == header) {
+                    return this.responseHeaders[h];
+                }
+            }
+
+            return null;
+        },
+
+        getAllResponseHeaders: function getAllResponseHeaders() {
+            if (this.readyState < FakeXMLHttpRequest.HEADERS_RECEIVED) {
+                return "";
+            }
+
+            var headers = "";
+
+            for (var header in this.responseHeaders) {
+                if (this.responseHeaders.hasOwnProperty(header) &&
+                    !/^Set-Cookie2?$/i.test(header)) {
+                    headers += header + ": " + this.responseHeaders[header] + "\r\n";
+                }
+            }
+
+            return headers;
+        },
+
+        setResponseBody: function setResponseBody(body) {
+            verifyRequestSent(this);
+            verifyHeadersReceived(this);
+            verifyResponseBodyType(body);
+
+            var chunkSize = this.chunkSize || 10;
+            var index = 0;
+            this.responseText = "";
+
+            do {
+                if (this.async) {
+                    this.readyStateChange(FakeXMLHttpRequest.LOADING);
+                }
+
+                this.responseText += body.substring(index, index + chunkSize);
+                index += chunkSize;
+            } while (index < body.length);
+
+            var type = this.getResponseHeader("Content-Type");
+
+            if (this.responseText &&
+                (!type || /(text\/xml)|(application\/xml)|(\+xml)/.test(type))) {
+                try {
+                    this.responseXML = FakeXMLHttpRequest.parseXML(this.responseText);
+                } catch (e) {
+                    // Unable to parse XML - no biggie
+                }
+            }
+
+            if (this.async) {
+                this.readyStateChange(FakeXMLHttpRequest.DONE);
+            } else {
+                this.readyState = FakeXMLHttpRequest.DONE;
+            }
+        },
+
+        respond: function respond(status, headers, body) {
+            this.setResponseHeaders(headers || {});
+            this.status = typeof status == "number" ? status : 200;
+            this.statusText = FakeXMLHttpRequest.statusCodes[this.status];
+            this.setResponseBody(body || "");
+        }
+    });
+
+    sinon.extend(FakeXMLHttpRequest, {
+        UNSENT: 0,
+        OPENED: 1,
+        HEADERS_RECEIVED: 2,
+        LOADING: 3,
+        DONE: 4
+    });
+
+    // Borrowed from JSpec
+    FakeXMLHttpRequest.parseXML = function parseXML(text) {
+        var xmlDoc;
+
+        if (typeof DOMParser != "undefined") {
+            var parser = new DOMParser();
+            xmlDoc = parser.parseFromString(text, "text/xml");
+        } else {
+            xmlDoc = new ActiveXObject("Microsoft.XMLDOM");
+            xmlDoc.async = "false";
+            xmlDoc.loadXML(text);
+        }
+
+        return xmlDoc;
+    };
+
+    FakeXMLHttpRequest.statusCodes = {
+        100: "Continue",
+        101: "Switching Protocols",
+        200: "OK",
+        201: "Created",
+        202: "Accepted",
+        203: "Non-Authoritative Information",
+        204: "No Content",
+        205: "Reset Content",
+        206: "Partial Content",
+        300: "Multiple Choice",
+        301: "Moved Permanently",
+        302: "Found",
+        303: "See Other",
+        304: "Not Modified",
+        305: "Use Proxy",
+        307: "Temporary Redirect",
+        400: "Bad Request",
+        401: "Unauthorized",
+        402: "Payment Required",
+        403: "Forbidden",
+        404: "Not Found",
+        405: "Method Not Allowed",
+        406: "Not Acceptable",
+        407: "Proxy Authentication Required",
+        408: "Request Timeout",
+        409: "Conflict",
+        410: "Gone",
+        411: "Length Required",
+        412: "Precondition Failed",
+        413: "Request Entity Too Large",
+        414: "Request-URI Too Long",
+        415: "Unsupported Media Type",
+        416: "Requested Range Not Satisfiable",
+        417: "Expectation Failed",
+        422: "Unprocessable Entity",
+        500: "Internal Server Error",
+        501: "Not Implemented",
+        502: "Bad Gateway",
+        503: "Service Unavailable",
+        504: "Gateway Timeout",
+        505: "HTTP Version Not Supported"
+    };
+
+    sinon.useFakeXMLHttpRequest = function () {
+        sinon.FakeXMLHttpRequest.restore = function restore(keepOnCreate) {
+            if (xhr.supportsXHR) {
+                global.XMLHttpRequest = xhr.GlobalXMLHttpRequest;
+            }
+
+            if (xhr.supportsActiveX) {
+                global.ActiveXObject = xhr.GlobalActiveXObject;
+            }
+
+            delete sinon.FakeXMLHttpRequest.restore;
+
+            if (keepOnCreate !== true) {
+                delete sinon.FakeXMLHttpRequest.onCreate;
+            }
+        };
+        if (xhr.supportsXHR) {
+            global.XMLHttpRequest = sinon.FakeXMLHttpRequest;
+        }
+
+        if (xhr.supportsActiveX) {
+            global.ActiveXObject = function ActiveXObject(objId) {
+                if (objId == "Microsoft.XMLHTTP" || /^Msxml2\.XMLHTTP/i.test(objId)) {
+
+                    return new sinon.FakeXMLHttpRequest();
+                }
+
+                return new xhr.GlobalActiveXObject(objId);
+            };
+        }
+
+        return sinon.FakeXMLHttpRequest;
+    };
+
+    sinon.FakeXMLHttpRequest = FakeXMLHttpRequest;
+})(this);
+
+if (typeof module == "object" && typeof require == "function") {
+    module.exports = sinon;
+}
+
+/**
+ * @depend fake_xml_http_request.js
+ */
+/*jslint eqeqeq: false, onevar: false, regexp: false, plusplus: false*/
+/*global module, require, window*/
+/**
+ * The Sinon "server" mimics a web server that receives requests from
+ * sinon.FakeXMLHttpRequest and provides an API to respond to those requests,
+ * both synchronously and asynchronously. To respond synchronuously, canned
+ * answers have to be provided upfront.
+ *
+ * @author Christian Johansen (christian@cjohansen.no)
+ * @license BSD
+ *
+ * Copyright (c) 2010-2011 Christian Johansen
+ */
+
+if (typeof sinon == "undefined") {
+    var sinon = {};
+}
+
+sinon.fakeServer = (function () {
+    var push = [].push;
+    function F() {}
+
+    function create(proto) {
+        F.prototype = proto;
+        return new F();
+    }
+
+    function responseArray(handler) {
+        var response = handler;
+
+        if (Object.prototype.toString.call(handler) != "[object Array]") {
+            response = [200, {}, handler];
+        }
+
+        if (typeof response[2] != "string") {
+            throw new TypeError("Fake server response body should be string, but was " +
+                                typeof response[2]);
+        }
+
+        return response;
+    }
+
+    var wloc = window.location;
+    var rCurrLoc = new RegExp("^" + wloc.protocol + "//" + wloc.host);
+
+    function matchOne(response, reqMethod, reqUrl) {
+        var rmeth = response.method;
+        var matchMethod = !rmeth || rmeth.toLowerCase() == reqMethod.toLowerCase();
+        var url = response.url;
+        var matchUrl = !url || url == reqUrl || (typeof url.test == "function" && url.test(reqUrl));
+
+        return matchMethod && matchUrl;
+    }
+
+    function match(response, request) {
+        var requestMethod = this.getHTTPMethod(request);
+        var requestUrl = request.url;
+
+        if (!/^https?:\/\//.test(requestUrl) || rCurrLoc.test(requestUrl)) {
+            requestUrl = requestUrl.replace(rCurrLoc, "");
+        }
+
+        if (matchOne(response, this.getHTTPMethod(request), requestUrl)) {
+            if (typeof response.response == "function") {
+                var ru = response.url;
+                var args = [request].concat(!ru ? [] : requestUrl.match(ru).slice(1));
+                return response.response.apply(response, args);
+            }
+
+            return true;
+        }
+
+        return false;
+    }
+
+    return {
+        create: function () {
+            var server = create(this);
+            this.xhr = sinon.useFakeXMLHttpRequest();
+            server.requests = [];
+
+            this.xhr.onCreate = function (xhrObj) {
+                server.addRequest(xhrObj);
+            };
+
+            return server;
+        },
+
+        addRequest: function addRequest(xhrObj) {
+            var server = this;
+            push.call(this.requests, xhrObj);
+
+            xhrObj.onSend = function () {
+                server.handleRequest(this);
+            };
+
+            if (this.autoRespond && !this.responding) {
+                setTimeout(function () {
+                    server.responding = false;
+                    server.respond();
+                }, this.autoRespondAfter || 10);
+
+                this.responding = true;
+            }
+        },
+
+        getHTTPMethod: function getHTTPMethod(request) {
+            if (this.fakeHTTPMethods && /post/i.test(request.method)) {
+                var matches = (request.requestBody || "").match(/_method=([^\b;]+)/);
+                return !!matches ? matches[1] : request.method;
+            }
+
+            return request.method;
+        },
+
+        handleRequest: function handleRequest(xhr) {
+            if (xhr.async) {
+                if (!this.queue) {
+                    this.queue = [];
+                }
+
+                push.call(this.queue, xhr);
+            } else {
+                this.processRequest(xhr);
+            }
+        },
+
+        respondWith: function respondWith(method, url, body) {
+            if (arguments.length == 1 && typeof method != "function") {
+                this.response = responseArray(method);
+                return;
+            }
+
+            if (!this.responses) { this.responses = []; }
+
+            if (arguments.length == 1) {
+                body = method;
+                url = method = null;
+            }
+
+            if (arguments.length == 2) {
+                body = url;
+                url = method;
+                method = null;
+            }
+
+            push.call(this.responses, {
+                method: method,
+                url: url,
+                response: typeof body == "function" ? body : responseArray(body)
+            });
+        },
+
+        respond: function respond() {
+            if (arguments.length > 0) this.respondWith.apply(this, arguments);
+            var queue = this.queue || [];
+            var request;
+
+            while(request = queue.shift()) {
+                this.processRequest(request);
+            }
+        },
+
+        processRequest: function processRequest(request) {
+            try {
+                if (request.aborted) {
+                    return;
+                }
+
+                var response = this.response || [404, {}, ""];
+
+                if (this.responses) {
+                    for (var i = 0, l = this.responses.length; i < l; i++) {
+                        if (match.call(this, this.responses[i], request)) {
+                            response = this.responses[i].response;
+                            break;
+                        }
+                    }
+                }
+
+                if (request.readyState != 4) {
+                    request.respond(response[0], response[1], response[2]);
+                }
+            } catch (e) {
+                sinon.logError("Fake server request processing", e);
+            }
+        },
+
+        restore: function restore() {
+            return this.xhr.restore && this.xhr.restore.apply(this.xhr, arguments);
+        }
+    };
+}());
+
+if (typeof module == "object" && typeof require == "function") {
+    module.exports = sinon;
+}
+
+/**
+ * @depend fake_server.js
+ * @depend fake_timers.js
+ */
+/*jslint browser: true, eqeqeq: false, onevar: false*/
+/*global sinon*/
+/**
+ * Add-on for sinon.fakeServer that automatically handles a fake timer along with
+ * the FakeXMLHttpRequest. The direct inspiration for this add-on is jQuery
+ * 1.3.x, which does not use xhr object's onreadystatehandler at all - instead,
+ * it polls the object for completion with setInterval. Dispite the direct
+ * motivation, there is nothing jQuery-specific in this file, so it can be used
+ * in any environment where the ajax implementation depends on setInterval or
+ * setTimeout.
+ *
+ * @author Christian Johansen (christian@cjohansen.no)
+ * @license BSD
+ *
+ * Copyright (c) 2010-2011 Christian Johansen
+ */
+
+(function () {
+    function Server() {}
+    Server.prototype = sinon.fakeServer;
+
+    sinon.fakeServerWithClock = new Server();
+
+    sinon.fakeServerWithClock.addRequest = function addRequest(xhr) {
+        if (xhr.async) {
+            if (typeof setTimeout.clock == "object") {
+                this.clock = setTimeout.clock;
+            } else {
+                this.clock = sinon.useFakeTimers();
+                this.resetClock = true;
+            }
+
+            if (!this.longestTimeout) {
+                var clockSetTimeout = this.clock.setTimeout;
+                var clockSetInterval = this.clock.setInterval;
+                var server = this;
+
+                this.clock.setTimeout = function (fn, timeout) {
+                    server.longestTimeout = Math.max(timeout, server.longestTimeout || 0);
+
+                    return clockSetTimeout.apply(this, arguments);
+                };
+
+                this.clock.setInterval = function (fn, timeout) {
+                    server.longestTimeout = Math.max(timeout, server.longestTimeout || 0);
+
+                    return clockSetInterval.apply(this, arguments);
+                };
+            }
+        }
+
+        return sinon.fakeServer.addRequest.call(this, xhr);
+    };
+
+    sinon.fakeServerWithClock.respond = function respond() {
+        var returnVal = sinon.fakeServer.respond.apply(this, arguments);
+
+        if (this.clock) {
+            this.clock.tick(this.longestTimeout || 0);
+            this.longestTimeout = 0;
+
+            if (this.resetClock) {
+                this.clock.restore();
+                this.resetClock = false;
+            }
+        }
+
+        return returnVal;
+    };
+
+    sinon.fakeServerWithClock.restore = function restore() {
+        if (this.clock) {
+            this.clock.restore();
+        }
+
+        return sinon.fakeServer.restore.apply(this, arguments);
+    };
+}());
+
+/**
+ * @depend ../sinon.js
+ * @depend collection.js
+ * @depend util/fake_timers.js
+ * @depend util/fake_server_with_clock.js
+ */
+/*jslint eqeqeq: false, onevar: false, plusplus: false*/
+/*global require, module*/
+/**
+ * Manages fake collections as well as fake utilities such as Sinon's
+ * timers and fake XHR implementation in one convenient object.
+ *
+ * @author Christian Johansen (christian@cjohansen.no)
+ * @license BSD
+ *
+ * Copyright (c) 2010-2011 Christian Johansen
+ */
+
+if (typeof module == "object" && typeof require == "function") {
+    var sinon = require("../sinon");
+    sinon.extend(sinon, require("./util/fake_timers"));
+}
+
+(function () {
+    var push = [].push;
+
+    function exposeValue(sandbox, config, key, value) {
+        if (!value) {
+            return;
+        }
+
+        if (config.injectInto) {
+            config.injectInto[key] = value;
+        } else {
+            push.call(sandbox.args, value);
+        }
+    }
+
+    function prepareSandboxFromConfig(config) {
+        var sandbox = sinon.create(sinon.sandbox);
+
+        if (config.useFakeServer) {
+            if (typeof config.useFakeServer == "object") {
+                sandbox.serverPrototype = config.useFakeServer;
+            }
+
+            sandbox.useFakeServer();
+        }
+
+        if (config.useFakeTimers) {
+            if (typeof config.useFakeTimers == "object") {
+                sandbox.useFakeTimers.apply(sandbox, config.useFakeTimers);
+            } else {
+                sandbox.useFakeTimers();
+            }
+        }
+
+        return sandbox;
+    }
+
+    sinon.sandbox = sinon.extend(sinon.create(sinon.collection), {
+        useFakeTimers: function useFakeTimers() {
+            this.clock = sinon.useFakeTimers.apply(sinon, arguments);
+
+            return this.add(this.clock);
+        },
+
+        serverPrototype: sinon.fakeServer,
+
+        useFakeServer: function useFakeServer() {
+            var proto = this.serverPrototype || sinon.fakeServer;
+
+            if (!proto || !proto.create) {
+                return null;
+            }
+
+            this.server = proto.create();
+            return this.add(this.server);
+        },
+
+        inject: function (obj) {
+            sinon.collection.inject.call(this, obj);
+
+            if (this.clock) {
+                obj.clock = this.clock;
+            }
+
+            if (this.server) {
+                obj.server = this.server;
+                obj.requests = this.server.requests;
+            }
+
+            return obj;
+        },
+
+        create: function (config) {
+            if (!config) {
+                return sinon.create(sinon.sandbox);
+            }
+
+            var sandbox = prepareSandboxFromConfig(config);
+            sandbox.args = sandbox.args || [];
+            var prop, value, exposed = sandbox.inject({});
+
+            if (config.properties) {
+                for (var i = 0, l = config.properties.length; i < l; i++) {
+                    prop = config.properties[i];
+                    value = exposed[prop] || prop == "sandbox" && sandbox;
+                    exposeValue(sandbox, config, prop, value);
+                }
+            } else {
+                exposeValue(sandbox, config, "sandbox", value);
+            }
+
+            return sandbox;
+        }
+    });
+
+    sinon.sandbox.useFakeXMLHttpRequest = sinon.sandbox.useFakeServer;
+
+    if (typeof module == "object" && typeof require == "function") {
+        module.exports = sinon.sandbox;
+    }
+}());
+
+/**
+ * @depend ../sinon.js
+ * @depend stub.js
+ * @depend mock.js
+ * @depend sandbox.js
+ */
+/*jslint eqeqeq: false, onevar: false, forin: true, plusplus: false*/
+/*global module, require, sinon*/
+/**
+ * Test function, sandboxes fakes
+ *
+ * @author Christian Johansen (christian@cjohansen.no)
+ * @license BSD
+ *
+ * Copyright (c) 2010-2011 Christian Johansen
+ */
+
+(function (sinon) {
+    var commonJSModule = typeof module == "object" && typeof require == "function";
+
+    if (!sinon && commonJSModule) {
+        sinon = require("../sinon");
+    }
+
+    if (!sinon) {
+        return;
+    }
+
+    function test(callback) {
+        var type = typeof callback;
+
+        if (type != "function") {
+            throw new TypeError("sinon.test needs to wrap a test function, got " + type);
+        }
+
+        return function () {
+            var config = sinon.getConfig(sinon.config);
+            config.injectInto = config.injectIntoThis && this || config.injectInto;
+            var sandbox = sinon.sandbox.create(config);
+            var exception, result;
+            var args = Array.prototype.slice.call(arguments).concat(sandbox.args);
+
+            try {
+                result = callback.apply(this, args);
+            } finally {
+                sandbox.verifyAndRestore();
+            }
+
+            return result;
+        };
+    }
+
+    test.config = {
+        injectIntoThis: true,
+        injectInto: null,
+        properties: ["spy", "stub", "mock", "clock", "server", "requests"],
+        useFakeTimers: true,
+        useFakeServer: true
+    };
+
+    if (commonJSModule) {
+        module.exports = test;
+    } else {
+        sinon.test = test;
+    }
+}(typeof sinon == "object" && sinon || null));
+
+/**
+ * @depend ../sinon.js
+ * @depend test.js
+ */
+/*jslint eqeqeq: false, onevar: false, eqeqeq: false*/
+/*global module, require, sinon*/
+/**
+ * Test case, sandboxes all test functions
+ *
+ * @author Christian Johansen (christian@cjohansen.no)
+ * @license BSD
+ *
+ * Copyright (c) 2010-2011 Christian Johansen
+ */
+
+(function (sinon) {
+    var commonJSModule = typeof module == "object" && typeof require == "function";
+
+    if (!sinon && commonJSModule) {
+        sinon = require("../sinon");
+    }
+
+    if (!sinon || !Object.prototype.hasOwnProperty) {
+        return;
+    }
+
+    function createTest(property, setUp, tearDown) {
+        return function () {
+            if (setUp) {
+                setUp.apply(this, arguments);
+            }
+
+            var exception, result;
+
+            try {
+                result = property.apply(this, arguments);
+            } catch (e) {
+                exception = e;
+            }
+
+            if (tearDown) {
+                tearDown.apply(this, arguments);
+            }
+
+            if (exception) {
+                throw exception;
+            }
+
+            return result;
+        };
+    }
+
+    function testCase(tests, prefix) {
+        /*jsl:ignore*/
+        if (!tests || typeof tests != "object") {
+            throw new TypeError("sinon.testCase needs an object with test functions");
+        }
+        /*jsl:end*/
+
+        prefix = prefix || "test";
+        var rPrefix = new RegExp("^" + prefix);
+        var methods = {}, testName, property, method;
+        var setUp = tests.setUp;
+        var tearDown = tests.tearDown;
+
+        for (testName in tests) {
+            if (tests.hasOwnProperty(testName)) {
+                property = tests[testName];
+
+                if (/^(setUp|tearDown)$/.test(testName)) {
+                    continue;
+                }
+
+                if (typeof property == "function" && rPrefix.test(testName)) {
+                    method = property;
+
+                    if (setUp || tearDown) {
+                        method = createTest(property, setUp, tearDown);
+                    }
+
+                    methods[testName] = sinon.test(method);
+                } else {
+                    methods[testName] = tests[testName];
+                }
+            }
+        }
+
+        return methods;
+    }
+
+    if (commonJSModule) {
+        module.exports = testCase;
+    } else {
+        sinon.testCase = testCase;
+    }
+}(typeof sinon == "object" && sinon || null));
+
+/**
+ * @depend ../sinon.js
+ * @depend stub.js
+ */
+/*jslint eqeqeq: false, onevar: false, nomen: false, plusplus: false*/
+/*global module, require, sinon*/
+/**
+ * Assertions matching the test spy retrieval interface.
+ *
+ * @author Christian Johansen (christian@cjohansen.no)
+ * @license BSD
+ *
+ * Copyright (c) 2010-2011 Christian Johansen
+ */
+
+(function (sinon, global) {
+    var commonJSModule = typeof module == "object" && typeof require == "function";
+    var slice = Array.prototype.slice;
+    var assert;
+
+    if (!sinon && commonJSModule) {
+        sinon = require("../sinon");
+    }
+
+    if (!sinon) {
+        return;
+    }
+
+    function verifyIsStub() {
+        var method;
+
+        for (var i = 0, l = arguments.length; i < l; ++i) {
+            method = arguments[i];
+
+            if (!method) {
+                assert.fail("fake is not a spy");
+            }
+
+            if (typeof method != "function") {
+                assert.fail(method + " is not a function");
+            }
+
+            if (typeof method.getCall != "function") {
+                assert.fail(method + " is not stubbed");
+            }
+        }
+    }
+
+    function failAssertion(object, msg) {
+        object = object || global;
+        var failMethod = object.fail || assert.fail;
+        failMethod.call(object, msg);
+    }
+
+    function mirrorPropAsAssertion(name, method, message) {
+        if (arguments.length == 2) {
+            message = method;
+            method = name;
+        }
+
+        assert[name] = function (fake) {
+            verifyIsStub(fake);
+
+            var args = slice.call(arguments, 1);
+            var failed = false;
+
+            if (typeof method == "function") {
+                failed = !method(fake);
+            } else {
+                failed = typeof fake[method] == "function" ?
+                    !fake[method].apply(fake, args) : !fake[method];
+            }
+
+            if (failed) {
+                failAssertion(this, fake.printf.apply(fake, [message].concat(args)));
+            } else {
+                assert.pass(name);
+            }
+        };
+    }
+
+    function exposedName(prefix, prop) {
+        return !prefix || /^fail/.test(prop) ? prop :
+            prefix + prop.slice(0, 1).toUpperCase() + prop.slice(1);
+    };
+
+    assert = {
+        failException: "AssertError",
+
+        fail: function fail(message) {
+            var error = new Error(message);
+            error.name = this.failException || assert.failException;
+
+            throw error;
+        },
+
+        pass: function pass(assertion) {},
+
+        callOrder: function assertCallOrder() {
+            verifyIsStub.apply(null, arguments);
+            var expected = "", actual = "";
+
+            if (!sinon.calledInOrder(arguments)) {
+                try {
+                    expected = [].join.call(arguments, ", ");
+                    actual = sinon.orderByFirstCall(slice.call(arguments)).join(", ");
+                } catch (e) {
+                    // If this fails, we'll just fall back to the blank string
+                }
+
+                failAssertion(this, "expected " + expected + " to be " +
+                              "called in order but were called as " + actual);
+            } else {
+                assert.pass("callOrder");
+            }
+        },
+
+        callCount: function assertCallCount(method, count) {
+            verifyIsStub(method);
+
+            if (method.callCount != count) {
+                var msg = "expected %n to be called " + sinon.timesInWords(count) +
+                    " but was called %c%C";
+                failAssertion(this, method.printf(msg));
+            } else {
+                assert.pass("callCount");
+            }
+        },
+
+        expose: function expose(target, options) {
+            if (!target) {
+                throw new TypeError("target is null or undefined");
+            }
+
+            var o = options || {};
+            var prefix = typeof o.prefix == "undefined" && "assert" || o.prefix;
+            var includeFail = typeof o.includeFail == "undefined" || !!o.includeFail;
+
+            for (var method in this) {
+                if (method != "export" && (includeFail || !/^(fail)/.test(method))) {
+                    target[exposedName(prefix, method)] = this[method];
+                }
+            }
+
+            return target;
+        }
+    };
+
+    mirrorPropAsAssertion("called", "expected %n to have been called at least once but was never called");
+    mirrorPropAsAssertion("notCalled", function (spy) { return !spy.called; },
+                          "expected %n to not have been called but was called %c%C");
+    mirrorPropAsAssertion("calledOnce", "expected %n to be called once but was called %c%C");
+    mirrorPropAsAssertion("calledTwice", "expected %n to be called twice but was called %c%C");
+    mirrorPropAsAssertion("calledThrice", "expected %n to be called thrice but was called %c%C");
+    mirrorPropAsAssertion("calledOn", "expected %n to be called with %1 as this but was called with %t");
+    mirrorPropAsAssertion("alwaysCalledOn", "expected %n to always be called with %1 as this but was called with %t");
+    mirrorPropAsAssertion("calledWith", "expected %n to be called with arguments %*%C");
+    mirrorPropAsAssertion("alwaysCalledWith", "expected %n to always be called with arguments %*%C");
+    mirrorPropAsAssertion("calledWithExactly", "expected %n to be called with exact arguments %*%C");
+    mirrorPropAsAssertion("alwaysCalledWithExactly", "expected %n to always be called with exact arguments %*%C");
+    mirrorPropAsAssertion("neverCalledWith", "expected %n to never be called with arguments %*%C");
+    mirrorPropAsAssertion("threw", "%n did not throw exception%C");
+    mirrorPropAsAssertion("alwaysThrew", "%n did not always throw exception%C");
+
+    if (commonJSModule) {
+        module.exports = assert;
+    } else {
+        sinon.assert = assert;
+    }
+}(typeof sinon == "object" && sinon || null, typeof window != "undefined" ? window : global));
+
+return sinon;}.call(typeof window != 'undefined' && window || {}));
diff --git a/public/index.html b/public/index.html
index 1e136ac5..3b97f729 100644
--- a/public/index.html
+++ b/public/index.html
@@ -9,6 +9,7 @@
     <script src="javascripts/application.js"></script>
     <script>
       minispade.require('app')
+      Travis.initialize()
     </script>
   </head>
   <body>
diff --git a/public/javascripts/application.js b/public/javascripts/application.js
index 5b25a949..e94c6a90 100644
--- a/public/javascripts/application.js
+++ b/public/javascripts/application.js
@@ -1 +1 @@
-minispade.register('templates', "(function() {Ember.TEMPLATES['application']=Ember.Handlebars.compile(\"<div id=\\\"head\\\">\\n  <a href=\\\"/\\\">Travis CI</a>\\n  <a href=\\\"#\\\">#</a>\\n</div>\\n\\n<div id=\\\"left\\\">\\n  {{outlet left}}\\n</div>\\n\\n<div id=\\\"main\\\">\\n  {{outlet main}}\\n</div>\\n\");Ember.TEMPLATES['builds/list']=Ember.Handlebars.compile(\"<table id=\\\"builds\\\">\\n  <thead>\\n    <tr>\\n      <th>{{t builds.name}}</th>\\n      <th>{{t builds.commit}}</th>\\n      <th>{{t builds.message}}</th>\\n      <th>{{t builds.duration}}</th>\\n      <th>{{t builds.finished_at}}</th>\\n    </tr>\\n  </thead>\\n\\n  <tbody>\\n    {{#each build in content}}\\n      {{#view Travis.BuildsItemView contextBinding=\\\"build\\\"}}\\n        <tr>\\n          <td class=\\\"number\\\"><a {{action viewBuild href=true}}>{{number}}</a></td>\\n          <td class=\\\"commit\\\"><a {{bindAttr href=\\\"urlGithubCommit\\\"}}>{{formatCommit commit}}</a></td>\\n          <td class=\\\"message\\\">{{{formatMessage commit.message short=\\\"true\\\"}}}</td>\\n          <td class=\\\"duration\\\" {{bindAttr title=\\\"started_at\\\"}}>{{formatDuration duration}}</td>\\n          <td class=\\\"finished_at timeago\\\" {{bindAttr title=\\\"finished_at\\\"}}>{{formatTime finished_at}}</td>\\n        </tr>\\n      {{/view}}\\n    {{/each}}\\n  </tbody>\\n</table>\\n\\n<p>\\n  <button {{action showMore on=\\\"click\\\" target=\\\"builds\\\" isVisibleBinding=\\\"hasMore\\\"}}>\\n    {{t builds.show_more}}\\n  </button>\\n</p>\\n\");Ember.TEMPLATES['builds/show']=Ember.Handlebars.compile(\"<div {{bindAttr class=\\\"classes\\\"}}>\\n  <dl class=\\\"summary clearfix\\\">\\n    <div class=\\\"left\\\">\\n      <dt>{{t builds.name}}</dt>\\n      <dd class=\\\"number\\\"><a {{action viewBuild href=true}}>{{number}}</a></dd>\\n      <dt class=\\\"finished_at_label\\\">{{t builds.finished_at}}</dt>\\n      <dd class=\\\"finished_at timeago\\\" {{bindAttr title=\\\"finished_at\\\"}}>{{formatTime finished_at}}</dd>\\n      <dt>{{t builds.duration}}</dt>\\n      <dd class=\\\"duration\\\" {{bindAttr title=\\\"started_at\\\"}}>{{formatDuration duration}}</dd>\\n    </div>\\n\\n    <div class=\\\"right\\\">\\n      <dt>{{t builds.commit}}</dt>\\n      <dd class=\\\"commit-hash\\\"><a {{bindAttr href=\\\"urlGithubCommit\\\"}}>{{formatCommit commit}}</a></dd>\\n      {{#if commit.compareUrl}}\\n        <dt>{{t builds.compare}}</dt>\\n        <dd class=\\\"compare_view\\\"><a {{bindAttr href=\\\"commit.compareUrl\\\"}}>{{pathFrom commit.compareUrl}}</a></dd>\\n      {{/if}}\\n      {{#if commit.authorName}}\\n        <dt>{{t builds.author}}</dt>\\n        <dd class=\\\"author\\\"><a {{bindAttr href=\\\"urlAuthor\\\"}}>{{commit.authorName}}</a></dd>\\n      {{/if}}\\n      {{#if commit.committerName}}\\n        <dt>{{t builds.committer}}</dt>\\n        <dd class=\\\"committer\\\"><a {{bindAttr href=\\\"urlCommitter\\\"}}>{{commit.committerName}}</a></dd>\\n      {{/if}}\\n    </div>\\n\\n    <dt>{{t builds.message}}</dt>\\n    <dd class=\\\"commit-message\\\">{{{formatMessage commit.message}}}</dd>\\n\\n    {{#unless isMatrix}}\\n      <dt>{{t builds.config}}</dt>\\n      <dd class=\\\"config\\\">{{formatConfig config}}</dd>\\n    {{/unless}}\\n  </dl>\\n\\n  {{#if isLoaded}}\\n    {{#if view.isMatrix}}\\n      {{view Travis.JobsView jobsBinding=\\\"view.requiredJobs\\\" required=\\\"true\\\"}}\\n      {{view Travis.JobsView jobsBinding=\\\"view.allowedFailureJobs\\\"}}\\n    {{else}}\\n      {{view Travis.LogView contextBinding=\\\"jobs.firstObject\\\"}}\\n    {{/if}}\\n  {{/if}}\\n</div>\\n\");Ember.TEMPLATES['jobs/list']=Ember.Handlebars.compile(\"{{#if view.jobs.length}}\\n  <table id=\\\"jobs\\\">\\n    <caption>\\n      {{#if view.required}}\\n        {{t jobs.build_matrix}}\\n      {{else}}\\n        {{t jobs.allowed_failures}}{{whats_this allow_failure_help}}\\n      {{/if}}\\n    </caption>\\n    <thead>\\n      <tr>\\n        {{#each configKeys}}\\n          <th>{{this}}</th>\\n        {{/each}}\\n      </tr>\\n    </thead>\\n    <tbody>\\n      {{#each view.jobs}}\\n        <tr {{bindAttr class=\\\"color\\\"}}>\\n          <td class=\\\"number\\\"><a {{action viewJob href=true}}>#{{number}}</a></td>\\n          <td class=\\\"duration\\\" {{bindAttr title=\\\"started_at\\\"}}>{{formatDuration duration}}</td>\\n          <td class=\\\"finished_at timeago\\\" {{bindAttr title=\\\"finished_at\\\"}}>{{formatTime finished_at}}</td>\\n          {{#each configValues}}\\n            <td>{{this}}</td>\\n          {{/each}}\\n        </tr>\\n      {{/each}}\\n    </tbody>\\n  </table>\\n\\n  {{#unless view.required}}\\n    <div id=\\\"allow_failure_help\\\" class=\\\"context_help\\\">\\n      <div class=\\\"context_help_caption\\\">{{t \\\"jobs.allowed_failures\\\"}}</div>\\n      <div class=\\\"context_help_body\\\">\\n        <p>\\n          Allowed Failures are items in your build matrix that are allowed to\\n          fail without causing the entire build to be shown as failed. This lets you add\\n          in experimental and preparatory builds to test against versions or\\n          configurations that you are not ready to officially support.\\n        </p>\\n        <p>\\n          You can define allowed failures in the build matrix as follows:\\n        </p>\\n        <pre>\\n      matrix:\\n        allow_failures:\\n          - rvm: ruby-head\\n        </pre>\\n      </div>\\n    </div>\\n  {{/unless}}\\n{{/if}}\\n\");Ember.TEMPLATES['jobs/log']=Ember.Handlebars.compile(\"<pre class=\\\"log\\\">{{{formatLog log.body}}}</pre>\\n\\n{{#if sponsor.name}}\\n  <p class=\\\"sponsor\\\">\\n  {{t builds.messages.sponsored_by}}\\n    <a {{bindAttr href=\\\"sponsor.url\\\"}}>{{sponsor.name}}</a>\\n  </p>\\n{{/if}}\\n\");Ember.TEMPLATES['jobs/show']=Ember.Handlebars.compile(\"<div {{bindAttr class=\\\"classes\\\"}}>\\n  <dl class=\\\"summary clearfix\\\">\\n    <div class=\\\"left\\\">\\n      <dt>Job</dt>\\n      <dd class=\\\"number\\\"><a {{action viewJob href=true}}>{{number}}</a></dd>\\n      <dt class=\\\"finished_at_label\\\">{{t jobs.finished_at}}</dt>\\n      <dd class=\\\"finished_at timeago\\\" {{bindAttr title=\\\"finished_at\\\"}}>{{formatTime finished_at}}</dd>\\n      <dt>{{t jobs.duration}}</dt>\\n      <dd class=\\\"duration\\\" {{bindAttr title=\\\"started_at\\\"}}>{{formatDuration duration}}</dd>\\n    </div>\\n\\n    <div class=\\\"right\\\">\\n      <dt>{{t jobs.commit}}</dt>\\n      <dd class=\\\"commit-hash\\\"><a {{bindAttr href=\\\"urlGithubCommit\\\"}}>{{formatCommit commit}}</a></dd>\\n      {{#if commit.compareUrl}}\\n        <dt>{{t jobs.compare}}</dt>\\n        <dd class=\\\"compare_view\\\"><a {{bindAttr href=\\\"commit.compareUrl\\\"}}>{{pathFrom commit.compareUrl}}</a></dd>\\n      {{/if}}\\n      {{#if commit.authorName}}\\n        <dt>{{t jobs.author}}</dt>\\n        <dd class=\\\"author\\\"><a {{bindAttr href=\\\"urlAuthor\\\"}}>{{commit.authorName}}</a></dd>\\n      {{/if}}\\n      {{#if commit.committerName}}\\n        <dt>{{t jobs.committer}}</dt>\\n        <dd class=\\\"committer\\\"><a {{bindAttr href=\\\"urlCommitter\\\"}}>{{commit.committerName}}</a></dd>\\n      {{/if}}\\n    </div>\\n\\n    <dt>{{t jobs.message}}</dt>\\n    <dd class=\\\"commit-message\\\">{{formatMessage commit.message}}</dd>\\n    <dt>{{t jobs.config}}</dt>\\n    <dd class=\\\"config\\\">{{formatConfig config}}</dd>\\n  </dl>\\n\\n  {{view Travis.LogView}}\\n</div>\\n\\n\");Ember.TEMPLATES['repositories/list']=Ember.Handlebars.compile(\"{{#if content.lastObject.isLoaded}}\\n  <ul>\\n    {{#each repository in content}}\\n      {{#view Travis.RepositoriesItemView contextBinding=\\\"repository\\\"}}\\n        <li {{bindAttr class=\\\"view.classes\\\"}}>\\n          <div class=\\\"wrapper\\\">\\n            <a {{action viewCurrent href=true}} class=\\\"slug\\\">{{slug}}</a>\\n            <a {{action viewBuild href=true context=\\\"lastBuild\\\"}} class=\\\"build\\\">#{{lastBuildNumber}}</a>\\n          </div>\\n\\n          <p class=\\\"summary\\\">\\n            <span class=\\\"duration_label\\\">{{t repositories.duration}}:</span>\\n            <abbr class=\\\"duration\\\" {{bindAttr title=\\\"lastBuildStartedAt\\\"}}>{{formatDuration lastBuildDuration}}</abbr>,\\n            <span class=\\\"finished_at_label\\\">{{t repositories.finished_at}}:</span>\\n            <abbr class=\\\"finished_at timeago\\\" {{bindAttr title=\\\"lastBuildFinishedAt\\\"}}>{{formatTime lastBuildFinished_at}}</abbr>\\n          </p>\\n          {{#if description}}\\n            <p class=\\\"description\\\">{{description}}</p>\\n          {{/if}}\\n          <span class=\\\"indicator\\\"></span>\\n        </li>\\n      {{/view}}\\n    {{/each}}\\n  <ul>\\n{{/if}}\\n\");Ember.TEMPLATES['repositories/show']=Ember.Handlebars.compile(\"<h3>\\n  <a {{bindAttr href=\\\"urlGithub\\\"}}>{{slug}}</a>\\n</h3>\\n\\n<p class=\\\"description\\\">{{description}}</p>\\n\\n<ul class=\\\"github-stats\\\">\\n  <li class=\\\"language\\\">{{last_build_language}}</li>\\n  <li><a class=\\\"watchers\\\" title=\\\"Watches\\\" {{bindAttr href=\\\"urlGithubWatchers\\\"}}>{{stats.watchers}}</a></li>\\n  <li><a class=\\\"forks\\\" title=\\\"Forks\\\" {{bindAttr href=\\\"urlGithubNetwork\\\"}}>{{stats.forks}}</a></li>\\n</ul>\\n\\n{{outlet tabs}}\\n\\n<div class=\\\"tab\\\">\\n  {{outlet tab}}\\n</div>\\n\");Ember.TEMPLATES['repositories/tabs']=Ember.Handlebars.compile(\"<ul class=\\\"tabs\\\">\\n  <li><a {{action viewCurrent href=true context=\\\"repository\\\"}} class=\\\"current\\\">Current</a></li>\\n  <li><a {{action viewBuilds href=true context=\\\"repository\\\"}} class=\\\"history\\\">History</a></li>\\n  {{#if build}}\\n    <li><a {{action viewBuild href=true context=\\\"build\\\"}} class=\\\"build\\\">Build #{{build.number}}</a></li>\\n  {{/if}}\\n  {{#if job}}\\n    <li><a {{action viewJob href=true context=\\\"job\\\"}} class=\\\"job\\\">Job #{{job.number}}</a></li>\\n  {{/if}}\\n</ul>\\n\");\n})();\n//@ sourceURL=templates");minispade.register('app', "(function() {(function() {\n\n  this.Travis = Em.Application.create();\nminispade.require('ext/jquery');\nminispade.require('locales');\nminispade.require('travis/data_store/rest_adapter');\nminispade.require('helpers');\nminispade.require('models');\nminispade.require('views');\nminispade.require('templates');\nminispade.require('controllers');\nminispade.require('routes');\n\n  Travis.store = DS.Store.extend({\n    revision: 4,\n    adapter: Travis.RestAdapter.create()\n  }).create();\n\n  Travis.initialize();\n\n}).call(this);\n\n})();\n//@ sourceURL=app");minispade.register('controllers', "(function() {(function() {\n\n  Travis.ApplicationController = Em.Controller.extend();\n\n  Travis.RepositoriesController = Em.ArrayController.extend();\n\n  Travis.RepositoryController = Em.ObjectController.extend(Travis.Urls.Repository);\n\n  Travis.TabsController = Em.Controller.extend();\n\n  Travis.HistoryController = Em.ArrayController.extend();\n\n  Travis.BuildController = Em.ObjectController.extend(Travis.Urls.Commit);\n\n  Travis.JobController = Em.ObjectController.extend(Travis.Urls.Commit);\n\n}).call(this);\n\n})();\n//@ sourceURL=controllers");minispade.register('helpers', "(function() {(function() {\nminispade.require('helpers/handlebars');\nminispade.require('helpers/helpers');\nminispade.require('helpers/urls');\n\n}).call(this);\n\n})();\n//@ sourceURL=helpers");minispade.register('helpers/handlebars', "(function() {(function() {\n  var safe;\nminispade.require('ext/ember/bound_helper');\n\n  safe = function(string) {\n    return new Handlebars.SafeString(string);\n  };\n\n  Handlebars.registerHelper('whats_this', function(id) {\n    return safe('<span title=\"What\\'s This?\" class=\"whats_this\" onclick=\"$.facebox({ div: \\'#' + id + '\\'})\">&nbsp;</span>');\n  });\n\n  Handlebars.registerHelper('tipsy', function(text, tip) {\n    return safe('<span class=\"tool-tip\" original-title=\"' + tip + '\">' + text + '</span>');\n  });\n\n  Handlebars.registerHelper('t', function(key) {\n    return safe(I18n.t(key));\n  });\n\n  Ember.registerBoundHelper('formatTime', function(value, options) {\n    return safe(Travis.Helpers.timeAgoInWords(value) || '-');\n  });\n\n  Ember.registerBoundHelper('formatDuration', function(duration, options) {\n    return safe(Travis.Helpers.timeInWords(duration));\n  });\n\n  Ember.registerBoundHelper('formatCommit', function(commit, options) {\n    if (commit) {\n      return safe(Travis.Helpers.formatCommit(commit.get('sha'), commit.get('branch')));\n    }\n  });\n\n  Ember.registerBoundHelper('formatSha', function(sha, options) {\n    return safe(Travis.Helpers.formatSha(sha));\n  });\n\n  Ember.registerBoundHelper('pathFrom', function(url, options) {\n    return safe(Travis.Helpers.pathFrom(url));\n  });\n\n  Ember.registerBoundHelper('formatMessage', function(message, options) {\n    return safe(Travis.Helpers.formatMessage(message, options));\n  });\n\n  Ember.registerBoundHelper('formatConfig', function(config, options) {\n    return safe(Travis.Helpers.formatConfig(config));\n  });\n\n  Ember.registerBoundHelper('formatLog', function(log, options) {\n    return Travis.Helpers.formatLog(log) || '';\n  });\n\n}).call(this);\n\n})();\n//@ sourceURL=helpers/handlebars");minispade.register('helpers/helpers', "(function() {(function() {\nminispade.require('travis/log');\n\n  this.Travis.Helpers = {\n    safe: function(string) {\n      return new Handlebars.SafeString(string);\n    },\n    colorForResult: function(result) {\n      if (result === 0) {\n        return 'green';\n      } else {\n        if (result === 1) {\n          return 'red';\n        } else {\n          return null;\n        }\n      }\n    },\n    formatCommit: function(sha, branch) {\n      return Travis.Helpers.formatSha(sha) + (branch ? \" (\" + branch + \")\" : '');\n    },\n    formatSha: function(sha) {\n      return (sha || '').substr(0, 7);\n    },\n    formatConfig: function(config) {\n      var values;\n      config = $.only(config, 'rvm', 'gemfile', 'env', 'otp_release', 'php', 'node_js', 'scala', 'jdk', 'python', 'perl');\n      values = $.map(config, function(value, key) {\n        value = (value && value.join ? value.join(', ') : value) || '';\n        return '%@: %@'.fmt($.camelize(key), value);\n      });\n      if (values.length === 0) {\n        return '-';\n      } else {\n        return values.join(', ');\n      }\n    },\n    formatMessage: function(message, options) {\n      message = message || '';\n      if (options.short) {\n        message = message.split(/\\n/)[0];\n      }\n      return this._emojize(this._escape(message)).replace(/\\n/g, '<br/>');\n    },\n    formatLog: function(log) {\n      return Travis.Log.filter(log);\n    },\n    pathFrom: function(url) {\n      return (url || '').split('/').pop();\n    },\n    timeAgoInWords: function(date) {\n      return $.timeago.distanceInWords(date);\n    },\n    durationFrom: function(started, finished) {\n      started = started && this._toUtc(new Date(this._normalizeDateString(started)));\n      finished = finished ? this._toUtc(new Date(this._normalizeDateString(finished))) : this._nowUtc();\n      if (started && finished) {\n        return Math.round((finished - started) / 1000);\n      } else {\n        return 0;\n      }\n    },\n    timeInWords: function(duration) {\n      var days, hours, minutes, result, seconds;\n      days = Math.floor(duration / 86400);\n      hours = Math.floor(duration % 86400 / 3600);\n      minutes = Math.floor(duration % 3600 / 60);\n      seconds = duration % 60;\n      if (days > 0) {\n        return 'more than 24 hrs';\n      } else {\n        result = [];\n        if (hours === 1) {\n          result.push(hours + ' hr');\n        }\n        if (hours > 1) {\n          result.push(hours + ' hrs');\n        }\n        if (minutes > 0) {\n          result.push(minutes + ' min');\n        }\n        if (seconds > 0) {\n          result.push(seconds + ' sec');\n        }\n        if (result.length > 0) {\n          return result.join(' ');\n        } else {\n          return '-';\n        }\n      }\n    },\n    _normalizeDateString: function(string) {\n      if (window.JHW) {\n        string = string.replace('T', ' ').replace(/-/g, '/');\n        string = string.replace('Z', '').replace(/\\..*$/, '');\n      }\n      return string;\n    },\n    _nowUtc: function() {\n      return this._toUtc(new Date());\n    },\n    _toUtc: function(date) {\n      return Date.UTC(date.getFullYear(), date.getMonth(), date.getDate(), date.getHours(), date.getMinutes(), date.getSeconds(), date.getMilliseconds());\n    },\n    _emojize: function(text) {\n      var emojis;\n      emojis = text.match(/:\\S+?:/g);\n      if (emojis !== null) {\n        $.each(emojis.uniq(), function(ix, emoji) {\n          var image, strippedEmoji;\n          strippedEmoji = emoji.substring(1, emoji.length - 1);\n          if (EmojiDictionary.indexOf(strippedEmoji) !== -1) {\n            image = '<img class=\\'emoji\\' title=\\'' + emoji + '\\' alt=\\'' + emoji + '\\' src=\\'' + Travis.assets.host + '/' + Travis.assets.version + '/images/emoji/' + strippedEmoji + '.png\\'/>';\n            return text = text.replace(new RegExp(emoji, 'g'), image);\n          }\n        });\n      }\n      return text;\n    },\n    _escape: function(text) {\n      return text.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');\n    }\n  };\n\n}).call(this);\n\n})();\n//@ sourceURL=helpers/helpers");minispade.register('helpers/urls', "(function() {(function() {\n\n  this.Travis.Urls = {\n    Repository: {\n      urlGithub: (function() {\n        return 'http://github.com/%@'.fmt(this.get('slug'));\n      }).property('slug'),\n      urlGithubWatchers: (function() {\n        return 'http://github.com/%@/watchers'.fmt(this.get('slug'));\n      }).property('slug'),\n      urlGithubNetwork: (function() {\n        return 'http://github.com/%@/network'.fmt(this.get('slug'));\n      }).property('slug'),\n      urlGithubAdmin: (function() {\n        return 'http://github.com/%@/admin/hooks#travis_minibucket'.fmt(this.get('slug'));\n      }).property('slug'),\n      statusImage: (function() {\n        return '%@.png'.fmt(this.get('slug'));\n      }).property('slug')\n    },\n    Build: {\n      githubCommit: (function() {\n        return 'http://github.com/%@/commit/%@'.fmt(this.getPath('repository.slug'), this.getPath('commit.sha'));\n      }).property('repository.slug', 'commit.sha')\n    },\n    Commit: {\n      urlAuthor: (function() {\n        return 'mailto:%@'.fmt(this.getPath('commit.authorEmail'));\n      }).property(),\n      urlCommitter: (function() {\n        return 'mailto:%@'.fmt(this.getPath('commit.committerEmail'));\n      }).property()\n    }\n  };\n\n}).call(this);\n\n})();\n//@ sourceURL=helpers/urls");minispade.register('models', "(function() {(function() {\nminispade.require('models/build');\nminispade.require('models/repository');\nminispade.require('models/commit');\nminispade.require('models/job');\nminispade.require('models/artifact');\n\n}).call(this);\n\n})();\n//@ sourceURL=models");minispade.register('models/artifact', "(function() {(function() {\nminispade.require('travis/model');\n\n  this.Travis.Artifact = Travis.Model.extend({\n    body: DS.attr('string')\n  });\n\n}).call(this);\n\n})();\n//@ sourceURL=models/artifact");minispade.register('models/branch', "(function() {(function() {\nminispade.require('travis/model');\n\n  this.Travis.Branch = Travis.Model.extend(Travis.Helpers, {\n    repository_id: DS.attr('number'),\n    number: DS.attr('number'),\n    branch: DS.attr('string'),\n    message: DS.attr('string'),\n    result: DS.attr('number'),\n    duration: DS.attr('number'),\n    started_at: DS.attr('string'),\n    finished_at: DS.attr('string'),\n    commit: DS.belongsTo('Travis.Commit'),\n    repository: (function() {\n      if (this.get('repository_id')) {\n        return Travis.Repository.find(this.get('repository_id'));\n      }\n    }).property('repository_id').cacheable(),\n    tick: function() {\n      this.notifyPropertyChange('started_at');\n      return this.notifyPropertyChange('finished_at');\n    }\n  });\n\n  this.Travis.Branch.reopenClass({\n    byRepositoryId: function(id) {\n      return this.find({\n        repository_id: id\n      });\n    }\n  });\n\n}).call(this);\n\n})();\n//@ sourceURL=models/branch");minispade.register('models/build', "(function() {(function() {\nminispade.require('travis/model');\n\n  this.Travis.Build = Travis.Model.extend({\n    state: DS.attr('string'),\n    number: DS.attr('number'),\n    branch: DS.attr('string'),\n    message: DS.attr('string'),\n    result: DS.attr('number'),\n    duration: DS.attr('number'),\n    started_at: DS.attr('string'),\n    finished_at: DS.attr('string'),\n    committed_at: DS.attr('string'),\n    committer_name: DS.attr('string'),\n    committer_email: DS.attr('string'),\n    author_name: DS.attr('string'),\n    author_email: DS.attr('string'),\n    compare_url: DS.attr('string'),\n    repository: DS.belongsTo('Travis.Repository'),\n    commit: DS.belongsTo('Travis.Commit'),\n    config: (function() {\n      return this.getPath('data.config');\n    }).property('data.config'),\n    jobs: (function() {\n      return Travis.Job.findMany(this.getPath('data.job_ids') || []);\n    }).property('data.job_ids.length'),\n    configKeys: (function() {\n      var config, headers, keys;\n      config = this.get('config');\n      if (!config) {\n        return [];\n      }\n      keys = $.keys($.only(config, 'rvm', 'gemfile', 'env', 'otp_release', 'php', 'node_js', 'perl', 'python', 'scala'));\n      headers = [I18n.t('build.job'), I18n.t('build.duration'), I18n.t('build.finished_at')];\n      return $.map(headers.concat(keys), function(key) {\n        return $.camelize(key);\n      });\n    }).property('config'),\n    tick: function() {\n      this.notifyPropertyChange('duration');\n      return this.notifyPropertyChange('finished_at');\n    }\n  });\n\n  this.Travis.Build.reopenClass({\n    byRepositoryId: function(id, parameters) {\n      return this.find($.extend(parameters || {}, {\n        repository_id: id,\n        orderBy: 'number DESC'\n      }));\n    },\n    olderThanNumber: function(id, build_number) {\n      return this.find({\n        url: '/repositories/' + id + '/builds.json?bare=true&after_number=' + build_number,\n        repository_id: id,\n        orderBy: 'number DESC'\n      });\n    }\n  });\n\n}).call(this);\n\n})();\n//@ sourceURL=models/build");minispade.register('models/commit', "(function() {(function() {\nminispade.require('travis/model');\n\n  this.Travis.Commit = Travis.Model.extend({\n    sha: DS.attr('string'),\n    branch: DS.attr('string'),\n    message: DS.attr('string'),\n    compareUrl: DS.attr('string'),\n    authorName: DS.attr('string'),\n    authorEmail: DS.attr('string'),\n    committerName: DS.attr('string'),\n    committerEmail: DS.attr('string'),\n    build: DS.belongsTo('Travis.Build')\n  });\n\n}).call(this);\n\n})();\n//@ sourceURL=models/commit");minispade.register('models/job', "(function() {(function() {\nminispade.require('travis/model');\n\n  this.Travis.Job = Travis.Model.extend({\n    repository_id: DS.attr('number'),\n    build_id: DS.attr('number'),\n    log_id: DS.attr('number'),\n    queue: DS.attr('string'),\n    state: DS.attr('string'),\n    number: DS.attr('string'),\n    result: DS.attr('number'),\n    duration: DS.attr('number'),\n    started_at: DS.attr('string'),\n    finished_at: DS.attr('string'),\n    allow_failure: DS.attr('boolean'),\n    repository: DS.belongsTo('Travis.Repository'),\n    commit: DS.belongsTo('Travis.Commit'),\n    build: DS.belongsTo('Travis.Build'),\n    log: DS.belongsTo('Travis.Artifact'),\n    config: (function() {\n      return this.getPath('data.config');\n    }).property('data.config'),\n    sponsor: (function() {\n      return this.getPath('data.sponsor');\n    }).property('data.sponsor'),\n    configValues: (function() {\n      var config;\n      config = this.get('config');\n      if (!config) {\n        return [];\n      }\n      return $.values($.only(config, 'rvm', 'gemfile', 'env', 'otp_release', 'php', 'node_js', 'scala', 'jdk', 'python', 'perl'));\n    }).property('config'),\n    appendLog: function(log) {\n      return this.set('log', this.get('log') + log);\n    },\n    subscribe: function() {\n      return Travis.app.subscribe('job-' + this.get('id'));\n    },\n    onStateChange: (function() {\n      if (this.get('state') === 'finished') {\n        return Travis.app.unsubscribe('job-' + this.get('id'));\n      }\n    }).observes('state'),\n    tick: function() {\n      this.notifyPropertyChange('duration');\n      return this.notifyPropertyChange('finished_at');\n    }\n  });\n\n  this.Travis.Job.reopenClass({\n    queued: function(queue) {\n      this.all();\n      return Travis.store.filter(this, function(job) {\n        return job.get('queue') === 'builds.' + queue;\n      });\n    },\n    findMany: function(ids) {\n      return Travis.store.findMany(this, ids);\n    }\n  });\n\n}).call(this);\n\n})();\n//@ sourceURL=models/job");minispade.register('models/repository', "(function() {(function() {\nminispade.require('travis/model');\n\n  this.Travis.Repository = Travis.Model.extend({\n    slug: DS.attr('string'),\n    description: DS.attr('string'),\n    lastBuildId: DS.attr('number'),\n    lastBuildNumber: DS.attr('string'),\n    lastBuildResult: DS.attr('number'),\n    lastBuildStarted_at: DS.attr('string'),\n    lastBuildFinished_at: DS.attr('string'),\n    primaryKey: 'slug',\n    lastBuild: DS.belongsTo('Travis.Build'),\n    builds: (function() {\n      return Travis.Build.byRepositoryId(this.get('id'), {\n        event_type: 'push'\n      });\n    }).property(),\n    pullRequests: (function() {\n      return Travis.Build.byRepositoryId(this.get('id'), {\n        event_type: 'pull_request'\n      });\n    }).property(),\n    owner: (function() {\n      return (this.get('slug') || this._id).split('/')[0];\n    }).property('owner', 'name'),\n    name: (function() {\n      return (this.get('slug') || this._id).split('/')[1];\n    }).property('owner', 'name'),\n    lastBuildDuration: (function() {\n      var duration;\n      duration = this.getPath('data.lastBuildDuration');\n      if (!duration) {\n        duration = Travis.Helpers.durationFrom(this.get('lastBuildStarted_at'), this.get('lastBuildFinished_at'));\n      }\n      return duration;\n    }).property('data.lastBuildDuration', 'lastBuildStartedAt', 'lastBuildFinishedAt'),\n    stats: (function() {}).property('slug'),\n    select: function() {\n      return Travis.Repository.select(self.get('id'));\n    },\n    tick: function() {\n      this.notifyPropertyChange('lastBuildDuration');\n      return this.notifyPropertyChange('lastBuildFinishedAt');\n    }\n  });\n\n  this.Travis.Repository.reopenClass({\n    recent: function() {\n      return this.find();\n    },\n    ownedBy: function(owner) {\n      return this.find({\n        owner: owner,\n        orderBy: 'name'\n      });\n    },\n    search: function(query) {\n      return this.find({\n        search: query,\n        orderBy: 'name'\n      });\n    },\n    bySlug: function(slug) {\n      var repo;\n      repo = $.detect(this.find().toArray(), function(repo) {\n        return repo.get('slug') === slug;\n      });\n      if (repo) {\n        return Ember.ArrayProxy.create({\n          content: [repo]\n        });\n      } else {\n        return this.find({\n          slug: slug\n        });\n      }\n    },\n    select: function(id) {\n      return this.find().forEach(function(repository) {\n        return repository.set('selected', repository.get('id') === id);\n      });\n    },\n    buildURL: function(slug) {\n      if (slug) {\n        return slug;\n      } else {\n        return 'repositories';\n      }\n    }\n  });\n\n}).call(this);\n\n})();\n//@ sourceURL=models/repository");minispade.register('models/service_hook', "(function() {(function() {\nminispade.require('travis/model');\n\n  this.Travis.ServiceHook = Travis.Model.extend({\n    primaryKey: 'slug',\n    name: DS.attr('string'),\n    owner_name: DS.attr('string'),\n    active: DS.attr('boolean'),\n    slug: (function() {\n      return [this.get('owner_name'), this.get('name')].join('/');\n    }).property(),\n    toggle: function() {\n      this.set('active', !this.get('active'));\n      return Travis.app.store.commit();\n    }\n  });\n\n  this.Travis.ServiceHook.reopenClass({\n    url: 'profile/service_hooks'\n  });\n\n}).call(this);\n\n})();\n//@ sourceURL=models/service_hook");minispade.register('models/worker', "(function() {(function() {\nminispade.require('travis/model');\n\n  this.Travis.WorkerGroup = Ember.ArrayProxy.extend({\n    init: function() {\n      return this.set('content', []);\n    },\n    host: (function() {\n      return this.getPath('firstObject.host');\n    }).property()\n  });\n\n  this.Travis.Worker = Travis.Model.extend({\n    state: DS.attr('string'),\n    name: DS.attr('string'),\n    host: DS.attr('string'),\n    lastSeenAt: DS.attr('string'),\n    isTesting: (function() {\n      return this.get('state') === 'working' && !!this.getPath('payload.config');\n    }).property('state', 'config'),\n    number: (function() {\n      return this.get('name').match(/\\d+$/)[0];\n    }).property('name'),\n    display: (function() {\n      var name, number, payload, repo, state;\n      name = this.get('name').replace('travis-', '');\n      state = this.get('state');\n      payload = this.get('payload');\n      if (state === 'working' && payload !== void 0) {\n        repo = payload.repository ? $.truncate(payload.repository.slug, 18) : void 0;\n        number = payload.build && payload.build.number ? ' #' + payload.build.number : '';\n        state = repo ? repo + number : state;\n      }\n      return name + ': ' + state;\n    }).property('state'),\n    urlJob: (function() {\n      return '#!/%@/jobs/%@'.fmt(this.getPath('payload.repository.slug'), this.getPath('payload.build.id'));\n    }).property('payload', 'state')\n  });\n\n}).call(this);\n\n})();\n//@ sourceURL=models/worker");minispade.register('routes', "(function() {(function() {\nminispade.require('hax0rs');\n\n  this.Travis.Router = Em.Router.extend({\n    enableLogging: true,\n    location: 'hash',\n    root: Em.Route.extend({\n      \"default\": Em.Route.extend({\n        route: '/',\n        viewCurrent: Ember.Route.transitionTo('repository.current'),\n        viewBuilds: Ember.Route.transitionTo('repository.builds'),\n        viewBuild: Ember.Route.transitionTo('repository.build'),\n        viewJob: Ember.Route.transitionTo('repository.job'),\n        connectOutlets: function(router) {\n          var repositories;\n          repositories = Travis.Repository.find();\n          router.set('repositories', repositories);\n          router.set('job', void 0);\n          return router.connectLeft(repositories);\n        },\n        index: Em.Route.extend({\n          route: '/',\n          connectOutlets: function(router) {\n            var repositories,\n              _this = this;\n            repositories = router.get('repositories');\n            return onceLoaded(repositories, function() {\n              var build, repository;\n              repository = repositories.get('firstObject');\n              build = Travis.Build.find(repository.get('lastBuildId'));\n              router.connectRepository(repository);\n              router.connectTabs();\n              return router.connectBuild(build);\n            });\n          }\n        }),\n        repository: Em.Route.extend({\n          route: '/:owner/:name',\n          serialize: function(router, repository) {\n            return router.serializeRepository(repository);\n          },\n          deserialize: function(router, params) {\n            return router.deserializeRepository(params);\n          },\n          connectOutlets: function(router, repository) {\n            return router.connectRepository(repository);\n          },\n          current: Em.Route.extend({\n            route: '/',\n            connectOutlets: function(router) {\n              var repository;\n              repository = router.get('repository');\n              return onceLoaded(repository, function() {\n                var build;\n                build = repository.get('lastBuild');\n                router.connectTabs();\n                return router.connectBuild(build);\n              });\n            }\n          }),\n          builds: Em.Route.extend({\n            route: '/builds',\n            connectOutlets: function(router) {\n              var repository,\n                _this = this;\n              repository = router.get('repository');\n              return onceLoaded(repository, function() {\n                router.connectTabs();\n                return router.connectBuilds(repository.get('builds'));\n              });\n            }\n          }),\n          build: Em.Route.extend({\n            route: '/builds/:build_id',\n            connectOutlets: function(router, build) {\n              if (!(build instanceof Travis.Build)) {\n                build = Travis.Build.find(build.id);\n              }\n              router.connectTabs(build);\n              return router.connectBuild(build);\n            }\n          }),\n          job: Em.Route.extend({\n            route: '/jobs/:job_id',\n            connectOutlets: function(router, job) {\n              if (!(job instanceof Travis.Job)) {\n                job = Travis.Job.find(job.id);\n              }\n              router.connectTabs(job.get('build'), job);\n              return router.connectJob(job);\n            }\n          })\n        })\n      })\n    }),\n    connectLeft: function(repositories) {\n      return this.get('applicationController').connectOutlet({\n        outletName: 'left',\n        name: 'repositories',\n        context: repositories\n      });\n    },\n    connectRepository: function(repository) {\n      this.set('repository', repository);\n      return this.get('applicationController').connectOutlet({\n        outletName: 'main',\n        name: 'repository',\n        context: repository\n      });\n    },\n    connectTabs: function(build, job) {\n      this.setPath('tabsController.repository', this.get('repository'));\n      this.setPath('tabsController.build', build);\n      this.setPath('tabsController.job', job);\n      return this.get('repositoryController').connectOutlet({\n        outletName: 'tabs',\n        name: 'tabs'\n      });\n    },\n    connectBuilds: function(builds) {\n      return this.get('repositoryController').connectOutlet({\n        outletName: 'tab',\n        name: 'history',\n        context: builds\n      });\n    },\n    connectBuild: function(build) {\n      return this.get('repositoryController').connectOutlet({\n        outletName: 'tab',\n        name: 'build',\n        context: build\n      });\n    },\n    connectJob: function(job) {\n      return this.get('repositoryController').connectOutlet({\n        outletName: 'tab',\n        name: 'job',\n        context: job\n      });\n    },\n    serializeRepository: function(object) {\n      var slug;\n      if (object instanceof DS.Model) {\n        slug = object.get('slug') || object._id;\n        return {\n          owner: slug.split('/')[0],\n          name: slug.split('/')[1]\n        };\n      } else {\n        return object;\n      }\n    },\n    deserializeRepository: function(params) {\n      return Travis.Repository.find(\"\" + params.owner + \"/\" + params.name);\n    }\n  });\n\n}).call(this);\n\n})();\n//@ sourceURL=routes");minispade.register('views', "(function() {(function() {\n\n  Travis.ApplicationView = Em.View.extend({\n    templateName: 'application'\n  });\n\n  Travis.RepositoriesView = Em.View.extend({\n    templateName: 'repositories/list'\n  });\n\n  Travis.RepositoriesItemView = Em.View.extend({\n    classes: (function() {\n      var classes, color;\n      color = Travis.Helpers.colorForResult(this.getPath('repository.lastBuildResult'));\n      classes = ['repository', color];\n      if (this.getPath('repository.selected')) {\n        classes.push('selected');\n      }\n      return classes.join(' ');\n    }).property('repository.lastBuildResult', 'repository.selected'),\n    lastBuild: (function() {\n      return {\n        owner: this.getPath('repository.owner'),\n        name: this.getPath('repository.name'),\n        id: this.getPath('repository.lastBuildId')\n      };\n    }).property('repository.owner', 'repository.name', 'repository.lastBuildId')\n  });\n\n  Travis.RepositoryView = Em.View.extend({\n    templateName: 'repositories/show'\n  });\n\n  Travis.TabsView = Em.View.extend({\n    templateName: 'repositories/tabs'\n  });\n\n  Travis.HistoryView = Em.View.extend({\n    templateName: 'builds/list'\n  });\n\n  Travis.BuildsItemView = Em.View.extend({\n    classes: (function() {\n      return Travis.Helpers.colorForResult(this.getPath('content.result'));\n    }).property('content.result')\n  });\n\n  Travis.BuildView = Em.View.extend({\n    templateName: 'builds/show',\n    classes: (function() {\n      return Travis.Helpers.colorForResult(this.get('result'));\n    }).property('result'),\n    isMatrix: (function() {\n      return this.getPath('context.data.job_ids.length') > 1;\n    }).property(),\n    requiredJobs: (function() {\n      return this.getPath('context.jobs').filter(function(job) {\n        return job.get('allow_failure') !== true;\n      });\n    }).property(),\n    allowedFailureJobs: (function() {\n      return this.getPath('context.jobs').filter(function(job) {\n        return job.get('allow_failure');\n      });\n    }).property()\n  });\n\n  Travis.JobsView = Em.View.extend({\n    templateName: 'jobs/list'\n  });\n\n  Travis.JobView = Em.View.extend({\n    templateName: 'jobs/show',\n    classes: (function() {\n      return Travis.Helpers.colorForResult(this.get('result'));\n    }).property('result')\n  });\n\n  Travis.LogView = Em.View.extend({\n    templateName: 'jobs/log'\n  });\n\n}).call(this);\n\n})();\n//@ sourceURL=views");minispade.register('emoij', "(function() {(function() {\n\n  this.EmojiDictionary = ['-1', '0', '1', '109', '2', '3', '4', '5', '6', '7', '8', '8ball', '9', 'a', 'ab', 'airplane', 'alien', 'ambulance', 'angel', 'anger', 'angry', 'apple', 'aquarius', 'aries', 'arrow_backward', 'arrow_down', 'arrow_forward', 'arrow_left', 'arrow_lower_left', 'arrow_lower_right', 'arrow_right', 'arrow_up', 'arrow_upper_left', 'arrow_upper_right', 'art', 'astonished', 'atm', 'b', 'baby', 'baby_chick', 'baby_symbol', 'balloon', 'bamboo', 'bank', 'barber', 'baseball', 'basketball', 'bath', 'bear', 'beer', 'beers', 'beginner', 'bell', 'bento', 'bike', 'bikini', 'bird', 'birthday', 'black_square', 'blue_car', 'blue_heart', 'blush', 'boar', 'boat', 'bomb', 'book', 'boot', 'bouquet', 'bow', 'bowtie', 'boy', 'bread', 'briefcase', 'broken_heart', 'bug', 'bulb', 'bullettrain_front', 'bullettrain_side', 'bus', 'busstop', 'cactus', 'cake', 'calling', 'camel', 'camera', 'cancer', 'capricorn', 'car', 'cat', 'cd', 'chart', 'checkered_flag', 'cherry_blossom', 'chicken', 'christmas_tree', 'church', 'cinema', 'city_sunrise', 'city_sunset', 'clap', 'clapper', 'clock1', 'clock10', 'clock11', 'clock12', 'clock2', 'clock3', 'clock4', 'clock5', 'clock6', 'clock7', 'clock8', 'clock9', 'closed_umbrella', 'cloud', 'clubs', 'cn', 'cocktail', 'coffee', 'cold_sweat', 'computer', 'confounded', 'congratulations', 'construction', 'construction_worker', 'convenience_store', 'cool', 'cop', 'copyright', 'couple', 'couple_with_heart', 'couplekiss', 'cow', 'crossed_flags', 'crown', 'cry', 'cupid', 'currency_exchange', 'curry', 'cyclone', 'dancer', 'dancers', 'dango', 'dart', 'dash', 'de', 'department_store', 'diamonds', 'disappointed', 'dog', 'dolls', 'dolphin', 'dress', 'dvd', 'ear', 'ear_of_rice', 'egg', 'eggplant', 'egplant', 'eight_pointed_black_star', 'eight_spoked_asterisk', 'elephant', 'email', 'es', 'european_castle', 'exclamation', 'eyes', 'factory', 'fallen_leaf', 'fast_forward', 'fax', 'fearful', 'feelsgood', 'feet', 'ferris_wheel', 'finnadie', 'fire', 'fire_engine', 'fireworks', 'fish', 'fist', 'flags', 'flushed', 'football', 'fork_and_knife', 'fountain', 'four_leaf_clover', 'fr', 'fries', 'frog', 'fuelpump', 'gb', 'gem', 'gemini', 'ghost', 'gift', 'gift_heart', 'girl', 'goberserk', 'godmode', 'golf', 'green_heart', 'grey_exclamation', 'grey_question', 'grin', 'guardsman', 'guitar', 'gun', 'haircut', 'hamburger', 'hammer', 'hamster', 'hand', 'handbag', 'hankey', 'hash', 'headphones', 'heart', 'heart_decoration', 'heart_eyes', 'heartbeat', 'heartpulse', 'hearts', 'hibiscus', 'high_heel', 'horse', 'hospital', 'hotel', 'hotsprings', 'house', 'hurtrealbad', 'icecream', 'id', 'ideograph_advantage', 'imp', 'information_desk_person', 'iphone', 'it', 'jack_o_lantern', 'japanese_castle', 'joy', 'jp', 'key', 'kimono', 'kiss', 'kissing_face', 'kissing_heart', 'koala', 'koko', 'kr', 'leaves', 'leo', 'libra', 'lips', 'lipstick', 'lock', 'loop', 'loudspeaker', 'love_hotel', 'mag', 'mahjong', 'mailbox', 'man', 'man_with_gua_pi_mao', 'man_with_turban', 'maple_leaf', 'mask', 'massage', 'mega', 'memo', 'mens', 'metal', 'metro', 'microphone', 'minidisc', 'mobile_phone_off', 'moneybag', 'monkey', 'monkey_face', 'moon', 'mortar_board', 'mount_fuji', 'mouse', 'movie_camera', 'muscle', 'musical_note', 'nail_care', 'necktie', 'new', 'no_good', 'no_smoking', 'nose', 'notes', 'o', 'o2', 'ocean', 'octocat', 'octopus', 'oden', 'office', 'ok', 'ok_hand', 'ok_woman', 'older_man', 'older_woman', 'open_hands', 'ophiuchus', 'palm_tree', 'parking', 'part_alternation_mark', 'pencil', 'penguin', 'pensive', 'persevere', 'person_with_blond_hair', 'phone', 'pig', 'pill', 'pisces', 'plus1', 'point_down', 'point_left', 'point_right', 'point_up', 'point_up_2', 'police_car', 'poop', 'post_office', 'postbox', 'pray', 'princess', 'punch', 'purple_heart', 'question', 'rabbit', 'racehorse', 'radio', 'rage', 'rage1', 'rage2', 'rage3', 'rage4', 'rainbow', 'raised_hands', 'ramen', 'red_car', 'red_circle', 'registered', 'relaxed', 'relieved', 'restroom', 'rewind', 'ribbon', 'rice', 'rice_ball', 'rice_cracker', 'rice_scene', 'ring', 'rocket', 'roller_coaster', 'rose', 'ru', 'runner', 'sa', 'sagittarius', 'sailboat', 'sake', 'sandal', 'santa', 'satellite', 'satisfied', 'saxophone', 'school', 'school_satchel', 'scissors', 'scorpius', 'scream', 'seat', 'secret', 'shaved_ice', 'sheep', 'shell', 'ship', 'shipit', 'shirt', 'shit', 'shoe', 'signal_strength', 'six_pointed_star', 'ski', 'skull', 'sleepy', 'slot_machine', 'smile', 'smiley', 'smirk', 'smoking', 'snake', 'snowman', 'sob', 'soccer', 'space_invader', 'spades', 'spaghetti', 'sparkler', 'sparkles', 'speaker', 'speedboat', 'squirrel', 'star', 'star2', 'stars', 'station', 'statue_of_liberty', 'stew', 'strawberry', 'sunflower', 'sunny', 'sunrise', 'sunrise_over_mountains', 'surfer', 'sushi', 'suspect', 'sweat', 'sweat_drops', 'swimmer', 'syringe', 'tada', 'tangerine', 'taurus', 'taxi', 'tea', 'telephone', 'tennis', 'tent', 'thumbsdown', 'thumbsup', 'ticket', 'tiger', 'tm', 'toilet', 'tokyo_tower', 'tomato', 'tongue', 'top', 'tophat', 'traffic_light', 'train', 'trident', 'trophy', 'tropical_fish', 'truck', 'trumpet', 'tshirt', 'tulip', 'tv', 'u5272', 'u55b6', 'u6307', 'u6708', 'u6709', 'u6e80', 'u7121', 'u7533', 'u7a7a', 'umbrella', 'unamused', 'underage', 'unlock', 'up', 'us', 'v', 'vhs', 'vibration_mode', 'virgo', 'vs', 'walking', 'warning', 'watermelon', 'wave', 'wc', 'wedding', 'whale', 'wheelchair', 'white_square', 'wind_chime', 'wink', 'wink2', 'wolf', 'woman', 'womans_hat', 'womens', 'x', 'yellow_heart', 'zap', 'zzz'];\n\n}).call(this);\n\n})();\n//@ sourceURL=emoij");minispade.register('ext/jquery', "(function() {(function() {\n\n  $.fn.extend({\n    outerHtml: function() {\n      return $(this).wrap('<div></div>').parent().html();\n    },\n    outerElement: function() {\n      return $($(this).outerHtml()).empty();\n    },\n    flash: function() {\n      return Utils.flash(this);\n    },\n    unflash: function() {\n      return Utils.unflash(this);\n    },\n    filterLog: function() {\n      this.deansi();\n      return this.foldLog();\n    },\n    deansi: function() {\n      return this.html(Utils.deansi(this.html()));\n    },\n    foldLog: function() {\n      return this.html(Utils.foldLog(this.html()));\n    },\n    unfoldLog: function() {\n      return this.html(Utils.unfoldLog(this.html()));\n    },\n    updateTimes: function() {\n      return Utils.updateTimes(this);\n    },\n    activateTab: function(tab) {\n      return Utils.activateTab(this, tab);\n    },\n    timeInWords: function() {\n      return $(this).each(function() {\n        return $(this).text(Utils.timeInWords(parseInt($(this).attr('title'))));\n      });\n    },\n    updateGithubStats: function(repository) {\n      return Utils.updateGithubStats(repository, $(this));\n    }\n  });\n\n  $.extend({\n    keys: function(obj) {\n      var keys;\n      keys = [];\n      $.each(obj, function(key) {\n        return keys.push(key);\n      });\n      return keys;\n    },\n    values: function(obj) {\n      var values;\n      values = [];\n      $.each(obj, function(key, value) {\n        return values.push(value);\n      });\n      return values;\n    },\n    camelize: function(string, uppercase) {\n      if (uppercase || typeof uppercase === 'undefined') {\n        string = $.capitalize(string);\n      }\n      return string.replace(/_(.)?/g, function(match, chr) {\n        if (chr) {\n          return chr.toUpperCase();\n        } else {\n          return '';\n        }\n      });\n    },\n    capitalize: function(string) {\n      return string[0].toUpperCase() + string.substring(1);\n    },\n    compact: function(array) {\n      return $.grep(array, function(value) {\n        return !!value;\n      });\n    },\n    all: function(array, callback) {\n      var args, i;\n      args = Array.prototype.slice.apply(arguments);\n      callback = args.pop();\n      array = args.pop() || this;\n      i = 0;\n      while (i < array.length) {\n        if (callback(array[i])) {\n          return false;\n        }\n        i++;\n      }\n      return true;\n    },\n    detect: function(array, callback) {\n      var args, i;\n      args = Array.prototype.slice.apply(arguments);\n      callback = args.pop();\n      array = args.pop() || this;\n      i = 0;\n      while (i < array.length) {\n        if (callback(array[i])) {\n          return array[i];\n        }\n        i++;\n      }\n    },\n    select: function(array, callback) {\n      var args, i, result;\n      args = Array.prototype.slice.apply(arguments);\n      callback = args.pop();\n      array = args.pop() || this;\n      result = [];\n      i = 0;\n      while (i < array.length) {\n        if (callback(array[i])) {\n          result.push(array[i]);\n        }\n        i++;\n      }\n      return result;\n    },\n    slice: function(object, key) {\n      var keys, result;\n      keys = Array.prototype.slice.apply(arguments);\n      object = (typeof keys[0] === 'object' ? keys.shift() : this);\n      result = {};\n      for (key in object) {\n        if (keys.indexOf(key) > -1) {\n          result[key] = object[key];\n        }\n      }\n      return result;\n    },\n    only: function(object) {\n      var key, keys, result;\n      keys = Array.prototype.slice.apply(arguments);\n      object = (typeof keys[0] === 'object' ? keys.shift() : this);\n      result = {};\n      for (key in object) {\n        if (keys.indexOf(key) !== -1) {\n          result[key] = object[key];\n        }\n      }\n      return result;\n    },\n    except: function(object) {\n      var key, keys, result;\n      keys = Array.prototype.slice.apply(arguments);\n      object = (typeof keys[0] === 'object' ? keys.shift() : this);\n      result = {};\n      for (key in object) {\n        if (keys.indexOf(key) === -1) {\n          result[key] = object[key];\n        }\n      }\n      return result;\n    },\n    map: function(elems, callback, arg) {\n      var i, isArray, key, length, ret, value;\n      value = void 0;\n      key = void 0;\n      ret = [];\n      i = 0;\n      length = elems.length;\n      isArray = elems instanceof jQuery || length !== void 0 && typeof length === 'number' && (length > 0 && elems[0] && elems[length - 1]) || length === 0 || jQuery.isArray(elems);\n      if (isArray) {\n        while (i < length) {\n          value = callback(elems[i], i, arg);\n          if (value != null) {\n            ret[ret.length] = value;\n          }\n          i++;\n        }\n      } else {\n        for (key in elems) {\n          value = callback(elems[key], key, arg);\n          if (value != null) {\n            ret[ret.length] = value;\n          }\n        }\n      }\n      return ret.concat.apply([], ret);\n    },\n    truncate: function(string, length) {\n      if (string.length > length) {\n        return string.trim().substring(0, length) + '...';\n      } else {\n        return string;\n      }\n    }\n  });\n\n}).call(this);\n\n})();\n//@ sourceURL=ext/jquery");minispade.register('hax0rs', "(function() {(function() {\n\n  window.onTrue = function(object, path, callback) {\n    var observer;\n    if (object.getPath(path)) {\n      return callback();\n    } else {\n      observer = function() {\n        object.removeObserver(path, observer);\n        return callback();\n      };\n      return object.addObserver(path, observer);\n    }\n  };\n\n  window.onceLoaded = function() {\n    var callback, object, objects, path;\n    objects = Array.prototype.slice.apply(arguments);\n    callback = objects.pop();\n    objects = ((function() {\n      var _i, _len, _results;\n      _results = [];\n      for (_i = 0, _len = objects.length; _i < _len; _i++) {\n        object = objects[_i];\n        _results.push(object || null);\n      }\n      return _results;\n    })()).compact();\n    object = objects.shift();\n    if (object) {\n      path = Ember.isArray(object) ? 'firstObject.isLoaded' : 'isLoaded';\n      return onTrue(object, path, function() {\n        if (objects.length === 0) {\n          return callback(object);\n        } else {\n          return onceLoaded.apply(objects + [callback]);\n        }\n      });\n    } else {\n      return callback(object);\n    }\n  };\n\n}).call(this);\n\n})();\n//@ sourceURL=hax0rs");minispade.register('travis/data_store/fixture_adapter', "(function() {(function() {\n\n  this.Travis.FixtureAdapter = DS.Adapter.extend({\n    find: function(store, type, id) {\n      var fixtures;\n      fixtures = type.FIXTURES;\n      Ember.assert(\"Unable to find fixtures for model type \" + type.toString(), !!fixtures);\n      if (fixtures.hasLoaded) {\n        return;\n      }\n      return setTimeout((function() {\n        store.loadMany(type, fixtures);\n        return fixtures.hasLoaded = true;\n      }), 300);\n    },\n    findMany: function() {\n      return this.find.apply(this, arguments);\n    },\n    findAll: function(store, type) {\n      var fixtures, ids;\n      fixtures = type.FIXTURES;\n      Ember.assert(\"Unable to find fixtures for model type \" + type.toString(), !!fixtures);\n      ids = fixtures.map(function(item, index, self) {\n        return item.id;\n      });\n      return store.loadMany(type, ids, fixtures);\n    },\n    findQuery: function(store, type, params, array) {\n      var fixture, fixtures, hashes, key, matches, value;\n      fixtures = type.FIXTURES;\n      Ember.assert(\"Unable to find fixtures for model type \" + type.toString(), !!fixtures);\n      hashes = (function() {\n        var _i, _len, _results;\n        _results = [];\n        for (_i = 0, _len = fixtures.length; _i < _len; _i++) {\n          fixture = fixtures[_i];\n          matches = (function() {\n            var _results1;\n            _results1 = [];\n            for (key in params) {\n              value = params[key];\n              _results1.push(key === 'orderBy' || fixture[key] === value);\n            }\n            return _results1;\n          })();\n          if (matches.reduce(function(a, b) {\n            return a && b;\n          })) {\n            _results.push(fixture);\n          } else {\n            _results.push(null);\n          }\n        }\n        return _results;\n      })();\n      return array.load(hashes.compact());\n    }\n  });\n\n}).call(this);\n\n})();\n//@ sourceURL=travis/data_store/fixture_adapter");minispade.register('travis/data_store/rest_adapter', "(function() {(function() {\n\n  this.Travis.RestAdapter = DS.RESTAdapter.extend({\n    init: function() {\n      this._super();\n      return this.set('mappings', {\n        builds: Travis.Build,\n        commits: Travis.Commit,\n        jobs: Travis.Job,\n        service_hooks: Travis.ServiceHook\n      });\n    },\n    plurals: {\n      repository: 'repositories',\n      branch: 'branches'\n    },\n    find: function(store, type, id) {\n      var url;\n      url = '/' + type.buildURL(id);\n      console.log(\"find: \" + url);\n      return this.ajax(url, 'GET', {\n        success: function(json) {\n          var root;\n          root = type.singularName();\n          this.sideload(store, type, json, root);\n          return store.load(type, json[root]);\n        },\n        accepts: {\n          json: 'application/vnd.travis-ci.2+json'\n        }\n      });\n    },\n    findMany: function(store, type, ids) {\n      var url;\n      url = '/' + type.buildURL();\n      console.log(\"findMany: \" + url);\n      return this.ajax(url, 'GET', {\n        data: {\n          ids: ids\n        },\n        success: function(json) {\n          var root;\n          root = type.pluralName();\n          this.sideload(store, type, json, root);\n          return store.loadMany(type, json[root]);\n        },\n        accepts: {\n          json: 'application/vnd.travis-ci.2+json'\n        }\n      });\n    },\n    findAll: function(store, type) {\n      var url;\n      url = '/' + type.buildURL();\n      console.log(\"findAll: \" + url);\n      return this.ajax(url, 'GET', {\n        success: function(json) {\n          var root;\n          root = type.pluralName();\n          this.sideload(store, type, json, root);\n          return store.loadMany(type, json[root]);\n        },\n        accepts: {\n          json: 'application/vnd.travis-ci.2+json'\n        }\n      });\n    },\n    findQuery: function(store, type, query, recordArray) {\n      var url;\n      url = '/' + type.buildURL();\n      console.log(\"findQuery: \" + url + \" (\" + query + \")\");\n      return this.ajax(url, 'GET', {\n        data: query,\n        success: function(json) {\n          var root;\n          root = type.pluralName();\n          this.sideload(store, type, json, root);\n          return recordArray.load(json[root]);\n        },\n        accepts: {\n          json: 'application/vnd.travis-ci.2+json'\n        }\n      });\n    },\n    updateRecord: function(store, type, record) {\n      var data, id, url;\n      id = get(record, record.get('primaryKey') || 'id');\n      url = '/' + type.buildURL(id);\n      data = {\n        root: record.toJSON()\n      };\n      return this.ajax(url, 'PUT', {\n        data: data,\n        success: function(json) {\n          var root;\n          root = type.singularName();\n          this.sideload(store, type, json, root);\n          return store.didUpdateRecord(record, json && json[root]);\n        }\n      });\n    }\n  });\n\n}).call(this);\n\n})();\n//@ sourceURL=travis/data_store/rest_adapter");minispade.register('travis/log', "(function() {(function() {\n\n  this.Travis.Log = {\n    FOLDS: {\n      schema: /(<p.*?\\/a>\\$ (?:bundle exec )?rake( db:create)? db:schema:load[\\s\\S]*?<p.*?\\/a>-- assume_migrated_upto_version[\\s\\S]*?<\\/p>\\n<p.*?\\/a>.*<\\/p>)/g,\n      migrate: /(<p.*?\\/a>\\$ (?:bundle exec )?rake( db:create)? db:migrate[\\s\\S]*== +\\w+: migrated \\(.*\\) =+)/g,\n      bundle: /(<p.*?\\/a>\\$ bundle install.*<\\/p>\\n(<p.*?\\/a>(Updating|Using|Installing|Fetching|remote:|Receiving|Resolving).*?<\\/p>\\n|<p.*?\\/a><\\/p>\\n)*)/g,\n      exec: /(<p.*?\\/a>[\\/\\w]*.rvm\\/rubies\\/[\\S]*?\\/(ruby|rbx|jruby) .*?<\\/p>)/g\n    },\n    filter: function(log) {\n      log = this.escape(log);\n      log = this.deansi(log);\n      log = log.replace(/\\r/g, '');\n      log = this.number(log);\n      log = this.fold(log);\n      log = log.replace(/\\n/g, '');\n      return log;\n    },\n    stripPaths: function(log) {\n      return log.replace(/\\/home\\/vagrant\\/builds(\\/[^\\/\\n]+){2}\\//g, '');\n    },\n    escape: function(log) {\n      return Handlebars.Utils.escapeExpression(log);\n    },\n    escapeRuby: function(log) {\n      return log.replace(/#<(\\w+.*?)>/, '#&lt;$1&gt;');\n    },\n    number: function(log) {\n      var result;\n      result = '';\n      $.each(log.trim().split('\\n'), function(ix, line) {\n        var number, path;\n        number = ix + 1;\n        path = Travis.Log.location().substr(1).replace(/\\/L\\d+/, '') + '/L' + number;\n        return result += '<p><a href=\\'#%@\\' id=\\'%@\\' name=\\'L%@\\'>%@</a>%@</p>\\n'.fmt(path, path, number, number, line);\n      });\n      return result.trim();\n    },\n    deansi: function(log) {\n      var ansi, text;\n      log = log.replace(/\\r\\r/g, '\\r').replace(/\\033\\[K\\r/g, '\\r').replace(/^.*\\r(?!$)/g, '').replace(/\u001b\\[2K/g, '').replace(/\\033\\(B/g, '');\n      ansi = ansiparse(log);\n      text = '';\n      ansi.forEach(function(part) {\n        var classes;\n        classes = [];\n        part.foreground && classes.push(part.foreground);\n        part.background && classes.push('bg-' + part.background);\n        part.bold && classes.push('bold');\n        part.italic && classes.push('italic');\n        return text += (classes.length ? '<span class=\\'' + classes.join(' ') + '\\'>' + part.text + '</span>' : part.text);\n      });\n      return text.replace(/\\033/g, '');\n    },\n    fold: function(log) {\n      log = this.unfold(log);\n      $.each(Travis.Log.FOLDS, function(name, pattern) {\n        return log = log.replace(pattern, function() {\n          return '<div class=\\'fold ' + name + '\\'>' + arguments[1].trim() + '</div>';\n        });\n      });\n      return log;\n    },\n    unfold: function(log) {\n      return log.replace(/<div class='fold[^']*'>([\\s\\S]*?)<\\/div>/g, '$1\\n');\n    },\n    location: function() {\n      return window.location.hash;\n    }\n  };\n\n}).call(this);\n\n})();\n//@ sourceURL=travis/log");minispade.register('travis/model', "(function() {(function() {\n\n  this.Travis.Model = DS.Model.extend({\n    primaryKey: 'id',\n    id: DS.attr('number'),\n    refresh: function() {\n      var id;\n      id = this.get('id');\n      if (id) {\n        return Travis.store.adapter.find(Travis.store, this.constructor, id);\n      }\n    },\n    update: function(attrs) {\n      var _this = this;\n      $.each(attrs, function(key, value) {\n        if (key !== 'id') {\n          return _this.set(key, value);\n        }\n      });\n      return this;\n    }\n  });\n\n  this.Travis.Model.reopenClass({\n    load: function(attrs) {\n      return Travis.store.load(this, attrs);\n    },\n    buildURL: function(suffix) {\n      var base, url;\n      base = this.url || this.pluralName();\n      Ember.assert('Base URL (' + base + ') must not start with slash', !base || base.toString().charAt(0) !== '/');\n      Ember.assert('URL suffix (' + suffix + ') must not start with slash', !suffix || suffix.toString().charAt(0) !== '/');\n      url = [base];\n      if (suffix !== void 0) {\n        url.push(suffix);\n      }\n      return url.join('/');\n    },\n    singularName: function() {\n      var name, parts;\n      parts = this.toString().split('.');\n      name = parts[parts.length - 1];\n      return name.replace(/([A-Z])/g, '_$1').toLowerCase().slice(1);\n    },\n    pluralName: function() {\n      return Travis.store.adapter.pluralize(this.singularName());\n    }\n  });\n\n}).call(this);\n\n})();\n//@ sourceURL=travis/model");minispade.register('travis/ticker', "(function() {(function() {\n\n  this.Travis.Ticker = Ember.Object.extend({\n    init: function() {\n      this._super();\n      return this.schedule();\n    },\n    tick: function() {\n      var context,\n        _this = this;\n      context = this.get('context');\n      this.get('targets').forEach(function(target) {\n        target = context.get(target);\n        if (!target) {\n          return;\n        }\n        if (target.forEach) {\n          return target.forEach(function(target) {\n            return target.tick();\n          });\n        } else {\n          return target.tick();\n        }\n      });\n      return this.schedule();\n    },\n    schedule: function() {\n      var _this = this;\n      return Ember.run.later((function() {\n        return _this.tick();\n      }), Travis.app.TICK_INTERVAL);\n    }\n  });\n\n}).call(this);\n\n})();\n//@ sourceURL=travis/ticker");minispade.register('i18n', "(function() {console.log('FOO')\nvar I18n = I18n || {};\nI18n.translations = {\"ca\":{\"locales\":{\"en\":\"English\",\"es\":\"Español\",\"fr\":\"Français\",\"ja\":\"日本語\",\"nb\":\"Norsk Bokmål\",\"nl\":\"Nederlands\",\"pl\":\"Polski\",\"pt-BR\":\"português brasileiro\",\"ru\":\"Русский\"}},\"en\":{\"errors\":{\"messages\":{\"not_found\":\"not found\",\"already_confirmed\":\"was already confirmed\",\"not_locked\":\"was not locked\"}},\"devise\":{\"failure\":{\"unauthenticated\":\"You need to sign in or sign up before continuing.\",\"unconfirmed\":\"You have to confirm your account before continuing.\",\"locked\":\"Your account is locked.\",\"invalid\":\"Invalid email or password.\",\"invalid_token\":\"Invalid authentication token.\",\"timeout\":\"Your session expired, please sign in again to continue.\",\"inactive\":\"Your account was not activated yet.\"},\"sessions\":{\"signed_in\":\"Signed in successfully.\",\"signed_out\":\"Signed out successfully.\"},\"passwords\":{\"send_instructions\":\"You will receive an email with instructions about how to reset your password in a few minutes.\",\"updated\":\"Your password was changed successfully. You are now signed in.\"},\"confirmations\":{\"send_instructions\":\"You will receive an email with instructions about how to confirm your account in a few minutes.\",\"confirmed\":\"Your account was successfully confirmed. You are now signed in.\"},\"registrations\":{\"signed_up\":\"You have signed up successfully. If enabled, a confirmation was sent to your e-mail.\",\"updated\":\"You updated your account successfully.\",\"destroyed\":\"Bye! Your account was successfully cancelled. We hope to see you again soon.\"},\"unlocks\":{\"send_instructions\":\"You will receive an email with instructions about how to unlock your account in a few minutes.\",\"unlocked\":\"Your account was successfully unlocked. You are now signed in.\"},\"mailer\":{\"confirmation_instructions\":{\"subject\":\"Confirmation instructions\"},\"reset_password_instructions\":{\"subject\":\"Reset password instructions\"},\"unlock_instructions\":{\"subject\":\"Unlock Instructions\"}}},\"datetime\":{\"distance_in_words\":{\"hours_exact\":{\"one\":\"%{count} hour\",\"other\":\"%{count} hours\"},\"minutes_exact\":{\"one\":\"%{count} minute\",\"other\":\"%{count} minutes\"},\"seconds_exact\":{\"one\":\"%{count} second\",\"other\":\"%{count} seconds\"}}},\"workers\":\"Workers\",\"queue\":\"Queue\",\"no_job\":\"There are no jobs\",\"repositories\":{\"branch\":\"Branch\",\"image_url\":\"Image URL\",\"markdown\":\"Markdown\",\"textile\":\"Textile\",\"rdoc\":\"RDOC\",\"commit\":\"Commit\",\"message\":\"Message\",\"started_at\":\"Started\",\"duration\":\"Duration\",\"finished_at\":\"Finished\",\"tabs\":{\"current\":\"Current\",\"build_history\":\"Build History\",\"branches\":\"Branch Summary\",\"pull_requests\":\"Pull Requests\",\"build\":\"Build\",\"job\":\"Job\"}},\"build\":{\"job\":\"Job\",\"duration\":\"Duration\",\"finished_at\":\"Finished\"},\"jobs\":{\"messages\":{\"sponsored_by\":\"This test suite was run on a worker box sponsored by\"},\"build_matrix\":\"Build Matrix\",\"allowed_failures\":\"Allowed Failures\",\"author\":\"Author\",\"config\":\"Config\",\"compare\":\"Compare\",\"committer\":\"Committer\",\"branch\":\"Branch\",\"commit\":\"Commit\",\"message\":\"Message\",\"started_at\":\"Started\",\"duration\":\"Duration\",\"finished_at\":\"Finished\"},\"builds\":{\"name\":\"Build\",\"messages\":{\"sponsored_by\":\"This test suite was run on a worker box sponsored by\"},\"build_matrix\":\"Build Matrix\",\"allowed_failures\":\"Allowed Failures\",\"author\":\"Author\",\"config\":\"Config\",\"compare\":\"Compare\",\"committer\":\"Committer\",\"branch\":\"Branch\",\"commit\":\"Commit\",\"message\":\"Message\",\"started_at\":\"Started\",\"duration\":\"Duration\",\"finished_at\":\"Finished\",\"show_more\":\"Show more\"},\"layouts\":{\"top\":{\"home\":\"Home\",\"blog\":\"Blog\",\"docs\":\"Docs\",\"stats\":\"Stats\",\"github_login\":\"Sign in with Github\",\"profile\":\"Profile\",\"sign_out\":\"Sign Out\",\"admin\":\"Admin\"},\"application\":{\"fork_me\":\"Fork me on Github\",\"recent\":\"Recent\",\"search\":\"Search\",\"sponsers\":\"Sponsors\",\"sponsors_link\":\"See all of our amazing sponsors &rarr;\",\"my_repositories\":\"My Repositories\"},\"about\":{\"alpha\":\"This stuff is alpha.\",\"messages\":{\"alpha\":\"Please do <strong>not</strong> consider this a stable service. We're still far from that! More info <a href='https://github.com/travis-ci'>here.</a>\"},\"join\":\"Join us and help!\",\"mailing_list\":\"Mailing List\",\"repository\":\"Repository\",\"twitter\":\"Twitter\"},\"mobile\":{\"author\":\"Author\",\"build\":\"Build\",\"build_matrix\":\"Build Matrix\",\"commit\":\"Commit\",\"committer\":\"Committer\",\"compare\":\"Compare\",\"config\":\"Config\",\"duration\":\"Duration\",\"finished_at\":\"Finished at\",\"job\":\"Job\",\"log\":\"Log\"}},\"profiles\":{\"show\":{\"email\":\"Email\",\"github\":\"Github\",\"message\":{\"your_repos\":\"  Flick the switches below to turn on the Travis service hook for your projects, then push to GitHub.<br />\\n  To test against multiple rubies, see\",\"config\":\"how to configure custom build options\"},\"messages\":{\"notice\":\"To get started, please read our <a href=\\\"http://about.travis-ci.org/docs/user/getting-started/\\\">Getting Started guide</a>.\\n  <small>It will only take a couple of minutes.</small>\"},\"token\":\"Token\",\"your_repos\":\"Your Repositories\",\"update\":\"Update\",\"update_locale\":\"Update\",\"your_locale\":\"Your Locale\"}},\"statistics\":{\"index\":{\"count\":\"Count\",\"repo_growth\":\"Repository Growth\",\"total_projects\":\"Total Projects/Repositories\",\"build_count\":\"Build Count\",\"last_month\":\"last month\",\"total_builds\":\"Total Builds\"}},\"locales\":{\"en\":\"English\",\"es\":\"Español\",\"fr\":\"Français\",\"ja\":\"日本語\",\"nb\":\"Norsk Bokmål\",\"pl\":\"Polski\",\"ru\":\"Русский\",\"nl\":\"Nederlands\",\"pt-BR\":\"português brasileiro\"}},\"es\":{\"datetime\":{\"distance_in_words\":{\"hours_exact\":{\"one\":\"%{count} hora\",\"other\":\"%{count} horas\"},\"minutes_exact\":{\"one\":\"%{count} minuto\",\"other\":\"%{count} minutos\"},\"seconds_exact\":{\"one\":\"%{count} segundo\",\"other\":\"%{count} segundos\"}}},\"workers\":\"Procesos\",\"queue\":\"Cola\",\"no_job\":\"No hay trabajos\",\"repositories\":{\"branch\":\"Rama\",\"image_url\":\"Imagen URL\",\"markdown\":\"Markdown\",\"textile\":\"Textile\",\"rdoc\":\"RDOC\",\"commit\":\"Commit\",\"message\":\"Mensaje\",\"started_at\":\"Iniciado\",\"duration\":\"Duración\",\"finished_at\":\"Finalizado\",\"tabs\":{\"current\":\"Actual\",\"build_history\":\"Histórico\",\"branches\":\"Ramas\",\"build\":\"Builds\",\"job\":\"Trabajo\"}},\"build\":{\"job\":\"Trabajo\",\"duration\":\"Duración\",\"finished_at\":\"Finalizado\"},\"jobs\":{\"messages\":{\"sponsored_by\":\"Esta serie de tests han sido ejecutados en una caja de Proceso patrocinada por\"},\"build_matrix\":\"Matriz de Builds\",\"allowed_failures\":\"Fallos Permitidos\",\"author\":\"Autor\",\"config\":\"Configuración\",\"compare\":\"Comparar\",\"committer\":\"Committer\",\"branch\":\"Rama\",\"commit\":\"Commit\",\"message\":\"Mensaje\",\"started_at\":\"Iniciado\",\"duration\":\"Duración\",\"finished_at\":\"Finalizado\",\"sponsored_by\":\"Patrocinado por\"},\"builds\":{\"name\":\"Build\",\"messages\":{\"sponsored_by\":\"Esta serie de tests han sido ejecutados en una caja de Proceso patrocinada por\"},\"build_matrix\":\"Matriz de Builds\",\"allowed_failures\":\"Fallos Permitidos\",\"author\":\"Autor\",\"config\":\"Configuración\",\"compare\":\"Comparar\",\"committer\":\"Committer\",\"branch\":\"Rama\",\"commit\":\"Commit\",\"message\":\"Mensaje\",\"started_at\":\"Iniciado\",\"duration\":\"Duración\",\"finished_at\":\"Finalizado\"},\"layouts\":{\"top\":{\"home\":\"Inicio\",\"blog\":\"Blog\",\"docs\":\"Documentación\",\"stats\":\"Estadísticas\",\"github_login\":\"Iniciar sesión con Github\",\"profile\":\"Perfil\",\"sign_out\":\"Desconectar\",\"admin\":\"Admin\"},\"application\":{\"fork_me\":\"Hazme un Fork en Github\",\"recent\":\"Reciente\",\"search\":\"Buscar\",\"sponsers\":\"Patrocinadores\",\"sponsors_link\":\"Ver todos nuestros patrocinadores &rarr;\",\"my_repositories\":\"Mis Repositorios\"},\"about\":{\"alpha\":\"Esto es alpha.\",\"messages\":{\"alpha\":\"Por favor <strong>no</strong> considereis esto un servicio estable. Estamos estamos aún lejos de ello! Más información <a href='https://github.com/travis-ci'>aquí.</a>\"},\"join\":\"Únetenos y ayudanos!\",\"mailing_list\":\"Lista de Correos\",\"repository\":\"Repositorio\",\"twitter\":\"Twitter\"}},\"profiles\":{\"show\":{\"email\":\"Correo electrónico\",\"github\":\"Github\",\"message\":{\"your_repos\":\"  Activa los interruptores para inicial el  Travis service hook para tus proyectos, y haz un Push en GitHub.<br />\\n  Para probar varias versiones de ruby, mira\",\"config\":\"como configurar tus propias opciones para el Build\"},\"messages\":{\"notice\":\"Para comenzar, por favor lee nuestra <a href=\\\"http://about.travis-ci.org/docs/user/getting-started/\\\">Guía de Inicio </a>.\\n  <small>Solo tomará unos pocos minutos.</small>\"},\"token\":\"Token\",\"your_repos\":\"Tus repositorios\",\"update\":\"Actualizar\",\"update_locale\":\"Actualizar\",\"your_locale\":\"Tu Idioma\"}},\"statistics\":{\"index\":{\"count\":\"Número\",\"repo_growth\":\"Crecimiento de Repositorios\",\"total_projects\":\"Total de Proyectos/Repositorios\",\"build_count\":\"Número de Builds\",\"last_month\":\"mes anterior\",\"total_builds\":\"Total de Builds\"}},\"locales\":{\"en\":\"English\",\"es\":\"Español\",\"fr\":\"Français\",\"ja\":\"日本語\",\"nb\":\"Norsk Bokmål\",\"pl\":\"Polski\",\"ru\":\"Русский\",\"nl\":\"Nederlands\",\"pt-BR\":\"português brasileiro\"}},\"fr\":{\"datetime\":{\"distance_in_words\":{\"hours_exact\":{\"one\":\"%{count} heure\",\"other\":\"%{count} heures\"},\"minutes_exact\":{\"one\":\"%{count} minute\",\"other\":\"%{count} minutes\"},\"seconds_exact\":{\"one\":\"%{count} seconde\",\"other\":\"%{count} secondes\"}}},\"workers\":\"Processus\",\"queue\":\"File\",\"no_job\":\"Pas de tâches\",\"repositories\":{\"branch\":\"Branche\",\"image_url\":\"Image\",\"markdown\":\"Markdown\",\"textile\":\"Textile\",\"rdoc\":\"RDOC\",\"commit\":\"Commit\",\"message\":\"Message\",\"started_at\":\"Commencé\",\"duration\":\"Durée\",\"finished_at\":\"Terminé\",\"tabs\":{\"current\":\"Actuel\",\"build_history\":\"Historique des tâches\",\"branches\":\"Résumé des branches\",\"build\":\"Construction\",\"job\":\"Tâche\"}},\"build\":{\"job\":\"Tâche\",\"duration\":\"Durée\",\"finished_at\":\"Terminé\"},\"jobs\":{\"messages\":{\"sponsored_by\":\"Cette série de tests a été exécutée sur une machine sponsorisée par\"},\"build_matrix\":\"Matrice des versions\",\"allowed_failures\":\"Échecs autorisés\",\"author\":\"Auteur\",\"config\":\"Config\",\"compare\":\"Comparer\",\"committer\":\"Committeur\",\"branch\":\"Branche\",\"commit\":\"Commit\",\"message\":\"Message\",\"started_at\":\"Commencé\",\"duration\":\"Durée\",\"finished_at\":\"Terminé\",\"sponsored_by\":\"Cette série de tests a été exécutée sur une machine sponsorisée par\"},\"builds\":{\"name\":\"Version\",\"messages\":{\"sponsored_by\":\"Cette série de tests a été exécutée sur une machine sponsorisée par\"},\"build_matrix\":\"Matrice des versions\",\"allowed_failures\":\"Échecs autorisés\",\"author\":\"Auteur\",\"config\":\"Config\",\"compare\":\"Comparer\",\"committer\":\"Committeur\",\"branch\":\"Branche\",\"commit\":\"Commit\",\"message\":\"Message\",\"started_at\":\"Commencé\",\"duration\":\"Durée\",\"finished_at\":\"Terminé\"},\"layouts\":{\"top\":{\"home\":\"Accueil\",\"blog\":\"Blog\",\"docs\":\"Documentation\",\"stats\":\"Statistiques\",\"github_login\":\"Connection Github\",\"profile\":\"Profil\",\"sign_out\":\"Déconnection\",\"admin\":\"Admin\"},\"application\":{\"fork_me\":\"Faites un Fork sur Github\",\"recent\":\"Récent\",\"search\":\"Chercher\",\"sponsers\":\"Sponsors\",\"sponsors_link\":\"Voir tous nos extraordinaire sponsors &rarr;\",\"my_repositories\":\"Mes dépôts\"},\"about\":{\"alpha\":\"Ceci est en alpha.\",\"messages\":{\"alpha\":\"S'il vous plaît ne considérez <strong>pas</strong> ce service comme étant stable. Nous sommes loin de ça! Plus d'infos <a href='https://github.com/travis-ci'>ici.</a>\"},\"join\":\"Joignez-vous à nous et aidez-nous!\",\"mailing_list\":\"Liste de distribution\",\"repository\":\"Dépôt\",\"twitter\":\"Twitter\"},\"mobile\":{\"author\":\"Auteur\",\"build\":\"Version\",\"build_matrix\":\"Matrice des versions\",\"commit\":\"Commit\",\"committer\":\"Committeur\",\"compare\":\"Comparer\",\"config\":\"Config\",\"duration\":\"Durée\",\"finished_at\":\"Terminé à\",\"job\":\"Tâche\",\"log\":\"Journal\"}},\"profiles\":{\"show\":{\"github\":\"Github\",\"message\":{\"your_repos\":\"Utilisez les boutons ci-dessous pour activer Travis sur vos projets puis déployez sur GitHub.<br />\\nPour tester sur plus de versions de ruby, voir\",\"config\":\"comment configurer des options de version personnalisées\"},\"messages\":{\"notice\":\"Pour commencer, veuillez lire notre <a href=\\\"http://about.travis-ci.org/docs/user/getting-started/\\\">guide de démarrage</a>.\\n <small>Cela ne vous prendra que quelques minutes.</small>\"},\"token\":\"Jeton\",\"your_repos\":\"Vos dépôts\",\"email\":\"Courriel\",\"update\":\"Modifier\",\"update_locale\":\"Modifier\",\"your_locale\":\"Votre langue\"}},\"statistics\":{\"index\":{\"count\":\"Décompte\",\"repo_growth\":\"Croissance de dépôt\",\"total_projects\":\"Total des projets/dépôts\",\"build_count\":\"Décompte des versions\",\"last_month\":\"mois dernier\",\"total_builds\":\"Total des versions\"}},\"admin\":{\"actions\":{\"create\":\"créer\",\"created\":\"créé\",\"delete\":\"supprimer\",\"deleted\":\"supprimé\",\"update\":\"mise à jour\",\"updated\":\"mis à jour\"},\"credentials\":{\"log_out\":\"Déconnection\"},\"delete\":{\"confirmation\":\"Oui, je suis sure\",\"flash_confirmation\":\"%{name} a été détruit avec succès\"},\"flash\":{\"error\":\"%{name} n'a pas pu être %{action}\",\"noaction\":\"Aucune action n'a été entreprise\",\"successful\":\"%{name} a réussi à %{action}\"},\"history\":{\"name\":\"Historique\",\"no_activity\":\"Aucune activité\",\"page_name\":\"Historique pour %{name}\"},\"list\":{\"add_new\":\"Ajouter un nouveau\",\"delete_action\":\"Supprimer\",\"delete_selected\":\"Supprimer la sélection\",\"edit_action\":\"Modifier\",\"search\":\"Rechercher\",\"select\":\"Sélectionner le %{name} à modifier\",\"select_action\":\"Sélectionner\",\"show_all\":\"Montrer tout\"},\"new\":{\"basic_info\":\"Information de base\",\"cancel\":\"Annuler\",\"chosen\":\"%{name} choisi\",\"chose_all\":\"Choisir tout\",\"clear_all\":\"Déselectionner tout\",\"many_chars\":\"caractères ou moins\",\"one_char\":\"caractère.\",\"optional\":\"Optionnel\",\"required\":\"Requis\",\"save\":\"Sauvegarder\",\"save_and_add_another\":\"Sauvegarder et en ajouter un autre\",\"save_and_edit\":\"Sauvegarder et modifier\",\"select_choice\":\"Faites vos choix et cliquez\"},\"dashboard\":{\"add_new\":\"Ajouter un nouveau\",\"last_used\":\"Dernière utilisation\",\"model_name\":\"Nom du modèle\",\"modify\":\"Modification\",\"name\":\"Tableau de bord\",\"pagename\":\"Administration du site\",\"records\":\"Enregistrements\",\"show\":\"Voir\",\"ago\":\"plus tôt\"}},\"home\":{\"name\":\"accueil\"},\"repository\":{\"duration\":\"Durée\"},\"devise\":{\"confirmations\":{\"confirmed\":\"Votre compte a été crée avec succès. Vous être maintenant connecté.\",\"send_instructions\":\"Vous allez recevoir un courriel avec les instructions de confirmation de votre compte dans quelques minutes.\"},\"failure\":{\"inactive\":\"Votre compte n'a pas encore été activé.\",\"invalid\":\"Adresse courriel ou mot de passe invalide.\",\"invalid_token\":\"Jeton d'authentification invalide.\",\"locked\":\"Votre compte est bloqué.\",\"timeout\":\"Votre session est expirée, veuillez vous reconnecter pour continuer.\",\"unauthenticated\":\"Vous devez vous connecter ou vous enregistrer afin de continuer\",\"unconfirmed\":\"Vous devez confirmer votre compte avant de continuer.\"},\"mailer\":{\"confirmation_instructions\":{\"subject\":\"Instructions de confirmations\"},\"reset_password_instructions\":{\"subject\":\"Instruction de remise à zéro du mot de passe\"},\"unlock_instructions\":{\"subject\":\"Instruction de débloquage\"}},\"passwords\":{\"send_instructions\":\"Vous recevrez un courriel avec les instructions de remise à zéro du mot de passe dans quelques minutes.\",\"updated\":\"Votre mot de passe a été changé avec succès. Vous êtes maintenant connecté.\"},\"registrations\":{\"destroyed\":\"Au revoir! Votre compte a été annulé avec succès. Nous espérons vous revoir bientôt.\",\"signed_up\":\"Vous êtes enregistré avec succès. Si activé, une confirmation vous a été envoyé par courriel.\",\"updated\":\"Votre compte a été mis a jour avec succès\"},\"sessions\":{\"signed_in\":\"Connecté avec succès\",\"signed_out\":\"Déconnecté avec succès\"},\"unlocks\":{\"send_instructions\":\"Vous recevrez un courriel contenant les instructions pour débloquer votre compte dans quelques minutes.\",\"unlocked\":\"Votre compte a été débloqué avec succès.\"}},\"errors\":{\"messages\":{\"already_confirmed\":\"étais déja confirmé\",\"not_found\":\"n'a pas été trouvé\",\"not_locked\":\"n'étais pas bloqué\"}},\"locales\":{\"en\":\"English\",\"es\":\"Español\",\"ja\":\"日本語\",\"ru\":\"Русский\",\"fr\":\"Français\",\"nb\":\"Norsk Bokmål\",\"pl\":\"Polski\",\"nl\":\"Nederlands\",\"pt-BR\":\"português brasileiro\"}},\"ja\":{\"workers\":\"ワーカー\",\"queue\":\"キュー\",\"no_job\":\"ジョブはありません\",\"repositories\":{\"branch\":\"ブランチ\",\"image_url\":\"画像URL\",\"markdown\":\".md\",\"textile\":\".textile\",\"rdoc\":\".rdoc\",\"commit\":\"コミット\",\"message\":\"メッセージ\",\"started_at\":\"開始時刻\",\"duration\":\"処理時間\",\"finished_at\":\"終了時刻\",\"tabs\":{\"current\":\"最新\",\"build_history\":\"ビルド履歴\",\"branches\":\"ブランチまとめ\",\"build\":\"ビルド\",\"job\":\"ジョブ\"}},\"build\":{\"job\":\"ジョブ\",\"duration\":\"処理時間\",\"finished_at\":\"終了時刻\"},\"jobs\":{\"messages\":{\"sponsored_by\":\"このテストは以下のスポンサーの協力で行いました。\"},\"build_matrix\":\"ビルドマトリクス\",\"allowed_failures\":\"失敗許容範囲内\",\"author\":\"制作者\",\"config\":\"設定\",\"compare\":\"比較\",\"committer\":\"コミット者\",\"branch\":\"ブランチ\",\"commit\":\"コミット\",\"message\":\"メッセージ\",\"started_at\":\"開始時刻\",\"duration\":\"処理時間\",\"finished_at\":\"終了時刻\"},\"builds\":{\"name\":\"ビルド\",\"messages\":{\"sponsored_by\":\"このテストは以下のスポンサーの協力で行いました。\"},\"build_matrix\":\"失敗許容範囲外\",\"allowed_failures\":\"失敗許容範囲内\",\"author\":\"制作者\",\"config\":\"設定\",\"compare\":\"比較\",\"committer\":\"コミット者\",\"branch\":\"ブランチ\",\"commit\":\"コミット\",\"message\":\"メッセージ\",\"started_at\":\"開始時刻\",\"duration\":\"処理時間\",\"finished_at\":\"終了時刻\"},\"layouts\":{\"about\":{\"alpha\":\"まだアルファですよ！\",\"join\":\"参加してみよう！\",\"mailing_list\":\"メールリスト\",\"messages\":{\"alpha\":\"Travis-ciは安定したサービスまで後一歩！詳しくは<a href='https://github.com/travis-ci'>こちら</a>\"},\"repository\":\"リポジトリ\",\"twitter\":\"ツイッター\"},\"application\":{\"fork_me\":\"Githubでフォークしよう\",\"my_repositories\":\"マイリポジトリ\",\"recent\":\"最近\",\"search\":\"検索\",\"sponsers\":\"スポンサー\",\"sponsors_link\":\"スポンサーをもっと見る &rarr;\"},\"top\":{\"blog\":\"ブログ\",\"docs\":\"Travisとは？\",\"github_login\":\"Githubでログイン\",\"home\":\"ホーム\",\"profile\":\"プロフィール\",\"sign_out\":\"ログアウト\",\"stats\":\"統計\",\"admin\":\"管理\"},\"mobile\":{\"author\":\"制作者\",\"build\":\"ビルド\",\"build_matrix\":\"ビルドマトリクス\",\"commit\":\"コミット\",\"committer\":\"コミット者\",\"compare\":\"比較\",\"config\":\"設定\",\"duration\":\"処理時間\",\"finished_at\":\"終了時刻\",\"job\":\"ジョブ\",\"log\":\"ログ\"}},\"profiles\":{\"show\":{\"github\":\"Github\",\"email\":\"メール\",\"message\":{\"config\":\"詳細設定\",\"your_repos\":\"以下のスイッチを設定し、Travis-ciを有効にします。Githubへプッシュしたらビルドは自動的に開始します。複数バーションや細かい設定はこちらへ：\"},\"messages\":{\"notice\":\"まずは<a href=\\\"http://about.travis-ci.org/docs/user/getting-started/\\\">Travisのはじめ方</a>を参照してください。\"},\"token\":\"トークン\",\"your_repos\":\"リポジトリ\",\"update\":\"更新\",\"update_locale\":\"更新\",\"your_locale\":\"言語設定\"}},\"statistics\":{\"index\":{\"build_count\":\"ビルド数\",\"count\":\"数\",\"last_month\":\"先月\",\"repo_growth\":\"リポジトリ\",\"total_builds\":\"合計ビルド数\",\"total_projects\":\"合計リポジトリ\"}},\"locales\":{\"en\":\"English\",\"es\":\"Español\",\"fr\":\"Français\",\"ja\":\"日本語\",\"nb\":\"Norsk Bokmål\",\"pl\":\"Polski\",\"ru\":\"Русский\",\"nl\":\"Nederlands\",\"pt-BR\":\"português brasileiro\"}},\"nb\":{\"admin\":{\"actions\":{\"create\":\"opprett\",\"created\":\"opprettet\",\"delete\":\"slett\",\"deleted\":\"slettet\",\"update\":\"oppdater\",\"updated\":\"oppdatert\"},\"credentials\":{\"log_out\":\"Logg ut\"},\"dashboard\":{\"add_new\":\"Legg til ny\",\"ago\":\"siden\",\"last_used\":\"Sist brukt\",\"model_name\":\"Modell\",\"modify\":\"Rediger\",\"name\":\"Dashbord\",\"pagename\":\"Nettstedsadministrasjon\",\"records\":\"Oppføringer\",\"show\":\"Vis\"},\"delete\":{\"confirmation\":\"Ja, jeg er sikker\",\"flash_confirmation\":\"%{name} ble slettet\"},\"flash\":{\"error\":\"%{name} kunne ikke bli %{action}\",\"noaction\":\"Ingen handlinger ble utført\",\"successful\":\"%{name} ble %{action}\"},\"history\":{\"name\":\"Logg\",\"no_activity\":\"Ingen aktivitet\",\"page_name\":\"Logg for %{name}\"},\"list\":{\"add_new\":\"Legg til ny\",\"delete_action\":\"Slett\",\"delete_selected\":\"Slett valgte\",\"edit_action\":\"Rediger\",\"search\":\"Søk\",\"select\":\"Velg %{name} for å redigere\",\"select_action\":\"Velg\",\"show_all\":\"Vis alle \"},\"new\":{\"basic_info\":\"Basisinformasjon\",\"cancel\":\"Avbryt\",\"chosen\":\"Valgt %{name}\",\"chose_all\":\"Velg alle\",\"clear_all\":\"Fjern alle\",\"many_chars\":\"eller færre tegn.\",\"one_char\":\"tegn.\",\"optional\":\"Valgfri\",\"required\":\"Påkrevd\",\"save\":\"Lagre\",\"save_and_add_another\":\"Lagre og legg til ny\",\"save_and_edit\":\"Lagre og rediger\",\"select_choice\":\"Kryss av for dine valg og klikk\"}},\"build\":{\"duration\":\"Varighet\",\"finished_at\":\"Fullført\",\"job\":\"Jobb\"},\"builds\":{\"allowed_failures\":\"Tillatte feil\",\"author\":\"Forfatter\",\"branch\":\"Gren\",\"build_matrix\":\"Jobbmatrise\",\"commit\":\"Innsending\",\"committer\":\"Innsender\",\"compare\":\"Sammenlign\",\"config\":\"Oppsett\",\"duration\":\"Varighet\",\"finished_at\":\"Fullført\",\"message\":\"Beskrivelse\",\"messages\":{\"sponsored_by\":\"Denne testen ble kjørt på en maskin sponset av\"},\"name\":\"Jobb\",\"started_at\":\"Startet\"},\"datetime\":{\"distance_in_words\":{\"hours_exact\":{\"one\":\"%{count} time\",\"other\":\"%{count} timer\"},\"minutes_exact\":{\"one\":\"%{count} minutt\",\"other\":\"%{count} minutter\"},\"seconds_exact\":{\"one\":\"%{count} sekund\",\"other\":\"%{count} sekunder\"}}},\"devise\":{\"confirmations\":{\"confirmed\":\"Din konto er aktivert og du er nå innlogget.\",\"send_instructions\":\"Om noen få minutter så vil du få en e-post med informasjon om hvordan du bekrefter kontoen din.\"},\"failure\":{\"inactive\":\"Kontoen din har ikke blitt aktivert enda.\",\"invalid\":\"Ugyldig e-post eller passord.\",\"invalid_token\":\"Ugyldig autentiseringskode.\",\"locked\":\"Kontoen din er låst.\",\"timeout\":\"Du ble logget ut siden på grunn av mangel på aktivitet, vennligst logg inn på nytt.\",\"unauthenticated\":\"Du må logge inn eller registrere deg for å fortsette.\",\"unconfirmed\":\"Du må bekrefte kontoen din før du kan fortsette.\"},\"mailer\":{\"confirmation_instructions\":{\"subject\":\"Bekreftelsesinformasjon\"},\"reset_password_instructions\":{\"subject\":\"Instruksjoner for å få nytt passord\"},\"unlock_instructions\":{\"subject\":\"Opplåsningsinstruksjoner\"}},\"passwords\":{\"send_instructions\":\"Om noen få minutter så vil du få en epost med informasjon om hvordan du kan få et nytt passord.\",\"updated\":\"Passordet ditt ble endret, og du er logget inn.\"},\"registrations\":{\"destroyed\":\"Adjø! Kontoen din ble kansellert. Vi håper vi ser deg igjen snart.\",\"signed_up\":\"Du er nå registrert.\",\"updated\":\"Kontoen din ble oppdatert.\"},\"sessions\":{\"signed_in\":\"Du er nå logget inn.\",\"signed_out\":\"Du er nå logget ut.\"},\"unlocks\":{\"send_instructions\":\"Om noen få minutter så kommer du til å få en e-post med informasjon om hvordan du kan låse opp kontoen din.\",\"unlocked\":\"Kontoen din ble låst opp, og du er nå logget inn igjen.\"}},\"errors\":{\"messages\":{\"already_confirmed\":\"har allerede blitt bekreftet\",\"not_found\":\"ikke funnnet\",\"not_locked\":\"var ikke låst\"}},\"home\":{\"name\":\"hjem\"},\"jobs\":{\"allowed_failures\":\"Tillatte feil\",\"author\":\"Forfatter\",\"branch\":\"Gren\",\"build_matrix\":\"Jobbmatrise\",\"commit\":\"Innsending\",\"committer\":\"Innsender\",\"compare\":\"Sammenlign\",\"config\":\"Oppsett\",\"duration\":\"Varighet\",\"finished_at\":\"Fullført\",\"message\":\"Beskrivelse\",\"messages\":{\"sponsored_by\":\"Denne testserien ble kjørt på en maskin sponset av\"},\"started_at\":\"Startet\"},\"layouts\":{\"about\":{\"alpha\":\"Dette er alfa-greier.\",\"join\":\"Bli med og hjelp oss!\",\"mailing_list\":\"E-postliste\",\"messages\":{\"alpha\":\"Dette er <strong>ikke</strong> en stabil tjeneste. Vi har fremdeles et stykke igjen! Mer informasjon finner du <a href=\\\"https://github.com/travis-ci\\\">her</a>.\"},\"repository\":\"Kodelager\",\"twitter\":\"Twitter.\"},\"application\":{\"fork_me\":\"Se koden på Github\",\"my_repositories\":\"Mine kodelagre\",\"recent\":\"Nylig\",\"search\":\"Søk\",\"sponsers\":\"Sponsorer\",\"sponsors_link\":\"Se alle de flotte sponsorene våre &rarr;\"},\"mobile\":{\"author\":\"Forfatter\",\"build\":\"Jobb\",\"build_matrix\":\"Jobbmatrise\",\"commit\":\"Innsending\",\"committer\":\"Innsender\",\"compare\":\"Sammenlign\",\"config\":\"Oppsett\",\"duration\":\"Varighet\",\"finished_at\":\"Fullført\",\"job\":\"Jobb\",\"log\":\"Logg\"},\"top\":{\"admin\":\"Administrator\",\"blog\":\"Blogg\",\"docs\":\"Dokumentasjon\",\"github_login\":\"Logg inn med Github\",\"home\":\"Hjem\",\"profile\":\"Profil\",\"sign_out\":\"Logg ut\",\"stats\":\"Statistikk\"}},\"no_job\":\"Ingen jobber finnnes\",\"profiles\":{\"show\":{\"email\":\"E-post\",\"github\":\"Github\",\"message\":{\"config\":\"hvordan sette opp egne jobbinnstillinger\",\"your_repos\":\"Slå\\u0010 på Travis for prosjektene dine ved å dra i bryterne under, og send koden til Github.<br />\\nFor å teste mot flere ruby-versjoner, se dokumentasjonen for\"},\"messages\":{\"notice\":\"For å komme i gang, vennligst les <a href=\\\"http://about.travis-ci.org/docs/user/getting-started/\\\">kom-i-gang-veivisereren</a> vår. <small>Det tar bare et par minutter.</small>\"},\"token\":\"Kode\",\"update\":\"Oppdater\",\"update_locale\":\"Oppdater\",\"your_locale\":\"Ditt språk\",\"your_repos\":\"Dine kodelagre\"}},\"queue\":\"Kø\",\"repositories\":{\"branch\":\"Gren\",\"commit\":\"Innsender\",\"duration\":\"Varighet\",\"finished_at\":\"Fullført\",\"image_url\":\"Bilde-URL\",\"markdown\":\"Markdown\",\"message\":\"Beskrivelse\",\"rdoc\":\"RDOC\",\"started_at\":\"Startet\",\"tabs\":{\"branches\":\"Grensammendrag\",\"build\":\"Jobb\",\"build_history\":\"Jobblogg\",\"current\":\"Siste\",\"job\":\"Jobb\"},\"textile\":\"Textile\"},\"repository\":{\"duration\":\"Varighet\"},\"statistics\":{\"index\":{\"build_count\":\"Antall jobber\",\"count\":\"Antall\",\"last_month\":\"siste måned\",\"repo_growth\":\"Vekst i kodelager\",\"total_builds\":\"Totale jobber\",\"total_projects\":\"Antall prosjekter/kodelagre\"}},\"workers\":\"Arbeidere\",\"locales\":{\"en\":\"English\",\"es\":\"Español\",\"ja\":\"日本語\",\"ru\":\"Русский\",\"fr\":\"Français\",\"nb\":\"Norsk Bokmål\",\"pl\":\"Polski\",\"nl\":\"Nederlands\",\"pt-BR\":\"português brasileiro\"}},\"nl\":{\"admin\":{\"actions\":{\"create\":\"aanmaken\",\"created\":\"aangemaakt\",\"delete\":\"verwijderen\",\"deleted\":\"verwijderd\",\"update\":\"bijwerken\",\"updated\":\"bijgewerkt\"},\"credentials\":{\"log_out\":\"Afmelden\"},\"dashboard\":{\"add_new\":\"Nieuwe toevoegen\",\"ago\":\"geleden\",\"last_used\":\"Laatst gebruikt\",\"model_name\":\"Model naam\",\"modify\":\"Wijzigen\",\"pagename\":\"Site administratie\",\"show\":\"Laten zien\",\"records\":\"Gegevens\"},\"delete\":{\"confirmation\":\"Ja, ik ben zeker\",\"flash_confirmation\":\"%{name} is vernietigd\"},\"flash\":{\"error\":\"%{name} kon niet worden %{action}\",\"noaction\":\"Er zijn geen acties genomen\",\"successful\":\"%{name} is %{action}\"},\"history\":{\"name\":\"Geschiedenis\",\"no_activity\":\"Geen activiteit\",\"page_name\":\"Geschiedenis van %{name}\"},\"list\":{\"add_new\":\"Nieuwe toevoegen\",\"delete_action\":\"Verwijderen\",\"delete_selected\":\"Verwijder geselecteerden\",\"edit_action\":\"Bewerken\",\"search\":\"Zoeken\",\"select\":\"Selecteer %{name} om te bewerken\",\"select_action\":\"Selecteer\",\"show_all\":\"Laat allen zien\"},\"new\":{\"basic_info\":\"Basisinfo\",\"cancel\":\"Annuleren\",\"chosen\":\"%{name} gekozen\",\"chose_all\":\"Kies allen\",\"clear_all\":\"Deselecteer allen\",\"many_chars\":\"tekens of minder.\",\"one_char\":\"teken.\",\"optional\":\"Optioneel\",\"required\":\"Vereist\",\"save\":\"Opslaan\",\"save_and_add_another\":\"Opslaan en een nieuwe toevoegen\",\"save_and_edit\":\"Opslaan en bewerken\",\"select_choice\":\"Selecteer uw keuzes en klik\"}},\"build\":{\"duration\":\"Duur\",\"finished_at\":\"Voltooid\",\"job\":\"Taak\"},\"builds\":{\"allowed_failures\":\"Toegestane mislukkingen\",\"author\":\"Auteur\",\"branch\":\"Tak\",\"build_matrix\":\"Bouw Matrix\",\"compare\":\"Vergelijk\",\"config\":\"Configuratie\",\"duration\":\"Duur\",\"finished_at\":\"Voltooid\",\"message\":\"Bericht\",\"messages\":{\"sponsored_by\":\"Deze tests zijn gedraaid op een machine gesponsord door\"},\"name\":\"Bouw\",\"started_at\":\"Gestart\",\"commit\":\"Commit\",\"committer\":\"Committer\"},\"datetime\":{\"distance_in_words\":{\"hours_exact\":{\"one\":\"%{count} uur\",\"other\":\"%{count} uren\"},\"minutes_exact\":{\"one\":\"%{count} minuut\",\"other\":\"%{count} minuten\"},\"seconds_exact\":{\"one\":\"%{count} seconde\",\"other\":\"%{count} seconden\"}}},\"devise\":{\"confirmations\":{\"confirmed\":\"Uw account is bevestigd. U wordt nu ingelogd.\",\"send_instructions\":\"Binnen enkele minuten zal u een email ontvangen met instructies om uw account te bevestigen.\"},\"failure\":{\"inactive\":\"Uw account is nog niet geactiveerd.\",\"invalid\":\"Ongeldig email adres of wachtwoord.\",\"invalid_token\":\"Ongeldig authenticatie token.\",\"locked\":\"Uw account is vergrendeld.\",\"timeout\":\"Uw sessie is verlopen, gelieve opnieuw in te loggen om verder te gaan.\",\"unauthenticated\":\"U moet inloggen of u registeren voordat u verder gaat.\",\"unconfirmed\":\"U moet uw account bevestigen voordat u verder gaat.\"},\"mailer\":{\"confirmation_instructions\":{\"subject\":\"Bevestigings-instructies\"},\"reset_password_instructions\":{\"subject\":\"Wachtwoord herstel instructies\"},\"unlock_instructions\":{\"subject\":\"Ontgrendel-instructies\"}},\"passwords\":{\"send_instructions\":\"Binnen enkele minuten zal u een email krijgen met instructies om uw wachtwoord opnieuw in te stellen.\",\"updated\":\"Uw wachtwoord is veranderd. U wordt nu ingelogd.\"},\"registrations\":{\"destroyed\":\"Dag! Uw account is geannuleerd. We hopen u vlug terug te zien.\",\"signed_up\":\"Uw registratie is voltooid. Als het ingeschakeld is wordt een bevestiging naar uw email adres verzonden.\",\"updated\":\"Het bijwerken van uw account is gelukt.\"},\"sessions\":{\"signed_in\":\"Inloggen gelukt.\",\"signed_out\":\"Uitloggen gelukt.\"},\"unlocks\":{\"send_instructions\":\"Binnen enkele minuten zal u een email krijgen met instructies om uw account te ontgrendelen.\",\"unlocked\":\"Uw account is ontgrendeld. U wordt nu ingelogd.\"}},\"errors\":{\"messages\":{\"already_confirmed\":\"was al bevestigd\",\"not_found\":\"niet gevonden\",\"not_locked\":\"was niet vergrendeld\"}},\"jobs\":{\"allowed_failures\":\"Toegestane mislukkingen\",\"author\":\"Auteur\",\"branch\":\"Tak\",\"build_matrix\":\"Bouw matrix\",\"compare\":\"Vergelijk\",\"config\":\"Configuratie\",\"duration\":\"Duur\",\"finished_at\":\"Voltooid\",\"message\":\"Bericht\",\"messages\":{\"sponsored_by\":\"Deze testen zijn uitgevoerd op een machine gesponsord door\"},\"started_at\":\"Gestart\",\"commit\":\"Commit\",\"committer\":\"Committer\"},\"layouts\":{\"about\":{\"alpha\":\"Dit is in alfa-stadium.\",\"join\":\"Doe met ons mee en help!\",\"mailing_list\":\"Mailing lijst\",\"messages\":{\"alpha\":\"Gelieve deze service <strong>niet</strong> te beschouwen als stabiel. Daar zijn we nog lang niet! Meer info <a href='https://github.com/travis-ci'>hier.</a>\"},\"repository\":\"Repository\",\"twitter\":\"Twitter\"},\"application\":{\"fork_me\":\"Maak een fork op Github\",\"my_repositories\":\"Mijn repositories\",\"recent\":\"Recent\",\"search\":\"Zoeken\",\"sponsers\":\"Sponsors\",\"sponsors_link\":\"Bekijk al onze geweldige sponsors &rarr;\"},\"mobile\":{\"author\":\"Auteur\",\"build\":\"Bouw\",\"build_matrix\":\"Bouw matrix\",\"compare\":\"Vergelijk\",\"config\":\"Configuratie\",\"duration\":\"Duur\",\"finished_at\":\"Voltooid op\",\"job\":\"Taak\",\"commit\":\"Commit\",\"committer\":\"Committer\",\"log\":\"Logboek\"},\"top\":{\"admin\":\"Administratie\",\"blog\":\"Blog\",\"docs\":\"Documentatie\",\"github_login\":\"Inloggen met Github\",\"home\":\"Home\",\"profile\":\"Profiel\",\"sign_out\":\"Uitloggen\",\"stats\":\"Statistieken\"}},\"locales\":{\"en\":\"English\",\"es\":\"Español\",\"fr\":\"Français\",\"ja\":\"日本語\",\"nb\":\"Norsk Bokmål\",\"nl\":\"Nederlands\",\"pl\":\"Polski\",\"ru\":\"Русский\",\"pt-BR\":\"português brasileiro\"},\"no_job\":\"Er zijn geen taken\",\"profiles\":{\"show\":{\"email\":\"Email adres\",\"github\":\"Github\",\"message\":{\"config\":\"hoe eigen bouw-opties in te stellen\",\"your_repos\":\"Zet de schakelaars hieronder aan om de Travis hook voor uw projecten te activeren en push daarna naar Github<br />\\nOm te testen tegen meerdere rubies, zie\"},\"messages\":{\"notice\":\"Om te beginnen kunt u onze <a href=\\\\\\\"http://about.travis-ci.org/docs/user/getting-started/\\\\\\\">startersgids</a> lezen.\\\\n  <small>Het zal maar enkele minuten van uw tijd vergen.</small>\"},\"update\":\"Bijwerken\",\"update_locale\":\"Bijwerken\",\"your_locale\":\"Uw taal\",\"your_repos\":\"Uw repositories\",\"token\":\"Token\"}},\"queue\":\"Wachtrij\",\"repositories\":{\"branch\":\"Tak\",\"duration\":\"Duur\",\"finished_at\":\"Voltooid\",\"image_url\":\"Afbeeldings URL\",\"message\":\"Bericht\",\"started_at\":\"Gestart\",\"tabs\":{\"branches\":\"Tak samenvatting\",\"build\":\"Bouw\",\"build_history\":\"Bouw geschiedenis\",\"current\":\"Huidig\",\"job\":\"Taak\"},\"commit\":\"Commit\",\"markdown\":\"Markdown\",\"rdoc\":\"RDOC\",\"textile\":\"Textile\"},\"repository\":{\"duration\":\"Duur\"},\"statistics\":{\"index\":{\"build_count\":\"Bouw aantal\",\"count\":\"Aantal\",\"last_month\":\"voorbije maand\",\"repo_growth\":\"Repository groei\",\"total_builds\":\"Bouw totaal\",\"total_projects\":\"Projecten/Repository totaal\"}},\"workers\":\"Machines\",\"home\":{\"name\":\"Hoofdpagina\"}},\"pl\":{\"datetime\":{\"distance_in_words\":{\"hours_exact\":{\"one\":\"%{count} godzina\",\"other\":\"%{count} godziny\"},\"minutes_exact\":{\"one\":\"%{count} minuta\",\"other\":\"%{count} minuty\"},\"seconds_exact\":{\"one\":\"%{count} sekunda\",\"other\":\"%{count} sekundy\"}}},\"workers\":\"Workers\",\"queue\":\"Kolejka\",\"no_job\":\"Brak zadań\",\"repositories\":{\"branch\":\"Gałąź\",\"image_url\":\"URL obrazka\",\"markdown\":\"Markdown\",\"textile\":\"Textile\",\"rdoc\":\"RDOC\",\"commit\":\"Commit\",\"message\":\"Opis\",\"started_at\":\"Rozpoczęto\",\"duration\":\"Czas trwania\",\"finished_at\":\"Zakończono\",\"tabs\":{\"current\":\"Aktualny\",\"build_history\":\"Historia Buildów\",\"branches\":\"Wszystkie Gałęzie\",\"build\":\"Build\",\"job\":\"Zadanie\"}},\"build\":{\"job\":\"Zadanie\",\"duration\":\"Czas trwania\",\"finished_at\":\"Zakończono\"},\"jobs\":{\"messages\":{\"sponsored_by\":\"Te testy zostały uruchomione na maszynie sponsorowanej przez\"},\"build_matrix\":\"Macierz Buildów\",\"allowed_failures\":\"Dopuszczalne Niepowodzenia\",\"author\":\"Autor\",\"config\":\"Konfiguracja\",\"compare\":\"Porównanie\",\"committer\":\"Committer\",\"branch\":\"Gałąź\",\"commit\":\"Commit\",\"message\":\"Opis\",\"started_at\":\"Rozpoczęto\",\"duration\":\"Czas trwania\",\"finished_at\":\"Zakończono\",\"sponsored_by\":\"Te testy zostały uruchomione na maszynie sponsorowanej przez\"},\"builds\":{\"name\":\"Build\",\"messages\":{\"sponsored_by\":\"Te testy zostały uruchomione na maszynie sponsorowanej przez\"},\"build_matrix\":\"Macierz Buildów\",\"allowed_failures\":\"Dopuszczalne Niepowodzenia\",\"author\":\"Autor\",\"config\":\"Konfiguracja\",\"compare\":\"Porównanie\",\"committer\":\"Komitujący\",\"branch\":\"Gałąź\",\"commit\":\"Commit\",\"message\":\"Opis\",\"started_at\":\"Rozpoczęto\",\"duration\":\"Czas trwania\",\"finished_at\":\"Zakończono\"},\"layouts\":{\"top\":{\"home\":\"Start\",\"blog\":\"Blog\",\"docs\":\"Dokumentacja\",\"stats\":\"Statystki\",\"github_login\":\"Zaloguj się przy pomocy Githuba\",\"profile\":\"Profil\",\"sign_out\":\"Wyloguj się\"},\"application\":{\"fork_me\":\"Fork me on Github\",\"recent\":\"Ostatnie\",\"search\":\"Wyniki\",\"sponsers\":\"Sponsorzy\",\"sponsors_link\":\"Zobacz naszych wszystkich wspaniałych sponsorów &rarr;\",\"my_repositories\":\"Moje repozytoria\"},\"about\":{\"alpha\":\"To wciąż jest wersja alpha.\",\"messages\":{\"alpha\":\"Proszę <strong>nie</strong> traktuj tego jako stabilnej usługi. Wciąż nam wiele do tego brakuje! Więcej informacji znajdziesz <a href='https://github.com/travis-ci'>tutaj.</a>\"},\"join\":\"Pomóż i dołącz do nas!\",\"mailing_list\":\"Lista mailingowa\",\"repository\":\"Repozytorium\",\"twitter\":\"Twitter\"},\"mobile\":{\"author\":\"Autor\",\"build\":\"Build\",\"build_matrix\":\"Macierz Buildów\",\"commit\":\"Commit\",\"committer\":\"Komitujący\",\"compare\":\"Porównianie\",\"config\":\"Konfiguracja\",\"duration\":\"Czas trwania\",\"finished_at\":\"Zakończono\",\"job\":\"Zadanie\",\"log\":\"Log\"}},\"profiles\":{\"show\":{\"email\":\"Email\",\"github\":\"Github\",\"message\":{\"your_repos\":\"  Przesuń suwak poniżej, aby włączyć Travisa, dla twoich projektów, a następnie umieść swój kod na GitHubie.<br />\\n Aby testować swój kod przy użyciu wielu wersji Rubiego, zobacz\",\"config\":\"jak skonfigurować niestandardowe opcje builda\"},\"messages\":{\"notice\":\"Aby zacząć, przeczytaj nasz <a href=\\\"http://about.travis-ci.org/docs/user/getting-started/\\\">Przewodnik </a>.\\n  <small>Zajmie ci to tylko kilka minut.</small>\"},\"token\":\"Token\",\"your_repos\":\"Twoje repozytoria\"}},\"statistics\":{\"index\":{\"count\":\"Ilość\",\"repo_growth\":\"Przyrost repozytoriów\",\"total_projects\":\"Łącznie projektów/repozytoriów\",\"build_count\":\"Liczba buildów\",\"last_month\":\"ostatni miesiąc\",\"total_builds\":\"Łącznie Buildów\"}},\"date\":{\"abbr_day_names\":[\"nie\",\"pon\",\"wto\",\"śro\",\"czw\",\"pią\",\"sob\"],\"abbr_month_names\":[\"sty\",\"lut\",\"mar\",\"kwi\",\"maj\",\"cze\",\"lip\",\"sie\",\"wrz\",\"paź\",\"lis\",\"gru\"],\"day_names\":[\"niedziela\",\"poniedziałek\",\"wtorek\",\"środa\",\"czwartek\",\"piątek\",\"sobota\"],\"formats\":{\"default\":\"%d-%m-%Y\",\"long\":\"%B %d, %Y\",\"short\":\"%d %b\"},\"month_names\":[\"styczeń\",\"luty\",\"marzec\",\"kwiecień\",\"maj\",\"czerwiec\",\"lipiec\",\"sierpień\",\"wrzesień\",\"październik\",\"listopad\",\"grudzień\"],\"order\":[\"day\",\"month\",\"year\"]},\"errors\":{\"format\":\"%{attribute} %{message}\",\"messages\":{\"accepted\":\"musi zostać zaakceptowane\",\"blank\":\"nie może być puste\"}},\"locales\":{\"en\":\"English\",\"es\":\"Español\",\"ja\":\"日本語\",\"ru\":\"Русский\",\"fr\":\"Français\",\"nb\":\"Norsk Bokmål\",\"pl\":\"Polski\",\"nl\":\"Nederlands\",\"pt-BR\":\"português brasileiro\"}},\"pt-BR\":{\"admin\":{\"actions\":{\"create\":\"criar\",\"created\":\"criado\",\"delete\":\"deletar\",\"deleted\":\"deletado\",\"update\":\"atualizar\",\"updated\":\"atualizado\"},\"credentials\":{\"log_out\":\"Deslogar\"},\"dashboard\":{\"add_new\":\"Adicionar novo\",\"ago\":\"atrás\",\"last_used\":\"Última utilização\",\"model_name\":\"Nome do modelo\",\"modify\":\"Modificar\",\"name\":\"Dashboard\",\"pagename\":\"Administração do site\",\"records\":\"Registros\",\"show\":\"Mostrar\"},\"delete\":{\"confirmation\":\"Sim, tenho certeza\",\"flash_confirmation\":\"%{name} foi destruído com sucesso\"},\"flash\":{\"error\":\"%{name} falhou ao %{action}\",\"noaction\":\"Nenhuma ação foi tomada\",\"successful\":\"%{name} foi %{action} com sucesso\"},\"history\":{\"name\":\"Histórico\",\"no_activity\":\"Nenhuma Atividade\",\"page_name\":\"Histórico para %{name}\"},\"list\":{\"add_new\":\"Adicionar novo\",\"delete_action\":\"Deletar\",\"delete_selected\":\"Deletar selecionados\",\"edit_action\":\"Editar\",\"search\":\"Buscar\",\"select\":\"Selecionar %{name} para editar\",\"select_action\":\"Selecionar\",\"show_all\":\"Mostrar todos\"},\"new\":{\"basic_info\":\"Informações básicas\",\"cancel\":\"Cancelar\",\"chosen\":\"Escolhido %{name}\",\"chose_all\":\"Escolher todos\",\"clear_all\":\"Limpar todos\",\"many_chars\":\"caracteres ou menos.\",\"one_char\":\"caractere.\",\"optional\":\"Opcional\",\"required\":\"Requerido\",\"save\":\"Salvar\",\"save_and_add_another\":\"Salvar e adicionar outro\",\"save_and_edit\":\"Salvar e alterar\",\"select_choice\":\"Selecione e clique\"}},\"build\":{\"duration\":\"Duração\",\"finished_at\":\"Concluído em\",\"job\":\"Trabalho\"},\"builds\":{\"allowed_failures\":\"Falhas Permitidas\",\"author\":\"Autor\",\"branch\":\"Branch\",\"build_matrix\":\"Matriz de Build\",\"commit\":\"Commit\",\"committer\":\"Committer\",\"compare\":\"Comparar\",\"config\":\"Config\",\"duration\":\"Duração\",\"finished_at\":\"Concluído em\",\"message\":\"Mensagem\",\"messages\":{\"sponsored_by\":\"Esta série de testes foi executada em uma caixa de processos patrocinada por\"},\"name\":\"Build\",\"started_at\":\"Iniciou em\"},\"datetime\":{\"distance_in_words\":{\"hours_exact\":{\"one\":\"%{count} hora\",\"other\":\"%{count} horas\"},\"minutes_exact\":{\"one\":\"%{count} minuto\",\"other\":\"%{count} minutos\"},\"seconds_exact\":{\"one\":\"%{count} segundo\",\"other\":\"%{count} segundos\"}}},\"devise\":{\"confirmations\":{\"confirmed\":\"Sua conta foi confirmada com sucesso. Você agora está logado.\",\"send_instructions\":\"Você receberá um email com instruções de como confirmar sua conta em alguns minutos.\"},\"failure\":{\"inactive\":\"Sua conta ainda não foi ativada.\",\"invalid\":\"Email ou senha inválidos.\",\"invalid_token\":\"Token de autenticação inválido.\",\"locked\":\"Sua conta está trancada.\",\"timeout\":\"Sua sessão expirou, por favor faça seu login novamente.\",\"unauthenticated\":\"Você precisa fazer o login ou cadastrar-se antes de continuar.\",\"unconfirmed\":\"Você precisa confirmar sua conta antes de continuar.\"},\"mailer\":{\"confirmation_instructions\":{\"subject\":\"Instruções de confirmação\"},\"reset_password_instructions\":{\"subject\":\"Instruções de atualização de senha\"},\"unlock_instructions\":{\"subject\":\"Instruções de destrancamento\"}},\"passwords\":{\"send_instructions\":\"Você receberá um email com instruções de como atualizar sua senha em alguns minutos.\",\"updated\":\"Sua senha foi alterada com sucesso. Você agora está logado.\"},\"registrations\":{\"destroyed\":\"Tchau! Sua conta foi cancelada com sucesso. Esperamos vê-lo novamente em breve!\",\"signed_up\":\"Você se cadastrou com sucesso. Se ativada, uma confirmação foi enviada para seu email.\",\"updated\":\"Você atualizou sua conta com sucesso.\"},\"sessions\":{\"signed_in\":\"Logado com sucesso.\",\"signed_out\":\"Deslogado com sucesso.\"},\"unlocks\":{\"send_instructions\":\"Você receberá um email com instruções de como destrancar sua conta em alguns minutos.\",\"unlocked\":\"Sua conta foi destrancada com sucesso. Você agora está logado.\"}},\"errors\":{\"messages\":{\"already_confirmed\":\"já foi confirmado\",\"not_found\":\"não encontrado\",\"not_locked\":\"não estava trancado\"}},\"home\":{\"name\":\"home\"},\"jobs\":{\"allowed_failures\":\"Falhas Permitidas\",\"author\":\"Autor\",\"branch\":\"Branch\",\"build_matrix\":\"Matriz de Build\",\"commit\":\"Commit\",\"committer\":\"Committer\",\"compare\":\"Comparar\",\"config\":\"Config\",\"duration\":\"Duração\",\"finished_at\":\"Concluído em\",\"message\":\"Mensagem\",\"messages\":{\"sponsored_by\":\"Esta série de testes foi executada em uma caixa de processos patrocinada por\"},\"started_at\":\"Iniciou em\"},\"layouts\":{\"about\":{\"alpha\":\"Isto é um alpha.\",\"join\":\"Junte-se à nós e ajude!\",\"mailing_list\":\"Lista de email\",\"messages\":{\"alpha\":\"Por favor, <strong>não</strong> considere isto um serviço estável. Estamos muito longe disso! Mais informações <a href='https://github.com/travis-ci'>aqui.</a>\"},\"repository\":\"Repositório\",\"twitter\":\"Twitter\"},\"application\":{\"fork_me\":\"Faça fork no Github\",\"my_repositories\":\"Meus Repositórios\",\"recent\":\"Recentes\",\"search\":\"Buscar\",\"sponsers\":\"Patrocinadores\",\"sponsors_link\":\"Conheça todos os nossos patrocinadores &rarr;\"},\"mobile\":{\"author\":\"Autor\",\"build\":\"Build\",\"build_matrix\":\"Matriz de Build\",\"commit\":\"Commit\",\"committer\":\"Committer\",\"compare\":\"Comparar\",\"config\":\"Config\",\"duration\":\"Duração\",\"finished_at\":\"Concluído em\",\"job\":\"Trabalho\",\"log\":\"Log\"},\"top\":{\"admin\":\"Admin\",\"blog\":\"Blog\",\"docs\":\"Documentação\",\"github_login\":\"Logue com o Github\",\"home\":\"Home\",\"profile\":\"Perfil\",\"sign_out\":\"Sair\",\"stats\":\"Estatísticas\"}},\"locales\":{\"en\":\"English\",\"es\":\"Español\",\"fr\":\"Français\",\"ja\":\"日本語\",\"nb\":\"Norsk Bokmål\",\"nl\":\"Nederlands\",\"pl\":\"Polski\",\"ru\":\"Русский\",\"pt-BR\":\"português brasileiro\"},\"no_job\":\"Não há trabalhos\",\"profiles\":{\"show\":{\"email\":\"Email\",\"github\":\"Github\",\"message\":{\"config\":\"como configurar opções de build\",\"your_repos\":\"Use os botões abaixo para ligar ou desligar o hook de serviço do Travis para seus projetos, e então, faça um push para o Github.<br />Para testar com múltiplas versões do Ruby, leia\"},\"messages\":{\"notice\":\"Para começar, leia nosso <a href=\\\"http://about.travis-ci.org/docs/user/getting-started/\\\">Guia de início</a>. <small>Só leva alguns minutinhos.</small>\"},\"token\":\"Token\",\"update\":\"Atualizar\",\"update_locale\":\"Atualizar\",\"your_locale\":\"Sua língua\",\"your_repos\":\"Seus Repositórios\"}},\"queue\":\"Fila\",\"repositories\":{\"branch\":\"Branch\",\"commit\":\"Commit\",\"duration\":\"Duração\",\"finished_at\":\"Concluído em\",\"image_url\":\"URL da imagem\",\"markdown\":\"Markdown\",\"message\":\"Mensagem\",\"rdoc\":\"RDOC\",\"started_at\":\"Iniciou em\",\"tabs\":{\"branches\":\"Sumário do Branch\",\"build\":\"Build\",\"build_history\":\"Histórico de Build\",\"current\":\"Atual\",\"job\":\"Trabalho\"},\"textile\":\"Textile\"},\"repository\":{\"duration\":\"Duração\"},\"statistics\":{\"index\":{\"build_count\":\"Número de Builds\",\"count\":\"Número\",\"last_month\":\"último mês\",\"repo_growth\":\"Crescimento de Repositório\",\"total_builds\":\"Total de Builds\",\"total_projects\":\"Total de Projetos/Repositórios\"}},\"workers\":\"Processos\"},\"ru\":{\"admin\":{\"actions\":{\"create\":\"создать\",\"created\":\"создано\",\"delete\":\"удалить\",\"deleted\":\"удалено\",\"update\":\"обновить\",\"updated\":\"обновлено\"},\"credentials\":{\"log_out\":\"Выход\"},\"dashboard\":{\"add_new\":\"Добавить\",\"ago\":\"назад\",\"last_used\":\"Использовалось в последний раз\",\"model_name\":\"Имя модели\",\"modify\":\"Изменить\",\"name\":\"Панель управления\",\"pagename\":\"Управление сайтом\",\"records\":\"Записи\",\"show\":\"Показать\"},\"delete\":{\"confirmation\":\"Да, я уверен\",\"flash_confirmation\":\"%{name} успешно удалено\"},\"history\":{\"name\":\"История\",\"no_activity\":\"Нет активности\",\"page_name\":\"История %{name}\"},\"list\":{\"add_new\":\"Добавить\",\"delete_action\":\"Удалить\",\"delete_selected\":\"Удалить выбранные\",\"edit_action\":\"Редактировать\",\"search\":\"Поиск\",\"select\":\"Для редактирования выберите %{name}\",\"select_action\":\"Выбрать\",\"show_all\":\"Показать все\"},\"new\":{\"basic_info\":\"Основная информация\",\"cancel\":\"Отмена\",\"chosen\":\"Выбрано %{name}\",\"chose_all\":\"Выбрать все\",\"clear_all\":\"Очистить все\",\"one_char\":\"символ.\",\"optional\":\"Необязательно\",\"required\":\"Обязательно\",\"save\":\"Сохранить\",\"save_and_add_another\":\"Сохранить и добавить другое\",\"save_and_edit\":\"Сохранить и продолжить редактирование\",\"select_choice\":\"Выберите и кликните\",\"many_chars\":\"символов или меньше.\"},\"flash\":{\"error\":\"%{name} не удалось %{action}\",\"noaction\":\"Никаких действий не произведено\",\"successful\":\"%{name} было успешно %{action}\"}},\"build\":{\"duration\":\"Длительность\",\"finished_at\":\"Завершен\",\"job\":\"Задача\"},\"builds\":{\"allowed_failures\":\"Допустимые неудачи\",\"author\":\"Автор\",\"branch\":\"Ветка\",\"build_matrix\":\"Матрица\",\"commit\":\"Коммит\",\"committer\":\"Коммитер\",\"compare\":\"Дифф\",\"config\":\"Конфигурация\",\"duration\":\"Длительность\",\"finished_at\":\"Завершен\",\"message\":\"Комментарий\",\"messages\":{\"sponsored_by\":\"Эта серия тестов была запущена на машине, спонсируемой\"},\"name\":\"Билд\",\"started_at\":\"Начало\"},\"datetime\":{\"distance_in_words\":{\"hours_exact\":{\"one\":\"%{count} час\",\"few\":\"%{count} часа\",\"many\":\"%{count} часов\",\"other\":\"%{count} часа\"},\"minutes_exact\":{\"one\":\"%{count} минута\",\"few\":\"%{count} минуты\",\"many\":\"%{count} минут\",\"other\":\"%{count} минуты\"},\"seconds_exact\":{\"one\":\"%{count} секунда\",\"few\":\"%{count} секунды\",\"many\":\"%{count} секунд\",\"other\":\"%{count} секунды\"}}},\"devise\":{\"confirmations\":{\"confirmed\":\"Ваш аккаунт успешно подтвержден. Приветствуем!\",\"send_instructions\":\"В течении нескольких минут вы получите электронное письмо с инструкциями для прохождения процедуры подтверждения аккаунта.\"},\"failure\":{\"inactive\":\"Ваш аккаунт еще не активирован.\",\"invalid\":\"Ошибка в адресе почты или пароле.\",\"invalid_token\":\"Неправильный токен аутентификации.\",\"locked\":\"Ваш аккаунт заблокирован.\",\"timeout\":\"Сессия окончена. Для продолжения работы войдите снова.\",\"unauthenticated\":\"Вам нужно войти или зарегистрироваться.\",\"unconfirmed\":\"Вы должны сначала подтвердить свой аккаунт.\"},\"mailer\":{\"confirmation_instructions\":{\"subject\":\"Инструкции для подтверждению аккаунта\"},\"reset_password_instructions\":{\"subject\":\"Инструкции для сброса пароля\"},\"unlock_instructions\":{\"subject\":\"Инструкции для разблокирования аккаунта\"}},\"passwords\":{\"send_instructions\":\"В течении нескольких минут вы получите электронное письмо с инструкциями для сброса пароля.\",\"updated\":\"Ваш пароль успешно изменен. Приветствуем!\"},\"registrations\":{\"destroyed\":\"Ваш аккаунт был успешно удален. Живите долго и процветайте!\",\"signed_up\":\"Вы успешно прошли регистрацию. Инструкции для подтверждения аккаунта отправлены на ваш электронный адрес.\",\"updated\":\"Аккаунт успешно обновлен.\"},\"sessions\":{\"signed_in\":\"Приветствуем!\",\"signed_out\":\"Удачи!\"},\"unlocks\":{\"send_instructions\":\"В течении нескольких минут вы получите электронное письмо с инструкциям для разблокировния аккаунта.\",\"unlocked\":\"Ваш аккаунт успешно разблокирован. Приветствуем!\"}},\"errors\":{\"messages\":{\"already_confirmed\":\"уже подтвержден\",\"not_found\":\"не найден\",\"not_locked\":\"не заблокирован\"}},\"home\":{\"name\":\"Главная\"},\"jobs\":{\"allowed_failures\":\"Допустимые неудачи\",\"author\":\"Автор\",\"branch\":\"Ветка\",\"build_matrix\":\"Матрица\",\"commit\":\"Коммит\",\"committer\":\"Коммитер\",\"compare\":\"Сравнение\",\"config\":\"Конфигурация\",\"duration\":\"Длительность\",\"finished_at\":\"Завершен\",\"message\":\"Комментарий\",\"messages\":{\"sponsored_by\":\"Эта серия тестов была запущена на машине спонсируемой\"},\"started_at\":\"Начало\"},\"layouts\":{\"about\":{\"alpha\":\"Это альфа-версия\",\"join\":\"Присоединяйтесь к нам и помогайте!\",\"mailing_list\":\"Лист рассылки\",\"messages\":{\"alpha\":\"Пожалуйста, <strong>не</strong> считайте данный сервис стабильным. Мы еще очень далеки от стабильности! <a href='https://github.com/travis-ci'>Подробности</a>\"},\"repository\":\"Репозиторий\",\"twitter\":\"Twitter\"},\"application\":{\"fork_me\":\"Fork me on Github\",\"my_repositories\":\"Мои репозитории\",\"recent\":\"Недавние\",\"search\":\"Поиск\",\"sponsers\":\"Спонсоры\",\"sponsors_link\":\"Список всех наших замечательных спонсоров &rarr;\"},\"mobile\":{\"author\":\"Автор\",\"build\":\"Сборка\",\"build_matrix\":\"Матрица сборок\",\"commit\":\"Коммит\",\"committer\":\"Коммитер\",\"compare\":\"Сравнение\",\"config\":\"Конфигурация\",\"duration\":\"Длительность\",\"finished_at\":\"Завершен\",\"job\":\"Задача\",\"log\":\"Журнал\"},\"top\":{\"admin\":\"Управление\",\"blog\":\"Блог\",\"docs\":\"Документация\",\"github_login\":\"Войти через Github\",\"home\":\"Главная\",\"profile\":\"Профиль\",\"sign_out\":\"Выход\",\"stats\":\"Статистика\"}},\"no_job\":\"Очередь пуста\",\"profiles\":{\"show\":{\"email\":\"Электронная почта\",\"github\":\"Github\",\"message\":{\"config\":\"как настроить специальные опции билда\",\"your_repos\":\"Используйте переключатели, чтобы включить Travis service hook для вашего проекта, а потом отправьте код на GitHub.<br />\\nДля тестирования на нескольких версиях Ruby смотрите\"},\"messages\":{\"notice\":\"Перед началом, пожалуйста, прочтите <a href=\\\"http://about.travis-ci.org/docs/user/getting-started/\\\">Руководство для быстрого старта</a>. <small>Это займет всего несколько минут.</small>\"},\"token\":\"Токен\",\"update\":\"Обновить\",\"update_locale\":\"Обновить\",\"your_locale\":\"Ваш язык\",\"your_repos\":\"Ваши репозитории\"}},\"queue\":\"Очередь\",\"repositories\":{\"branch\":\"Ветка\",\"commit\":\"Коммит\",\"duration\":\"Длительность\",\"finished_at\":\"Завершен\",\"image_url\":\"URL изображения\",\"markdown\":\"Markdown\",\"message\":\"Комментарий\",\"rdoc\":\"RDOC\",\"started_at\":\"Начало\",\"tabs\":{\"branches\":\"Статус веток\",\"build\":\"Билд\",\"build_history\":\"История\",\"current\":\"Текущий\",\"job\":\"Задача\"},\"textile\":\"Textile\"},\"repository\":{\"duration\":\"Длительность\"},\"statistics\":{\"index\":{\"build_count\":\"Количество билдов\",\"count\":\"Количество\",\"last_month\":\"прошлый месяц\",\"repo_growth\":\"Рост числа репозиториев\",\"total_builds\":\"Всего билдов\",\"total_projects\":\"Всего проектов/репозиториев\"}},\"workers\":\"Машины\",\"locales\":{\"en\":\"English\",\"es\":\"Español\",\"ja\":\"日本語\",\"ru\":\"Русский\",\"fr\":\"Français\",\"nb\":\"Norsk Bokmål\",\"pl\":\"Polski\",\"nl\":\"Nederlands\",\"pt-BR\":\"português brasileiro\"}}};\n\n\n})();\n//@ sourceURL=i18n");minispade.register('locales', "(function() {window.I18n.translations = {\"ca\":{\"locales\":{\"en\":\"English\",\"es\":\"Español\",\"fr\":\"Français\",\"ja\":\"日本語\",\"nb\":\"Norsk Bokmål\",\"nl\":\"Nederlands\",\"pl\":\"Polski\",\"pt-BR\":\"português brasileiro\",\"ru\":\"Русский\"}},\"en\":{\"errors\":{\"messages\":{\"not_found\":\"not found\",\"already_confirmed\":\"was already confirmed\",\"not_locked\":\"was not locked\"}},\"devise\":{\"failure\":{\"unauthenticated\":\"You need to sign in or sign up before continuing.\",\"unconfirmed\":\"You have to confirm your account before continuing.\",\"locked\":\"Your account is locked.\",\"invalid\":\"Invalid email or password.\",\"invalid_token\":\"Invalid authentication token.\",\"timeout\":\"Your session expired, please sign in again to continue.\",\"inactive\":\"Your account was not activated yet.\"},\"sessions\":{\"signed_in\":\"Signed in successfully.\",\"signed_out\":\"Signed out successfully.\"},\"passwords\":{\"send_instructions\":\"You will receive an email with instructions about how to reset your password in a few minutes.\",\"updated\":\"Your password was changed successfully. You are now signed in.\"},\"confirmations\":{\"send_instructions\":\"You will receive an email with instructions about how to confirm your account in a few minutes.\",\"confirmed\":\"Your account was successfully confirmed. You are now signed in.\"},\"registrations\":{\"signed_up\":\"You have signed up successfully. If enabled, a confirmation was sent to your e-mail.\",\"updated\":\"You updated your account successfully.\",\"destroyed\":\"Bye! Your account was successfully cancelled. We hope to see you again soon.\"},\"unlocks\":{\"send_instructions\":\"You will receive an email with instructions about how to unlock your account in a few minutes.\",\"unlocked\":\"Your account was successfully unlocked. You are now signed in.\"},\"mailer\":{\"confirmation_instructions\":{\"subject\":\"Confirmation instructions\"},\"reset_password_instructions\":{\"subject\":\"Reset password instructions\"},\"unlock_instructions\":{\"subject\":\"Unlock Instructions\"}}},\"datetime\":{\"distance_in_words\":{\"hours_exact\":{\"one\":\"%{count} hour\",\"other\":\"%{count} hours\"},\"minutes_exact\":{\"one\":\"%{count} minute\",\"other\":\"%{count} minutes\"},\"seconds_exact\":{\"one\":\"%{count} second\",\"other\":\"%{count} seconds\"}}},\"workers\":\"Workers\",\"queue\":\"Queue\",\"no_job\":\"There are no jobs\",\"repositories\":{\"branch\":\"Branch\",\"image_url\":\"Image URL\",\"markdown\":\"Markdown\",\"textile\":\"Textile\",\"rdoc\":\"RDOC\",\"commit\":\"Commit\",\"message\":\"Message\",\"started_at\":\"Started\",\"duration\":\"Duration\",\"finished_at\":\"Finished\",\"tabs\":{\"current\":\"Current\",\"build_history\":\"Build History\",\"branches\":\"Branch Summary\",\"pull_requests\":\"Pull Requests\",\"build\":\"Build\",\"job\":\"Job\"}},\"build\":{\"job\":\"Job\",\"duration\":\"Duration\",\"finished_at\":\"Finished\"},\"jobs\":{\"messages\":{\"sponsored_by\":\"This test suite was run on a worker box sponsored by\"},\"build_matrix\":\"Build Matrix\",\"allowed_failures\":\"Allowed Failures\",\"author\":\"Author\",\"config\":\"Config\",\"compare\":\"Compare\",\"committer\":\"Committer\",\"branch\":\"Branch\",\"commit\":\"Commit\",\"message\":\"Message\",\"started_at\":\"Started\",\"duration\":\"Duration\",\"finished_at\":\"Finished\"},\"builds\":{\"name\":\"Build\",\"messages\":{\"sponsored_by\":\"This test suite was run on a worker box sponsored by\"},\"build_matrix\":\"Build Matrix\",\"allowed_failures\":\"Allowed Failures\",\"author\":\"Author\",\"config\":\"Config\",\"compare\":\"Compare\",\"committer\":\"Committer\",\"branch\":\"Branch\",\"commit\":\"Commit\",\"message\":\"Message\",\"started_at\":\"Started\",\"duration\":\"Duration\",\"finished_at\":\"Finished\",\"show_more\":\"Show more\"},\"layouts\":{\"top\":{\"home\":\"Home\",\"blog\":\"Blog\",\"docs\":\"Docs\",\"stats\":\"Stats\",\"github_login\":\"Sign in with Github\",\"profile\":\"Profile\",\"sign_out\":\"Sign Out\",\"admin\":\"Admin\"},\"application\":{\"fork_me\":\"Fork me on Github\",\"recent\":\"Recent\",\"search\":\"Search\",\"sponsers\":\"Sponsors\",\"sponsors_link\":\"See all of our amazing sponsors &rarr;\",\"my_repositories\":\"My Repositories\"},\"about\":{\"alpha\":\"This stuff is alpha.\",\"messages\":{\"alpha\":\"Please do <strong>not</strong> consider this a stable service. We're still far from that! More info <a href='https://github.com/travis-ci'>here.</a>\"},\"join\":\"Join us and help!\",\"mailing_list\":\"Mailing List\",\"repository\":\"Repository\",\"twitter\":\"Twitter\"},\"mobile\":{\"author\":\"Author\",\"build\":\"Build\",\"build_matrix\":\"Build Matrix\",\"commit\":\"Commit\",\"committer\":\"Committer\",\"compare\":\"Compare\",\"config\":\"Config\",\"duration\":\"Duration\",\"finished_at\":\"Finished at\",\"job\":\"Job\",\"log\":\"Log\"}},\"profiles\":{\"show\":{\"email\":\"Email\",\"github\":\"Github\",\"message\":{\"your_repos\":\"  Flick the switches below to turn on the Travis service hook for your projects, then push to GitHub.<br />\\n  To test against multiple rubies, see\",\"config\":\"how to configure custom build options\"},\"messages\":{\"notice\":\"To get started, please read our <a href=\\\"http://about.travis-ci.org/docs/user/getting-started/\\\">Getting Started guide</a>.\\n  <small>It will only take a couple of minutes.</small>\"},\"token\":\"Token\",\"your_repos\":\"Your Repositories\",\"update\":\"Update\",\"update_locale\":\"Update\",\"your_locale\":\"Your Locale\"}},\"statistics\":{\"index\":{\"count\":\"Count\",\"repo_growth\":\"Repository Growth\",\"total_projects\":\"Total Projects/Repositories\",\"build_count\":\"Build Count\",\"last_month\":\"last month\",\"total_builds\":\"Total Builds\"}},\"locales\":{\"en\":\"English\",\"es\":\"Español\",\"fr\":\"Français\",\"ja\":\"日本語\",\"nb\":\"Norsk Bokmål\",\"pl\":\"Polski\",\"ru\":\"Русский\",\"nl\":\"Nederlands\",\"pt-BR\":\"português brasileiro\"}},\"es\":{\"datetime\":{\"distance_in_words\":{\"hours_exact\":{\"one\":\"%{count} hora\",\"other\":\"%{count} horas\"},\"minutes_exact\":{\"one\":\"%{count} minuto\",\"other\":\"%{count} minutos\"},\"seconds_exact\":{\"one\":\"%{count} segundo\",\"other\":\"%{count} segundos\"}}},\"workers\":\"Procesos\",\"queue\":\"Cola\",\"no_job\":\"No hay trabajos\",\"repositories\":{\"branch\":\"Rama\",\"image_url\":\"Imagen URL\",\"markdown\":\"Markdown\",\"textile\":\"Textile\",\"rdoc\":\"RDOC\",\"commit\":\"Commit\",\"message\":\"Mensaje\",\"started_at\":\"Iniciado\",\"duration\":\"Duración\",\"finished_at\":\"Finalizado\",\"tabs\":{\"current\":\"Actual\",\"build_history\":\"Histórico\",\"branches\":\"Ramas\",\"build\":\"Builds\",\"job\":\"Trabajo\"}},\"build\":{\"job\":\"Trabajo\",\"duration\":\"Duración\",\"finished_at\":\"Finalizado\"},\"jobs\":{\"messages\":{\"sponsored_by\":\"Esta serie de tests han sido ejecutados en una caja de Proceso patrocinada por\"},\"build_matrix\":\"Matriz de Builds\",\"allowed_failures\":\"Fallos Permitidos\",\"author\":\"Autor\",\"config\":\"Configuración\",\"compare\":\"Comparar\",\"committer\":\"Committer\",\"branch\":\"Rama\",\"commit\":\"Commit\",\"message\":\"Mensaje\",\"started_at\":\"Iniciado\",\"duration\":\"Duración\",\"finished_at\":\"Finalizado\",\"sponsored_by\":\"Patrocinado por\"},\"builds\":{\"name\":\"Build\",\"messages\":{\"sponsored_by\":\"Esta serie de tests han sido ejecutados en una caja de Proceso patrocinada por\"},\"build_matrix\":\"Matriz de Builds\",\"allowed_failures\":\"Fallos Permitidos\",\"author\":\"Autor\",\"config\":\"Configuración\",\"compare\":\"Comparar\",\"committer\":\"Committer\",\"branch\":\"Rama\",\"commit\":\"Commit\",\"message\":\"Mensaje\",\"started_at\":\"Iniciado\",\"duration\":\"Duración\",\"finished_at\":\"Finalizado\"},\"layouts\":{\"top\":{\"home\":\"Inicio\",\"blog\":\"Blog\",\"docs\":\"Documentación\",\"stats\":\"Estadísticas\",\"github_login\":\"Iniciar sesión con Github\",\"profile\":\"Perfil\",\"sign_out\":\"Desconectar\",\"admin\":\"Admin\"},\"application\":{\"fork_me\":\"Hazme un Fork en Github\",\"recent\":\"Reciente\",\"search\":\"Buscar\",\"sponsers\":\"Patrocinadores\",\"sponsors_link\":\"Ver todos nuestros patrocinadores &rarr;\",\"my_repositories\":\"Mis Repositorios\"},\"about\":{\"alpha\":\"Esto es alpha.\",\"messages\":{\"alpha\":\"Por favor <strong>no</strong> considereis esto un servicio estable. Estamos estamos aún lejos de ello! Más información <a href='https://github.com/travis-ci'>aquí.</a>\"},\"join\":\"Únetenos y ayudanos!\",\"mailing_list\":\"Lista de Correos\",\"repository\":\"Repositorio\",\"twitter\":\"Twitter\"}},\"profiles\":{\"show\":{\"email\":\"Correo electrónico\",\"github\":\"Github\",\"message\":{\"your_repos\":\"  Activa los interruptores para inicial el  Travis service hook para tus proyectos, y haz un Push en GitHub.<br />\\n  Para probar varias versiones de ruby, mira\",\"config\":\"como configurar tus propias opciones para el Build\"},\"messages\":{\"notice\":\"Para comenzar, por favor lee nuestra <a href=\\\"http://about.travis-ci.org/docs/user/getting-started/\\\">Guía de Inicio </a>.\\n  <small>Solo tomará unos pocos minutos.</small>\"},\"token\":\"Token\",\"your_repos\":\"Tus repositorios\",\"update\":\"Actualizar\",\"update_locale\":\"Actualizar\",\"your_locale\":\"Tu Idioma\"}},\"statistics\":{\"index\":{\"count\":\"Número\",\"repo_growth\":\"Crecimiento de Repositorios\",\"total_projects\":\"Total de Proyectos/Repositorios\",\"build_count\":\"Número de Builds\",\"last_month\":\"mes anterior\",\"total_builds\":\"Total de Builds\"}},\"locales\":{\"en\":\"English\",\"es\":\"Español\",\"fr\":\"Français\",\"ja\":\"日本語\",\"nb\":\"Norsk Bokmål\",\"pl\":\"Polski\",\"ru\":\"Русский\",\"nl\":\"Nederlands\",\"pt-BR\":\"português brasileiro\"}},\"fr\":{\"datetime\":{\"distance_in_words\":{\"hours_exact\":{\"one\":\"%{count} heure\",\"other\":\"%{count} heures\"},\"minutes_exact\":{\"one\":\"%{count} minute\",\"other\":\"%{count} minutes\"},\"seconds_exact\":{\"one\":\"%{count} seconde\",\"other\":\"%{count} secondes\"}}},\"workers\":\"Processus\",\"queue\":\"File\",\"no_job\":\"Pas de tâches\",\"repositories\":{\"branch\":\"Branche\",\"image_url\":\"Image\",\"markdown\":\"Markdown\",\"textile\":\"Textile\",\"rdoc\":\"RDOC\",\"commit\":\"Commit\",\"message\":\"Message\",\"started_at\":\"Commencé\",\"duration\":\"Durée\",\"finished_at\":\"Terminé\",\"tabs\":{\"current\":\"Actuel\",\"build_history\":\"Historique des tâches\",\"branches\":\"Résumé des branches\",\"build\":\"Construction\",\"job\":\"Tâche\"}},\"build\":{\"job\":\"Tâche\",\"duration\":\"Durée\",\"finished_at\":\"Terminé\"},\"jobs\":{\"messages\":{\"sponsored_by\":\"Cette série de tests a été exécutée sur une machine sponsorisée par\"},\"build_matrix\":\"Matrice des versions\",\"allowed_failures\":\"Échecs autorisés\",\"author\":\"Auteur\",\"config\":\"Config\",\"compare\":\"Comparer\",\"committer\":\"Committeur\",\"branch\":\"Branche\",\"commit\":\"Commit\",\"message\":\"Message\",\"started_at\":\"Commencé\",\"duration\":\"Durée\",\"finished_at\":\"Terminé\",\"sponsored_by\":\"Cette série de tests a été exécutée sur une machine sponsorisée par\"},\"builds\":{\"name\":\"Version\",\"messages\":{\"sponsored_by\":\"Cette série de tests a été exécutée sur une machine sponsorisée par\"},\"build_matrix\":\"Matrice des versions\",\"allowed_failures\":\"Échecs autorisés\",\"author\":\"Auteur\",\"config\":\"Config\",\"compare\":\"Comparer\",\"committer\":\"Committeur\",\"branch\":\"Branche\",\"commit\":\"Commit\",\"message\":\"Message\",\"started_at\":\"Commencé\",\"duration\":\"Durée\",\"finished_at\":\"Terminé\"},\"layouts\":{\"top\":{\"home\":\"Accueil\",\"blog\":\"Blog\",\"docs\":\"Documentation\",\"stats\":\"Statistiques\",\"github_login\":\"Connection Github\",\"profile\":\"Profil\",\"sign_out\":\"Déconnection\",\"admin\":\"Admin\"},\"application\":{\"fork_me\":\"Faites un Fork sur Github\",\"recent\":\"Récent\",\"search\":\"Chercher\",\"sponsers\":\"Sponsors\",\"sponsors_link\":\"Voir tous nos extraordinaire sponsors &rarr;\",\"my_repositories\":\"Mes dépôts\"},\"about\":{\"alpha\":\"Ceci est en alpha.\",\"messages\":{\"alpha\":\"S'il vous plaît ne considérez <strong>pas</strong> ce service comme étant stable. Nous sommes loin de ça! Plus d'infos <a href='https://github.com/travis-ci'>ici.</a>\"},\"join\":\"Joignez-vous à nous et aidez-nous!\",\"mailing_list\":\"Liste de distribution\",\"repository\":\"Dépôt\",\"twitter\":\"Twitter\"},\"mobile\":{\"author\":\"Auteur\",\"build\":\"Version\",\"build_matrix\":\"Matrice des versions\",\"commit\":\"Commit\",\"committer\":\"Committeur\",\"compare\":\"Comparer\",\"config\":\"Config\",\"duration\":\"Durée\",\"finished_at\":\"Terminé à\",\"job\":\"Tâche\",\"log\":\"Journal\"}},\"profiles\":{\"show\":{\"github\":\"Github\",\"message\":{\"your_repos\":\"Utilisez les boutons ci-dessous pour activer Travis sur vos projets puis déployez sur GitHub.<br />\\nPour tester sur plus de versions de ruby, voir\",\"config\":\"comment configurer des options de version personnalisées\"},\"messages\":{\"notice\":\"Pour commencer, veuillez lire notre <a href=\\\"http://about.travis-ci.org/docs/user/getting-started/\\\">guide de démarrage</a>.\\n <small>Cela ne vous prendra que quelques minutes.</small>\"},\"token\":\"Jeton\",\"your_repos\":\"Vos dépôts\",\"email\":\"Courriel\",\"update\":\"Modifier\",\"update_locale\":\"Modifier\",\"your_locale\":\"Votre langue\"}},\"statistics\":{\"index\":{\"count\":\"Décompte\",\"repo_growth\":\"Croissance de dépôt\",\"total_projects\":\"Total des projets/dépôts\",\"build_count\":\"Décompte des versions\",\"last_month\":\"mois dernier\",\"total_builds\":\"Total des versions\"}},\"admin\":{\"actions\":{\"create\":\"créer\",\"created\":\"créé\",\"delete\":\"supprimer\",\"deleted\":\"supprimé\",\"update\":\"mise à jour\",\"updated\":\"mis à jour\"},\"credentials\":{\"log_out\":\"Déconnection\"},\"delete\":{\"confirmation\":\"Oui, je suis sure\",\"flash_confirmation\":\"%{name} a été détruit avec succès\"},\"flash\":{\"error\":\"%{name} n'a pas pu être %{action}\",\"noaction\":\"Aucune action n'a été entreprise\",\"successful\":\"%{name} a réussi à %{action}\"},\"history\":{\"name\":\"Historique\",\"no_activity\":\"Aucune activité\",\"page_name\":\"Historique pour %{name}\"},\"list\":{\"add_new\":\"Ajouter un nouveau\",\"delete_action\":\"Supprimer\",\"delete_selected\":\"Supprimer la sélection\",\"edit_action\":\"Modifier\",\"search\":\"Rechercher\",\"select\":\"Sélectionner le %{name} à modifier\",\"select_action\":\"Sélectionner\",\"show_all\":\"Montrer tout\"},\"new\":{\"basic_info\":\"Information de base\",\"cancel\":\"Annuler\",\"chosen\":\"%{name} choisi\",\"chose_all\":\"Choisir tout\",\"clear_all\":\"Déselectionner tout\",\"many_chars\":\"caractères ou moins\",\"one_char\":\"caractère.\",\"optional\":\"Optionnel\",\"required\":\"Requis\",\"save\":\"Sauvegarder\",\"save_and_add_another\":\"Sauvegarder et en ajouter un autre\",\"save_and_edit\":\"Sauvegarder et modifier\",\"select_choice\":\"Faites vos choix et cliquez\"},\"dashboard\":{\"add_new\":\"Ajouter un nouveau\",\"last_used\":\"Dernière utilisation\",\"model_name\":\"Nom du modèle\",\"modify\":\"Modification\",\"name\":\"Tableau de bord\",\"pagename\":\"Administration du site\",\"records\":\"Enregistrements\",\"show\":\"Voir\",\"ago\":\"plus tôt\"}},\"home\":{\"name\":\"accueil\"},\"repository\":{\"duration\":\"Durée\"},\"devise\":{\"confirmations\":{\"confirmed\":\"Votre compte a été crée avec succès. Vous être maintenant connecté.\",\"send_instructions\":\"Vous allez recevoir un courriel avec les instructions de confirmation de votre compte dans quelques minutes.\"},\"failure\":{\"inactive\":\"Votre compte n'a pas encore été activé.\",\"invalid\":\"Adresse courriel ou mot de passe invalide.\",\"invalid_token\":\"Jeton d'authentification invalide.\",\"locked\":\"Votre compte est bloqué.\",\"timeout\":\"Votre session est expirée, veuillez vous reconnecter pour continuer.\",\"unauthenticated\":\"Vous devez vous connecter ou vous enregistrer afin de continuer\",\"unconfirmed\":\"Vous devez confirmer votre compte avant de continuer.\"},\"mailer\":{\"confirmation_instructions\":{\"subject\":\"Instructions de confirmations\"},\"reset_password_instructions\":{\"subject\":\"Instruction de remise à zéro du mot de passe\"},\"unlock_instructions\":{\"subject\":\"Instruction de débloquage\"}},\"passwords\":{\"send_instructions\":\"Vous recevrez un courriel avec les instructions de remise à zéro du mot de passe dans quelques minutes.\",\"updated\":\"Votre mot de passe a été changé avec succès. Vous êtes maintenant connecté.\"},\"registrations\":{\"destroyed\":\"Au revoir! Votre compte a été annulé avec succès. Nous espérons vous revoir bientôt.\",\"signed_up\":\"Vous êtes enregistré avec succès. Si activé, une confirmation vous a été envoyé par courriel.\",\"updated\":\"Votre compte a été mis a jour avec succès\"},\"sessions\":{\"signed_in\":\"Connecté avec succès\",\"signed_out\":\"Déconnecté avec succès\"},\"unlocks\":{\"send_instructions\":\"Vous recevrez un courriel contenant les instructions pour débloquer votre compte dans quelques minutes.\",\"unlocked\":\"Votre compte a été débloqué avec succès.\"}},\"errors\":{\"messages\":{\"already_confirmed\":\"étais déja confirmé\",\"not_found\":\"n'a pas été trouvé\",\"not_locked\":\"n'étais pas bloqué\"}},\"locales\":{\"en\":\"English\",\"es\":\"Español\",\"ja\":\"日本語\",\"ru\":\"Русский\",\"fr\":\"Français\",\"nb\":\"Norsk Bokmål\",\"pl\":\"Polski\",\"nl\":\"Nederlands\",\"pt-BR\":\"português brasileiro\"}},\"ja\":{\"workers\":\"ワーカー\",\"queue\":\"キュー\",\"no_job\":\"ジョブはありません\",\"repositories\":{\"branch\":\"ブランチ\",\"image_url\":\"画像URL\",\"markdown\":\".md\",\"textile\":\".textile\",\"rdoc\":\".rdoc\",\"commit\":\"コミット\",\"message\":\"メッセージ\",\"started_at\":\"開始時刻\",\"duration\":\"処理時間\",\"finished_at\":\"終了時刻\",\"tabs\":{\"current\":\"最新\",\"build_history\":\"ビルド履歴\",\"branches\":\"ブランチまとめ\",\"build\":\"ビルド\",\"job\":\"ジョブ\"}},\"build\":{\"job\":\"ジョブ\",\"duration\":\"処理時間\",\"finished_at\":\"終了時刻\"},\"jobs\":{\"messages\":{\"sponsored_by\":\"このテストは以下のスポンサーの協力で行いました。\"},\"build_matrix\":\"ビルドマトリクス\",\"allowed_failures\":\"失敗許容範囲内\",\"author\":\"制作者\",\"config\":\"設定\",\"compare\":\"比較\",\"committer\":\"コミット者\",\"branch\":\"ブランチ\",\"commit\":\"コミット\",\"message\":\"メッセージ\",\"started_at\":\"開始時刻\",\"duration\":\"処理時間\",\"finished_at\":\"終了時刻\"},\"builds\":{\"name\":\"ビルド\",\"messages\":{\"sponsored_by\":\"このテストは以下のスポンサーの協力で行いました。\"},\"build_matrix\":\"失敗許容範囲外\",\"allowed_failures\":\"失敗許容範囲内\",\"author\":\"制作者\",\"config\":\"設定\",\"compare\":\"比較\",\"committer\":\"コミット者\",\"branch\":\"ブランチ\",\"commit\":\"コミット\",\"message\":\"メッセージ\",\"started_at\":\"開始時刻\",\"duration\":\"処理時間\",\"finished_at\":\"終了時刻\"},\"layouts\":{\"about\":{\"alpha\":\"まだアルファですよ！\",\"join\":\"参加してみよう！\",\"mailing_list\":\"メールリスト\",\"messages\":{\"alpha\":\"Travis-ciは安定したサービスまで後一歩！詳しくは<a href='https://github.com/travis-ci'>こちら</a>\"},\"repository\":\"リポジトリ\",\"twitter\":\"ツイッター\"},\"application\":{\"fork_me\":\"Githubでフォークしよう\",\"my_repositories\":\"マイリポジトリ\",\"recent\":\"最近\",\"search\":\"検索\",\"sponsers\":\"スポンサー\",\"sponsors_link\":\"スポンサーをもっと見る &rarr;\"},\"top\":{\"blog\":\"ブログ\",\"docs\":\"Travisとは？\",\"github_login\":\"Githubでログイン\",\"home\":\"ホーム\",\"profile\":\"プロフィール\",\"sign_out\":\"ログアウト\",\"stats\":\"統計\",\"admin\":\"管理\"},\"mobile\":{\"author\":\"制作者\",\"build\":\"ビルド\",\"build_matrix\":\"ビルドマトリクス\",\"commit\":\"コミット\",\"committer\":\"コミット者\",\"compare\":\"比較\",\"config\":\"設定\",\"duration\":\"処理時間\",\"finished_at\":\"終了時刻\",\"job\":\"ジョブ\",\"log\":\"ログ\"}},\"profiles\":{\"show\":{\"github\":\"Github\",\"email\":\"メール\",\"message\":{\"config\":\"詳細設定\",\"your_repos\":\"以下のスイッチを設定し、Travis-ciを有効にします。Githubへプッシュしたらビルドは自動的に開始します。複数バーションや細かい設定はこちらへ：\"},\"messages\":{\"notice\":\"まずは<a href=\\\"http://about.travis-ci.org/docs/user/getting-started/\\\">Travisのはじめ方</a>を参照してください。\"},\"token\":\"トークン\",\"your_repos\":\"リポジトリ\",\"update\":\"更新\",\"update_locale\":\"更新\",\"your_locale\":\"言語設定\"}},\"statistics\":{\"index\":{\"build_count\":\"ビルド数\",\"count\":\"数\",\"last_month\":\"先月\",\"repo_growth\":\"リポジトリ\",\"total_builds\":\"合計ビルド数\",\"total_projects\":\"合計リポジトリ\"}},\"locales\":{\"en\":\"English\",\"es\":\"Español\",\"fr\":\"Français\",\"ja\":\"日本語\",\"nb\":\"Norsk Bokmål\",\"pl\":\"Polski\",\"ru\":\"Русский\",\"nl\":\"Nederlands\",\"pt-BR\":\"português brasileiro\"}},\"nb\":{\"admin\":{\"actions\":{\"create\":\"opprett\",\"created\":\"opprettet\",\"delete\":\"slett\",\"deleted\":\"slettet\",\"update\":\"oppdater\",\"updated\":\"oppdatert\"},\"credentials\":{\"log_out\":\"Logg ut\"},\"dashboard\":{\"add_new\":\"Legg til ny\",\"ago\":\"siden\",\"last_used\":\"Sist brukt\",\"model_name\":\"Modell\",\"modify\":\"Rediger\",\"name\":\"Dashbord\",\"pagename\":\"Nettstedsadministrasjon\",\"records\":\"Oppføringer\",\"show\":\"Vis\"},\"delete\":{\"confirmation\":\"Ja, jeg er sikker\",\"flash_confirmation\":\"%{name} ble slettet\"},\"flash\":{\"error\":\"%{name} kunne ikke bli %{action}\",\"noaction\":\"Ingen handlinger ble utført\",\"successful\":\"%{name} ble %{action}\"},\"history\":{\"name\":\"Logg\",\"no_activity\":\"Ingen aktivitet\",\"page_name\":\"Logg for %{name}\"},\"list\":{\"add_new\":\"Legg til ny\",\"delete_action\":\"Slett\",\"delete_selected\":\"Slett valgte\",\"edit_action\":\"Rediger\",\"search\":\"Søk\",\"select\":\"Velg %{name} for å redigere\",\"select_action\":\"Velg\",\"show_all\":\"Vis alle \"},\"new\":{\"basic_info\":\"Basisinformasjon\",\"cancel\":\"Avbryt\",\"chosen\":\"Valgt %{name}\",\"chose_all\":\"Velg alle\",\"clear_all\":\"Fjern alle\",\"many_chars\":\"eller færre tegn.\",\"one_char\":\"tegn.\",\"optional\":\"Valgfri\",\"required\":\"Påkrevd\",\"save\":\"Lagre\",\"save_and_add_another\":\"Lagre og legg til ny\",\"save_and_edit\":\"Lagre og rediger\",\"select_choice\":\"Kryss av for dine valg og klikk\"}},\"build\":{\"duration\":\"Varighet\",\"finished_at\":\"Fullført\",\"job\":\"Jobb\"},\"builds\":{\"allowed_failures\":\"Tillatte feil\",\"author\":\"Forfatter\",\"branch\":\"Gren\",\"build_matrix\":\"Jobbmatrise\",\"commit\":\"Innsending\",\"committer\":\"Innsender\",\"compare\":\"Sammenlign\",\"config\":\"Oppsett\",\"duration\":\"Varighet\",\"finished_at\":\"Fullført\",\"message\":\"Beskrivelse\",\"messages\":{\"sponsored_by\":\"Denne testen ble kjørt på en maskin sponset av\"},\"name\":\"Jobb\",\"started_at\":\"Startet\"},\"datetime\":{\"distance_in_words\":{\"hours_exact\":{\"one\":\"%{count} time\",\"other\":\"%{count} timer\"},\"minutes_exact\":{\"one\":\"%{count} minutt\",\"other\":\"%{count} minutter\"},\"seconds_exact\":{\"one\":\"%{count} sekund\",\"other\":\"%{count} sekunder\"}}},\"devise\":{\"confirmations\":{\"confirmed\":\"Din konto er aktivert og du er nå innlogget.\",\"send_instructions\":\"Om noen få minutter så vil du få en e-post med informasjon om hvordan du bekrefter kontoen din.\"},\"failure\":{\"inactive\":\"Kontoen din har ikke blitt aktivert enda.\",\"invalid\":\"Ugyldig e-post eller passord.\",\"invalid_token\":\"Ugyldig autentiseringskode.\",\"locked\":\"Kontoen din er låst.\",\"timeout\":\"Du ble logget ut siden på grunn av mangel på aktivitet, vennligst logg inn på nytt.\",\"unauthenticated\":\"Du må logge inn eller registrere deg for å fortsette.\",\"unconfirmed\":\"Du må bekrefte kontoen din før du kan fortsette.\"},\"mailer\":{\"confirmation_instructions\":{\"subject\":\"Bekreftelsesinformasjon\"},\"reset_password_instructions\":{\"subject\":\"Instruksjoner for å få nytt passord\"},\"unlock_instructions\":{\"subject\":\"Opplåsningsinstruksjoner\"}},\"passwords\":{\"send_instructions\":\"Om noen få minutter så vil du få en epost med informasjon om hvordan du kan få et nytt passord.\",\"updated\":\"Passordet ditt ble endret, og du er logget inn.\"},\"registrations\":{\"destroyed\":\"Adjø! Kontoen din ble kansellert. Vi håper vi ser deg igjen snart.\",\"signed_up\":\"Du er nå registrert.\",\"updated\":\"Kontoen din ble oppdatert.\"},\"sessions\":{\"signed_in\":\"Du er nå logget inn.\",\"signed_out\":\"Du er nå logget ut.\"},\"unlocks\":{\"send_instructions\":\"Om noen få minutter så kommer du til å få en e-post med informasjon om hvordan du kan låse opp kontoen din.\",\"unlocked\":\"Kontoen din ble låst opp, og du er nå logget inn igjen.\"}},\"errors\":{\"messages\":{\"already_confirmed\":\"har allerede blitt bekreftet\",\"not_found\":\"ikke funnnet\",\"not_locked\":\"var ikke låst\"}},\"home\":{\"name\":\"hjem\"},\"jobs\":{\"allowed_failures\":\"Tillatte feil\",\"author\":\"Forfatter\",\"branch\":\"Gren\",\"build_matrix\":\"Jobbmatrise\",\"commit\":\"Innsending\",\"committer\":\"Innsender\",\"compare\":\"Sammenlign\",\"config\":\"Oppsett\",\"duration\":\"Varighet\",\"finished_at\":\"Fullført\",\"message\":\"Beskrivelse\",\"messages\":{\"sponsored_by\":\"Denne testserien ble kjørt på en maskin sponset av\"},\"started_at\":\"Startet\"},\"layouts\":{\"about\":{\"alpha\":\"Dette er alfa-greier.\",\"join\":\"Bli med og hjelp oss!\",\"mailing_list\":\"E-postliste\",\"messages\":{\"alpha\":\"Dette er <strong>ikke</strong> en stabil tjeneste. Vi har fremdeles et stykke igjen! Mer informasjon finner du <a href=\\\"https://github.com/travis-ci\\\">her</a>.\"},\"repository\":\"Kodelager\",\"twitter\":\"Twitter.\"},\"application\":{\"fork_me\":\"Se koden på Github\",\"my_repositories\":\"Mine kodelagre\",\"recent\":\"Nylig\",\"search\":\"Søk\",\"sponsers\":\"Sponsorer\",\"sponsors_link\":\"Se alle de flotte sponsorene våre &rarr;\"},\"mobile\":{\"author\":\"Forfatter\",\"build\":\"Jobb\",\"build_matrix\":\"Jobbmatrise\",\"commit\":\"Innsending\",\"committer\":\"Innsender\",\"compare\":\"Sammenlign\",\"config\":\"Oppsett\",\"duration\":\"Varighet\",\"finished_at\":\"Fullført\",\"job\":\"Jobb\",\"log\":\"Logg\"},\"top\":{\"admin\":\"Administrator\",\"blog\":\"Blogg\",\"docs\":\"Dokumentasjon\",\"github_login\":\"Logg inn med Github\",\"home\":\"Hjem\",\"profile\":\"Profil\",\"sign_out\":\"Logg ut\",\"stats\":\"Statistikk\"}},\"no_job\":\"Ingen jobber finnnes\",\"profiles\":{\"show\":{\"email\":\"E-post\",\"github\":\"Github\",\"message\":{\"config\":\"hvordan sette opp egne jobbinnstillinger\",\"your_repos\":\"Slå\\u0010 på Travis for prosjektene dine ved å dra i bryterne under, og send koden til Github.<br />\\nFor å teste mot flere ruby-versjoner, se dokumentasjonen for\"},\"messages\":{\"notice\":\"For å komme i gang, vennligst les <a href=\\\"http://about.travis-ci.org/docs/user/getting-started/\\\">kom-i-gang-veivisereren</a> vår. <small>Det tar bare et par minutter.</small>\"},\"token\":\"Kode\",\"update\":\"Oppdater\",\"update_locale\":\"Oppdater\",\"your_locale\":\"Ditt språk\",\"your_repos\":\"Dine kodelagre\"}},\"queue\":\"Kø\",\"repositories\":{\"branch\":\"Gren\",\"commit\":\"Innsender\",\"duration\":\"Varighet\",\"finished_at\":\"Fullført\",\"image_url\":\"Bilde-URL\",\"markdown\":\"Markdown\",\"message\":\"Beskrivelse\",\"rdoc\":\"RDOC\",\"started_at\":\"Startet\",\"tabs\":{\"branches\":\"Grensammendrag\",\"build\":\"Jobb\",\"build_history\":\"Jobblogg\",\"current\":\"Siste\",\"job\":\"Jobb\"},\"textile\":\"Textile\"},\"repository\":{\"duration\":\"Varighet\"},\"statistics\":{\"index\":{\"build_count\":\"Antall jobber\",\"count\":\"Antall\",\"last_month\":\"siste måned\",\"repo_growth\":\"Vekst i kodelager\",\"total_builds\":\"Totale jobber\",\"total_projects\":\"Antall prosjekter/kodelagre\"}},\"workers\":\"Arbeidere\",\"locales\":{\"en\":\"English\",\"es\":\"Español\",\"ja\":\"日本語\",\"ru\":\"Русский\",\"fr\":\"Français\",\"nb\":\"Norsk Bokmål\",\"pl\":\"Polski\",\"nl\":\"Nederlands\",\"pt-BR\":\"português brasileiro\"}},\"nl\":{\"admin\":{\"actions\":{\"create\":\"aanmaken\",\"created\":\"aangemaakt\",\"delete\":\"verwijderen\",\"deleted\":\"verwijderd\",\"update\":\"bijwerken\",\"updated\":\"bijgewerkt\"},\"credentials\":{\"log_out\":\"Afmelden\"},\"dashboard\":{\"add_new\":\"Nieuwe toevoegen\",\"ago\":\"geleden\",\"last_used\":\"Laatst gebruikt\",\"model_name\":\"Model naam\",\"modify\":\"Wijzigen\",\"pagename\":\"Site administratie\",\"show\":\"Laten zien\",\"records\":\"Gegevens\"},\"delete\":{\"confirmation\":\"Ja, ik ben zeker\",\"flash_confirmation\":\"%{name} is vernietigd\"},\"flash\":{\"error\":\"%{name} kon niet worden %{action}\",\"noaction\":\"Er zijn geen acties genomen\",\"successful\":\"%{name} is %{action}\"},\"history\":{\"name\":\"Geschiedenis\",\"no_activity\":\"Geen activiteit\",\"page_name\":\"Geschiedenis van %{name}\"},\"list\":{\"add_new\":\"Nieuwe toevoegen\",\"delete_action\":\"Verwijderen\",\"delete_selected\":\"Verwijder geselecteerden\",\"edit_action\":\"Bewerken\",\"search\":\"Zoeken\",\"select\":\"Selecteer %{name} om te bewerken\",\"select_action\":\"Selecteer\",\"show_all\":\"Laat allen zien\"},\"new\":{\"basic_info\":\"Basisinfo\",\"cancel\":\"Annuleren\",\"chosen\":\"%{name} gekozen\",\"chose_all\":\"Kies allen\",\"clear_all\":\"Deselecteer allen\",\"many_chars\":\"tekens of minder.\",\"one_char\":\"teken.\",\"optional\":\"Optioneel\",\"required\":\"Vereist\",\"save\":\"Opslaan\",\"save_and_add_another\":\"Opslaan en een nieuwe toevoegen\",\"save_and_edit\":\"Opslaan en bewerken\",\"select_choice\":\"Selecteer uw keuzes en klik\"}},\"build\":{\"duration\":\"Duur\",\"finished_at\":\"Voltooid\",\"job\":\"Taak\"},\"builds\":{\"allowed_failures\":\"Toegestane mislukkingen\",\"author\":\"Auteur\",\"branch\":\"Tak\",\"build_matrix\":\"Bouw Matrix\",\"compare\":\"Vergelijk\",\"config\":\"Configuratie\",\"duration\":\"Duur\",\"finished_at\":\"Voltooid\",\"message\":\"Bericht\",\"messages\":{\"sponsored_by\":\"Deze tests zijn gedraaid op een machine gesponsord door\"},\"name\":\"Bouw\",\"started_at\":\"Gestart\",\"commit\":\"Commit\",\"committer\":\"Committer\"},\"datetime\":{\"distance_in_words\":{\"hours_exact\":{\"one\":\"%{count} uur\",\"other\":\"%{count} uren\"},\"minutes_exact\":{\"one\":\"%{count} minuut\",\"other\":\"%{count} minuten\"},\"seconds_exact\":{\"one\":\"%{count} seconde\",\"other\":\"%{count} seconden\"}}},\"devise\":{\"confirmations\":{\"confirmed\":\"Uw account is bevestigd. U wordt nu ingelogd.\",\"send_instructions\":\"Binnen enkele minuten zal u een email ontvangen met instructies om uw account te bevestigen.\"},\"failure\":{\"inactive\":\"Uw account is nog niet geactiveerd.\",\"invalid\":\"Ongeldig email adres of wachtwoord.\",\"invalid_token\":\"Ongeldig authenticatie token.\",\"locked\":\"Uw account is vergrendeld.\",\"timeout\":\"Uw sessie is verlopen, gelieve opnieuw in te loggen om verder te gaan.\",\"unauthenticated\":\"U moet inloggen of u registeren voordat u verder gaat.\",\"unconfirmed\":\"U moet uw account bevestigen voordat u verder gaat.\"},\"mailer\":{\"confirmation_instructions\":{\"subject\":\"Bevestigings-instructies\"},\"reset_password_instructions\":{\"subject\":\"Wachtwoord herstel instructies\"},\"unlock_instructions\":{\"subject\":\"Ontgrendel-instructies\"}},\"passwords\":{\"send_instructions\":\"Binnen enkele minuten zal u een email krijgen met instructies om uw wachtwoord opnieuw in te stellen.\",\"updated\":\"Uw wachtwoord is veranderd. U wordt nu ingelogd.\"},\"registrations\":{\"destroyed\":\"Dag! Uw account is geannuleerd. We hopen u vlug terug te zien.\",\"signed_up\":\"Uw registratie is voltooid. Als het ingeschakeld is wordt een bevestiging naar uw email adres verzonden.\",\"updated\":\"Het bijwerken van uw account is gelukt.\"},\"sessions\":{\"signed_in\":\"Inloggen gelukt.\",\"signed_out\":\"Uitloggen gelukt.\"},\"unlocks\":{\"send_instructions\":\"Binnen enkele minuten zal u een email krijgen met instructies om uw account te ontgrendelen.\",\"unlocked\":\"Uw account is ontgrendeld. U wordt nu ingelogd.\"}},\"errors\":{\"messages\":{\"already_confirmed\":\"was al bevestigd\",\"not_found\":\"niet gevonden\",\"not_locked\":\"was niet vergrendeld\"}},\"jobs\":{\"allowed_failures\":\"Toegestane mislukkingen\",\"author\":\"Auteur\",\"branch\":\"Tak\",\"build_matrix\":\"Bouw matrix\",\"compare\":\"Vergelijk\",\"config\":\"Configuratie\",\"duration\":\"Duur\",\"finished_at\":\"Voltooid\",\"message\":\"Bericht\",\"messages\":{\"sponsored_by\":\"Deze testen zijn uitgevoerd op een machine gesponsord door\"},\"started_at\":\"Gestart\",\"commit\":\"Commit\",\"committer\":\"Committer\"},\"layouts\":{\"about\":{\"alpha\":\"Dit is in alfa-stadium.\",\"join\":\"Doe met ons mee en help!\",\"mailing_list\":\"Mailing lijst\",\"messages\":{\"alpha\":\"Gelieve deze service <strong>niet</strong> te beschouwen als stabiel. Daar zijn we nog lang niet! Meer info <a href='https://github.com/travis-ci'>hier.</a>\"},\"repository\":\"Repository\",\"twitter\":\"Twitter\"},\"application\":{\"fork_me\":\"Maak een fork op Github\",\"my_repositories\":\"Mijn repositories\",\"recent\":\"Recent\",\"search\":\"Zoeken\",\"sponsers\":\"Sponsors\",\"sponsors_link\":\"Bekijk al onze geweldige sponsors &rarr;\"},\"mobile\":{\"author\":\"Auteur\",\"build\":\"Bouw\",\"build_matrix\":\"Bouw matrix\",\"compare\":\"Vergelijk\",\"config\":\"Configuratie\",\"duration\":\"Duur\",\"finished_at\":\"Voltooid op\",\"job\":\"Taak\",\"commit\":\"Commit\",\"committer\":\"Committer\",\"log\":\"Logboek\"},\"top\":{\"admin\":\"Administratie\",\"blog\":\"Blog\",\"docs\":\"Documentatie\",\"github_login\":\"Inloggen met Github\",\"home\":\"Home\",\"profile\":\"Profiel\",\"sign_out\":\"Uitloggen\",\"stats\":\"Statistieken\"}},\"locales\":{\"en\":\"English\",\"es\":\"Español\",\"fr\":\"Français\",\"ja\":\"日本語\",\"nb\":\"Norsk Bokmål\",\"nl\":\"Nederlands\",\"pl\":\"Polski\",\"ru\":\"Русский\",\"pt-BR\":\"português brasileiro\"},\"no_job\":\"Er zijn geen taken\",\"profiles\":{\"show\":{\"email\":\"Email adres\",\"github\":\"Github\",\"message\":{\"config\":\"hoe eigen bouw-opties in te stellen\",\"your_repos\":\"Zet de schakelaars hieronder aan om de Travis hook voor uw projecten te activeren en push daarna naar Github<br />\\nOm te testen tegen meerdere rubies, zie\"},\"messages\":{\"notice\":\"Om te beginnen kunt u onze <a href=\\\\\\\"http://about.travis-ci.org/docs/user/getting-started/\\\\\\\">startersgids</a> lezen.\\\\n  <small>Het zal maar enkele minuten van uw tijd vergen.</small>\"},\"update\":\"Bijwerken\",\"update_locale\":\"Bijwerken\",\"your_locale\":\"Uw taal\",\"your_repos\":\"Uw repositories\",\"token\":\"Token\"}},\"queue\":\"Wachtrij\",\"repositories\":{\"branch\":\"Tak\",\"duration\":\"Duur\",\"finished_at\":\"Voltooid\",\"image_url\":\"Afbeeldings URL\",\"message\":\"Bericht\",\"started_at\":\"Gestart\",\"tabs\":{\"branches\":\"Tak samenvatting\",\"build\":\"Bouw\",\"build_history\":\"Bouw geschiedenis\",\"current\":\"Huidig\",\"job\":\"Taak\"},\"commit\":\"Commit\",\"markdown\":\"Markdown\",\"rdoc\":\"RDOC\",\"textile\":\"Textile\"},\"repository\":{\"duration\":\"Duur\"},\"statistics\":{\"index\":{\"build_count\":\"Bouw aantal\",\"count\":\"Aantal\",\"last_month\":\"voorbije maand\",\"repo_growth\":\"Repository groei\",\"total_builds\":\"Bouw totaal\",\"total_projects\":\"Projecten/Repository totaal\"}},\"workers\":\"Machines\",\"home\":{\"name\":\"Hoofdpagina\"}},\"pl\":{\"datetime\":{\"distance_in_words\":{\"hours_exact\":{\"one\":\"%{count} godzina\",\"other\":\"%{count} godziny\"},\"minutes_exact\":{\"one\":\"%{count} minuta\",\"other\":\"%{count} minuty\"},\"seconds_exact\":{\"one\":\"%{count} sekunda\",\"other\":\"%{count} sekundy\"}}},\"workers\":\"Workers\",\"queue\":\"Kolejka\",\"no_job\":\"Brak zadań\",\"repositories\":{\"branch\":\"Gałąź\",\"image_url\":\"URL obrazka\",\"markdown\":\"Markdown\",\"textile\":\"Textile\",\"rdoc\":\"RDOC\",\"commit\":\"Commit\",\"message\":\"Opis\",\"started_at\":\"Rozpoczęto\",\"duration\":\"Czas trwania\",\"finished_at\":\"Zakończono\",\"tabs\":{\"current\":\"Aktualny\",\"build_history\":\"Historia Buildów\",\"branches\":\"Wszystkie Gałęzie\",\"build\":\"Build\",\"job\":\"Zadanie\"}},\"build\":{\"job\":\"Zadanie\",\"duration\":\"Czas trwania\",\"finished_at\":\"Zakończono\"},\"jobs\":{\"messages\":{\"sponsored_by\":\"Te testy zostały uruchomione na maszynie sponsorowanej przez\"},\"build_matrix\":\"Macierz Buildów\",\"allowed_failures\":\"Dopuszczalne Niepowodzenia\",\"author\":\"Autor\",\"config\":\"Konfiguracja\",\"compare\":\"Porównanie\",\"committer\":\"Committer\",\"branch\":\"Gałąź\",\"commit\":\"Commit\",\"message\":\"Opis\",\"started_at\":\"Rozpoczęto\",\"duration\":\"Czas trwania\",\"finished_at\":\"Zakończono\",\"sponsored_by\":\"Te testy zostały uruchomione na maszynie sponsorowanej przez\"},\"builds\":{\"name\":\"Build\",\"messages\":{\"sponsored_by\":\"Te testy zostały uruchomione na maszynie sponsorowanej przez\"},\"build_matrix\":\"Macierz Buildów\",\"allowed_failures\":\"Dopuszczalne Niepowodzenia\",\"author\":\"Autor\",\"config\":\"Konfiguracja\",\"compare\":\"Porównanie\",\"committer\":\"Komitujący\",\"branch\":\"Gałąź\",\"commit\":\"Commit\",\"message\":\"Opis\",\"started_at\":\"Rozpoczęto\",\"duration\":\"Czas trwania\",\"finished_at\":\"Zakończono\"},\"layouts\":{\"top\":{\"home\":\"Start\",\"blog\":\"Blog\",\"docs\":\"Dokumentacja\",\"stats\":\"Statystki\",\"github_login\":\"Zaloguj się przy pomocy Githuba\",\"profile\":\"Profil\",\"sign_out\":\"Wyloguj się\"},\"application\":{\"fork_me\":\"Fork me on Github\",\"recent\":\"Ostatnie\",\"search\":\"Wyniki\",\"sponsers\":\"Sponsorzy\",\"sponsors_link\":\"Zobacz naszych wszystkich wspaniałych sponsorów &rarr;\",\"my_repositories\":\"Moje repozytoria\"},\"about\":{\"alpha\":\"To wciąż jest wersja alpha.\",\"messages\":{\"alpha\":\"Proszę <strong>nie</strong> traktuj tego jako stabilnej usługi. Wciąż nam wiele do tego brakuje! Więcej informacji znajdziesz <a href='https://github.com/travis-ci'>tutaj.</a>\"},\"join\":\"Pomóż i dołącz do nas!\",\"mailing_list\":\"Lista mailingowa\",\"repository\":\"Repozytorium\",\"twitter\":\"Twitter\"},\"mobile\":{\"author\":\"Autor\",\"build\":\"Build\",\"build_matrix\":\"Macierz Buildów\",\"commit\":\"Commit\",\"committer\":\"Komitujący\",\"compare\":\"Porównianie\",\"config\":\"Konfiguracja\",\"duration\":\"Czas trwania\",\"finished_at\":\"Zakończono\",\"job\":\"Zadanie\",\"log\":\"Log\"}},\"profiles\":{\"show\":{\"email\":\"Email\",\"github\":\"Github\",\"message\":{\"your_repos\":\"  Przesuń suwak poniżej, aby włączyć Travisa, dla twoich projektów, a następnie umieść swój kod na GitHubie.<br />\\n Aby testować swój kod przy użyciu wielu wersji Rubiego, zobacz\",\"config\":\"jak skonfigurować niestandardowe opcje builda\"},\"messages\":{\"notice\":\"Aby zacząć, przeczytaj nasz <a href=\\\"http://about.travis-ci.org/docs/user/getting-started/\\\">Przewodnik </a>.\\n  <small>Zajmie ci to tylko kilka minut.</small>\"},\"token\":\"Token\",\"your_repos\":\"Twoje repozytoria\"}},\"statistics\":{\"index\":{\"count\":\"Ilość\",\"repo_growth\":\"Przyrost repozytoriów\",\"total_projects\":\"Łącznie projektów/repozytoriów\",\"build_count\":\"Liczba buildów\",\"last_month\":\"ostatni miesiąc\",\"total_builds\":\"Łącznie Buildów\"}},\"date\":{\"abbr_day_names\":[\"nie\",\"pon\",\"wto\",\"śro\",\"czw\",\"pią\",\"sob\"],\"abbr_month_names\":[\"sty\",\"lut\",\"mar\",\"kwi\",\"maj\",\"cze\",\"lip\",\"sie\",\"wrz\",\"paź\",\"lis\",\"gru\"],\"day_names\":[\"niedziela\",\"poniedziałek\",\"wtorek\",\"środa\",\"czwartek\",\"piątek\",\"sobota\"],\"formats\":{\"default\":\"%d-%m-%Y\",\"long\":\"%B %d, %Y\",\"short\":\"%d %b\"},\"month_names\":[\"styczeń\",\"luty\",\"marzec\",\"kwiecień\",\"maj\",\"czerwiec\",\"lipiec\",\"sierpień\",\"wrzesień\",\"październik\",\"listopad\",\"grudzień\"],\"order\":[\"day\",\"month\",\"year\"]},\"errors\":{\"format\":\"%{attribute} %{message}\",\"messages\":{\"accepted\":\"musi zostać zaakceptowane\",\"blank\":\"nie może być puste\"}},\"locales\":{\"en\":\"English\",\"es\":\"Español\",\"ja\":\"日本語\",\"ru\":\"Русский\",\"fr\":\"Français\",\"nb\":\"Norsk Bokmål\",\"pl\":\"Polski\",\"nl\":\"Nederlands\",\"pt-BR\":\"português brasileiro\"}},\"pt-BR\":{\"admin\":{\"actions\":{\"create\":\"criar\",\"created\":\"criado\",\"delete\":\"deletar\",\"deleted\":\"deletado\",\"update\":\"atualizar\",\"updated\":\"atualizado\"},\"credentials\":{\"log_out\":\"Deslogar\"},\"dashboard\":{\"add_new\":\"Adicionar novo\",\"ago\":\"atrás\",\"last_used\":\"Última utilização\",\"model_name\":\"Nome do modelo\",\"modify\":\"Modificar\",\"name\":\"Dashboard\",\"pagename\":\"Administração do site\",\"records\":\"Registros\",\"show\":\"Mostrar\"},\"delete\":{\"confirmation\":\"Sim, tenho certeza\",\"flash_confirmation\":\"%{name} foi destruído com sucesso\"},\"flash\":{\"error\":\"%{name} falhou ao %{action}\",\"noaction\":\"Nenhuma ação foi tomada\",\"successful\":\"%{name} foi %{action} com sucesso\"},\"history\":{\"name\":\"Histórico\",\"no_activity\":\"Nenhuma Atividade\",\"page_name\":\"Histórico para %{name}\"},\"list\":{\"add_new\":\"Adicionar novo\",\"delete_action\":\"Deletar\",\"delete_selected\":\"Deletar selecionados\",\"edit_action\":\"Editar\",\"search\":\"Buscar\",\"select\":\"Selecionar %{name} para editar\",\"select_action\":\"Selecionar\",\"show_all\":\"Mostrar todos\"},\"new\":{\"basic_info\":\"Informações básicas\",\"cancel\":\"Cancelar\",\"chosen\":\"Escolhido %{name}\",\"chose_all\":\"Escolher todos\",\"clear_all\":\"Limpar todos\",\"many_chars\":\"caracteres ou menos.\",\"one_char\":\"caractere.\",\"optional\":\"Opcional\",\"required\":\"Requerido\",\"save\":\"Salvar\",\"save_and_add_another\":\"Salvar e adicionar outro\",\"save_and_edit\":\"Salvar e alterar\",\"select_choice\":\"Selecione e clique\"}},\"build\":{\"duration\":\"Duração\",\"finished_at\":\"Concluído em\",\"job\":\"Trabalho\"},\"builds\":{\"allowed_failures\":\"Falhas Permitidas\",\"author\":\"Autor\",\"branch\":\"Branch\",\"build_matrix\":\"Matriz de Build\",\"commit\":\"Commit\",\"committer\":\"Committer\",\"compare\":\"Comparar\",\"config\":\"Config\",\"duration\":\"Duração\",\"finished_at\":\"Concluído em\",\"message\":\"Mensagem\",\"messages\":{\"sponsored_by\":\"Esta série de testes foi executada em uma caixa de processos patrocinada por\"},\"name\":\"Build\",\"started_at\":\"Iniciou em\"},\"datetime\":{\"distance_in_words\":{\"hours_exact\":{\"one\":\"%{count} hora\",\"other\":\"%{count} horas\"},\"minutes_exact\":{\"one\":\"%{count} minuto\",\"other\":\"%{count} minutos\"},\"seconds_exact\":{\"one\":\"%{count} segundo\",\"other\":\"%{count} segundos\"}}},\"devise\":{\"confirmations\":{\"confirmed\":\"Sua conta foi confirmada com sucesso. Você agora está logado.\",\"send_instructions\":\"Você receberá um email com instruções de como confirmar sua conta em alguns minutos.\"},\"failure\":{\"inactive\":\"Sua conta ainda não foi ativada.\",\"invalid\":\"Email ou senha inválidos.\",\"invalid_token\":\"Token de autenticação inválido.\",\"locked\":\"Sua conta está trancada.\",\"timeout\":\"Sua sessão expirou, por favor faça seu login novamente.\",\"unauthenticated\":\"Você precisa fazer o login ou cadastrar-se antes de continuar.\",\"unconfirmed\":\"Você precisa confirmar sua conta antes de continuar.\"},\"mailer\":{\"confirmation_instructions\":{\"subject\":\"Instruções de confirmação\"},\"reset_password_instructions\":{\"subject\":\"Instruções de atualização de senha\"},\"unlock_instructions\":{\"subject\":\"Instruções de destrancamento\"}},\"passwords\":{\"send_instructions\":\"Você receberá um email com instruções de como atualizar sua senha em alguns minutos.\",\"updated\":\"Sua senha foi alterada com sucesso. Você agora está logado.\"},\"registrations\":{\"destroyed\":\"Tchau! Sua conta foi cancelada com sucesso. Esperamos vê-lo novamente em breve!\",\"signed_up\":\"Você se cadastrou com sucesso. Se ativada, uma confirmação foi enviada para seu email.\",\"updated\":\"Você atualizou sua conta com sucesso.\"},\"sessions\":{\"signed_in\":\"Logado com sucesso.\",\"signed_out\":\"Deslogado com sucesso.\"},\"unlocks\":{\"send_instructions\":\"Você receberá um email com instruções de como destrancar sua conta em alguns minutos.\",\"unlocked\":\"Sua conta foi destrancada com sucesso. Você agora está logado.\"}},\"errors\":{\"messages\":{\"already_confirmed\":\"já foi confirmado\",\"not_found\":\"não encontrado\",\"not_locked\":\"não estava trancado\"}},\"home\":{\"name\":\"home\"},\"jobs\":{\"allowed_failures\":\"Falhas Permitidas\",\"author\":\"Autor\",\"branch\":\"Branch\",\"build_matrix\":\"Matriz de Build\",\"commit\":\"Commit\",\"committer\":\"Committer\",\"compare\":\"Comparar\",\"config\":\"Config\",\"duration\":\"Duração\",\"finished_at\":\"Concluído em\",\"message\":\"Mensagem\",\"messages\":{\"sponsored_by\":\"Esta série de testes foi executada em uma caixa de processos patrocinada por\"},\"started_at\":\"Iniciou em\"},\"layouts\":{\"about\":{\"alpha\":\"Isto é um alpha.\",\"join\":\"Junte-se à nós e ajude!\",\"mailing_list\":\"Lista de email\",\"messages\":{\"alpha\":\"Por favor, <strong>não</strong> considere isto um serviço estável. Estamos muito longe disso! Mais informações <a href='https://github.com/travis-ci'>aqui.</a>\"},\"repository\":\"Repositório\",\"twitter\":\"Twitter\"},\"application\":{\"fork_me\":\"Faça fork no Github\",\"my_repositories\":\"Meus Repositórios\",\"recent\":\"Recentes\",\"search\":\"Buscar\",\"sponsers\":\"Patrocinadores\",\"sponsors_link\":\"Conheça todos os nossos patrocinadores &rarr;\"},\"mobile\":{\"author\":\"Autor\",\"build\":\"Build\",\"build_matrix\":\"Matriz de Build\",\"commit\":\"Commit\",\"committer\":\"Committer\",\"compare\":\"Comparar\",\"config\":\"Config\",\"duration\":\"Duração\",\"finished_at\":\"Concluído em\",\"job\":\"Trabalho\",\"log\":\"Log\"},\"top\":{\"admin\":\"Admin\",\"blog\":\"Blog\",\"docs\":\"Documentação\",\"github_login\":\"Logue com o Github\",\"home\":\"Home\",\"profile\":\"Perfil\",\"sign_out\":\"Sair\",\"stats\":\"Estatísticas\"}},\"locales\":{\"en\":\"English\",\"es\":\"Español\",\"fr\":\"Français\",\"ja\":\"日本語\",\"nb\":\"Norsk Bokmål\",\"nl\":\"Nederlands\",\"pl\":\"Polski\",\"ru\":\"Русский\",\"pt-BR\":\"português brasileiro\"},\"no_job\":\"Não há trabalhos\",\"profiles\":{\"show\":{\"email\":\"Email\",\"github\":\"Github\",\"message\":{\"config\":\"como configurar opções de build\",\"your_repos\":\"Use os botões abaixo para ligar ou desligar o hook de serviço do Travis para seus projetos, e então, faça um push para o Github.<br />Para testar com múltiplas versões do Ruby, leia\"},\"messages\":{\"notice\":\"Para começar, leia nosso <a href=\\\"http://about.travis-ci.org/docs/user/getting-started/\\\">Guia de início</a>. <small>Só leva alguns minutinhos.</small>\"},\"token\":\"Token\",\"update\":\"Atualizar\",\"update_locale\":\"Atualizar\",\"your_locale\":\"Sua língua\",\"your_repos\":\"Seus Repositórios\"}},\"queue\":\"Fila\",\"repositories\":{\"branch\":\"Branch\",\"commit\":\"Commit\",\"duration\":\"Duração\",\"finished_at\":\"Concluído em\",\"image_url\":\"URL da imagem\",\"markdown\":\"Markdown\",\"message\":\"Mensagem\",\"rdoc\":\"RDOC\",\"started_at\":\"Iniciou em\",\"tabs\":{\"branches\":\"Sumário do Branch\",\"build\":\"Build\",\"build_history\":\"Histórico de Build\",\"current\":\"Atual\",\"job\":\"Trabalho\"},\"textile\":\"Textile\"},\"repository\":{\"duration\":\"Duração\"},\"statistics\":{\"index\":{\"build_count\":\"Número de Builds\",\"count\":\"Número\",\"last_month\":\"último mês\",\"repo_growth\":\"Crescimento de Repositório\",\"total_builds\":\"Total de Builds\",\"total_projects\":\"Total de Projetos/Repositórios\"}},\"workers\":\"Processos\"},\"ru\":{\"admin\":{\"actions\":{\"create\":\"создать\",\"created\":\"создано\",\"delete\":\"удалить\",\"deleted\":\"удалено\",\"update\":\"обновить\",\"updated\":\"обновлено\"},\"credentials\":{\"log_out\":\"Выход\"},\"dashboard\":{\"add_new\":\"Добавить\",\"ago\":\"назад\",\"last_used\":\"Использовалось в последний раз\",\"model_name\":\"Имя модели\",\"modify\":\"Изменить\",\"name\":\"Панель управления\",\"pagename\":\"Управление сайтом\",\"records\":\"Записи\",\"show\":\"Показать\"},\"delete\":{\"confirmation\":\"Да, я уверен\",\"flash_confirmation\":\"%{name} успешно удалено\"},\"history\":{\"name\":\"История\",\"no_activity\":\"Нет активности\",\"page_name\":\"История %{name}\"},\"list\":{\"add_new\":\"Добавить\",\"delete_action\":\"Удалить\",\"delete_selected\":\"Удалить выбранные\",\"edit_action\":\"Редактировать\",\"search\":\"Поиск\",\"select\":\"Для редактирования выберите %{name}\",\"select_action\":\"Выбрать\",\"show_all\":\"Показать все\"},\"new\":{\"basic_info\":\"Основная информация\",\"cancel\":\"Отмена\",\"chosen\":\"Выбрано %{name}\",\"chose_all\":\"Выбрать все\",\"clear_all\":\"Очистить все\",\"one_char\":\"символ.\",\"optional\":\"Необязательно\",\"required\":\"Обязательно\",\"save\":\"Сохранить\",\"save_and_add_another\":\"Сохранить и добавить другое\",\"save_and_edit\":\"Сохранить и продолжить редактирование\",\"select_choice\":\"Выберите и кликните\",\"many_chars\":\"символов или меньше.\"},\"flash\":{\"error\":\"%{name} не удалось %{action}\",\"noaction\":\"Никаких действий не произведено\",\"successful\":\"%{name} было успешно %{action}\"}},\"build\":{\"duration\":\"Длительность\",\"finished_at\":\"Завершен\",\"job\":\"Задача\"},\"builds\":{\"allowed_failures\":\"Допустимые неудачи\",\"author\":\"Автор\",\"branch\":\"Ветка\",\"build_matrix\":\"Матрица\",\"commit\":\"Коммит\",\"committer\":\"Коммитер\",\"compare\":\"Дифф\",\"config\":\"Конфигурация\",\"duration\":\"Длительность\",\"finished_at\":\"Завершен\",\"message\":\"Комментарий\",\"messages\":{\"sponsored_by\":\"Эта серия тестов была запущена на машине, спонсируемой\"},\"name\":\"Билд\",\"started_at\":\"Начало\"},\"datetime\":{\"distance_in_words\":{\"hours_exact\":{\"one\":\"%{count} час\",\"few\":\"%{count} часа\",\"many\":\"%{count} часов\",\"other\":\"%{count} часа\"},\"minutes_exact\":{\"one\":\"%{count} минута\",\"few\":\"%{count} минуты\",\"many\":\"%{count} минут\",\"other\":\"%{count} минуты\"},\"seconds_exact\":{\"one\":\"%{count} секунда\",\"few\":\"%{count} секунды\",\"many\":\"%{count} секунд\",\"other\":\"%{count} секунды\"}}},\"devise\":{\"confirmations\":{\"confirmed\":\"Ваш аккаунт успешно подтвержден. Приветствуем!\",\"send_instructions\":\"В течении нескольких минут вы получите электронное письмо с инструкциями для прохождения процедуры подтверждения аккаунта.\"},\"failure\":{\"inactive\":\"Ваш аккаунт еще не активирован.\",\"invalid\":\"Ошибка в адресе почты или пароле.\",\"invalid_token\":\"Неправильный токен аутентификации.\",\"locked\":\"Ваш аккаунт заблокирован.\",\"timeout\":\"Сессия окончена. Для продолжения работы войдите снова.\",\"unauthenticated\":\"Вам нужно войти или зарегистрироваться.\",\"unconfirmed\":\"Вы должны сначала подтвердить свой аккаунт.\"},\"mailer\":{\"confirmation_instructions\":{\"subject\":\"Инструкции для подтверждению аккаунта\"},\"reset_password_instructions\":{\"subject\":\"Инструкции для сброса пароля\"},\"unlock_instructions\":{\"subject\":\"Инструкции для разблокирования аккаунта\"}},\"passwords\":{\"send_instructions\":\"В течении нескольких минут вы получите электронное письмо с инструкциями для сброса пароля.\",\"updated\":\"Ваш пароль успешно изменен. Приветствуем!\"},\"registrations\":{\"destroyed\":\"Ваш аккаунт был успешно удален. Живите долго и процветайте!\",\"signed_up\":\"Вы успешно прошли регистрацию. Инструкции для подтверждения аккаунта отправлены на ваш электронный адрес.\",\"updated\":\"Аккаунт успешно обновлен.\"},\"sessions\":{\"signed_in\":\"Приветствуем!\",\"signed_out\":\"Удачи!\"},\"unlocks\":{\"send_instructions\":\"В течении нескольких минут вы получите электронное письмо с инструкциям для разблокировния аккаунта.\",\"unlocked\":\"Ваш аккаунт успешно разблокирован. Приветствуем!\"}},\"errors\":{\"messages\":{\"already_confirmed\":\"уже подтвержден\",\"not_found\":\"не найден\",\"not_locked\":\"не заблокирован\"}},\"home\":{\"name\":\"Главная\"},\"jobs\":{\"allowed_failures\":\"Допустимые неудачи\",\"author\":\"Автор\",\"branch\":\"Ветка\",\"build_matrix\":\"Матрица\",\"commit\":\"Коммит\",\"committer\":\"Коммитер\",\"compare\":\"Сравнение\",\"config\":\"Конфигурация\",\"duration\":\"Длительность\",\"finished_at\":\"Завершен\",\"message\":\"Комментарий\",\"messages\":{\"sponsored_by\":\"Эта серия тестов была запущена на машине спонсируемой\"},\"started_at\":\"Начало\"},\"layouts\":{\"about\":{\"alpha\":\"Это альфа-версия\",\"join\":\"Присоединяйтесь к нам и помогайте!\",\"mailing_list\":\"Лист рассылки\",\"messages\":{\"alpha\":\"Пожалуйста, <strong>не</strong> считайте данный сервис стабильным. Мы еще очень далеки от стабильности! <a href='https://github.com/travis-ci'>Подробности</a>\"},\"repository\":\"Репозиторий\",\"twitter\":\"Twitter\"},\"application\":{\"fork_me\":\"Fork me on Github\",\"my_repositories\":\"Мои репозитории\",\"recent\":\"Недавние\",\"search\":\"Поиск\",\"sponsers\":\"Спонсоры\",\"sponsors_link\":\"Список всех наших замечательных спонсоров &rarr;\"},\"mobile\":{\"author\":\"Автор\",\"build\":\"Сборка\",\"build_matrix\":\"Матрица сборок\",\"commit\":\"Коммит\",\"committer\":\"Коммитер\",\"compare\":\"Сравнение\",\"config\":\"Конфигурация\",\"duration\":\"Длительность\",\"finished_at\":\"Завершен\",\"job\":\"Задача\",\"log\":\"Журнал\"},\"top\":{\"admin\":\"Управление\",\"blog\":\"Блог\",\"docs\":\"Документация\",\"github_login\":\"Войти через Github\",\"home\":\"Главная\",\"profile\":\"Профиль\",\"sign_out\":\"Выход\",\"stats\":\"Статистика\"}},\"no_job\":\"Очередь пуста\",\"profiles\":{\"show\":{\"email\":\"Электронная почта\",\"github\":\"Github\",\"message\":{\"config\":\"как настроить специальные опции билда\",\"your_repos\":\"Используйте переключатели, чтобы включить Travis service hook для вашего проекта, а потом отправьте код на GitHub.<br />\\nДля тестирования на нескольких версиях Ruby смотрите\"},\"messages\":{\"notice\":\"Перед началом, пожалуйста, прочтите <a href=\\\"http://about.travis-ci.org/docs/user/getting-started/\\\">Руководство для быстрого старта</a>. <small>Это займет всего несколько минут.</small>\"},\"token\":\"Токен\",\"update\":\"Обновить\",\"update_locale\":\"Обновить\",\"your_locale\":\"Ваш язык\",\"your_repos\":\"Ваши репозитории\"}},\"queue\":\"Очередь\",\"repositories\":{\"branch\":\"Ветка\",\"commit\":\"Коммит\",\"duration\":\"Длительность\",\"finished_at\":\"Завершен\",\"image_url\":\"URL изображения\",\"markdown\":\"Markdown\",\"message\":\"Комментарий\",\"rdoc\":\"RDOC\",\"started_at\":\"Начало\",\"tabs\":{\"branches\":\"Статус веток\",\"build\":\"Билд\",\"build_history\":\"История\",\"current\":\"Текущий\",\"job\":\"Задача\"},\"textile\":\"Textile\"},\"repository\":{\"duration\":\"Длительность\"},\"statistics\":{\"index\":{\"build_count\":\"Количество билдов\",\"count\":\"Количество\",\"last_month\":\"прошлый месяц\",\"repo_growth\":\"Рост числа репозиториев\",\"total_builds\":\"Всего билдов\",\"total_projects\":\"Всего проектов/репозиториев\"}},\"workers\":\"Машины\",\"locales\":{\"en\":\"English\",\"es\":\"Español\",\"ja\":\"日本語\",\"ru\":\"Русский\",\"fr\":\"Français\",\"nb\":\"Norsk Bokmål\",\"pl\":\"Polski\",\"nl\":\"Nederlands\",\"pt-BR\":\"português brasileiro\"}}};\n\n\n})();\n//@ sourceURL=locales");minispade.register('ext/ember/bound_helper', "(function() {// https://gist.github.com/2018185\n// For reference: https://github.com/wagenet/ember.js/blob/ac66dcb8a1cbe91d736074441f853e0da474ee6e/packages/ember-handlebars/lib/views/bound_property_view.js\nvar BoundHelperView = Ember.View.extend(Ember._Metamorph, {\n\n  context: null,\n  options: null,\n  property: null,\n  // paths of the property that are also observed\n  propertyPaths: [],\n\n  value: Ember.K,\n\n  valueForRender: function() {\n    var value = this.value(Ember.getPath(this.context, this.property), this.options);\n    if (this.options.escaped) { value = Handlebars.Utils.escapeExpression(value); }\n    return value;\n  },\n\n  render: function(buffer) {\n    buffer.push(this.valueForRender());\n  },\n\n  valueDidChange: function() {\n    if (this.morph.isRemoved()) { return; }\n    this.morph.html(this.valueForRender());\n  },\n\n  didInsertElement: function() {\n    this.valueDidChange();\n  },\n\n  init: function() {\n    this._super();\n    Ember.addObserver(this.context, this.property, this, 'valueDidChange');\n    this.get('propertyPaths').forEach(function(propName) {\n        Ember.addObserver(this.context, this.property + '.' + propName, this, 'valueDidChange');\n    }, this);\n  },\n\n  destroy: function() {\n    Ember.removeObserver(this.context, this.property, this, 'valueDidChange');\n    this.get('propertyPaths').forEach(function(propName) {\n        this.context.removeObserver(this.property + '.' + propName, this, 'valueDidChange');\n    }, this);\n    this._super();\n  }\n\n});\n\nEmber.registerBoundHelper = function(name, func) {\n  var propertyPaths = Array.prototype.slice.call(arguments, 2);\n  Ember.Handlebars.registerHelper(name, function(property, options) {\n    var data = options.data,\n        view = data.view,\n        ctx  = this;\n\n    var bindView = view.createChildView(BoundHelperView, {\n      property: property,\n      propertyPaths: propertyPaths,\n      context: ctx,\n      options: options.hash,\n      value: func\n    });\n\n    view.appendChild(bindView);\n  });\n};\n\n\n})();\n//@ sourceURL=ext/ember/bound_helper");
\ No newline at end of file
+minispade.register('templates', "(function() {Ember.TEMPLATES['application']=Ember.Handlebars.compile(\"<div id=\\\"head\\\">\\n  <a href=\\\"/\\\">Travis CI</a>\\n  <a href=\\\"#\\\">#</a>\\n</div>\\n\\n<div id=\\\"left\\\">\\n  {{outlet left}}\\n</div>\\n\\n<div id=\\\"main\\\">\\n  {{outlet main}}\\n</div>\\n\");Ember.TEMPLATES['builds/list']=Ember.Handlebars.compile(\"<table id=\\\"builds\\\">\\n  <thead>\\n    <tr>\\n      <th>{{t builds.name}}</th>\\n      <th>{{t builds.commit}}</th>\\n      <th>{{t builds.message}}</th>\\n      <th>{{t builds.duration}}</th>\\n      <th>{{t builds.finished_at}}</th>\\n    </tr>\\n  </thead>\\n\\n  <tbody>\\n    {{#each build in content}}\\n      {{#view Travis.BuildsItemView contextBinding=\\\"build\\\"}}\\n        <tr>\\n          <td class=\\\"number\\\"><a {{action viewBuild href=true}}>{{number}}</a></td>\\n          <td class=\\\"commit\\\"><a {{bindAttr href=\\\"view.urlGithubCommit\\\"}}>{{formatCommit commit}}</a></td>\\n          <td class=\\\"message\\\">{{{formatMessage commit.message short=\\\"true\\\"}}}</td>\\n          <td class=\\\"duration\\\" {{bindAttr title=\\\"started_at\\\"}}>{{formatDuration duration}}</td>\\n          <td class=\\\"finished_at timeago\\\" {{bindAttr title=\\\"finished_at\\\"}}>{{formatTime finished_at}}</td>\\n        </tr>\\n      {{/view}}\\n    {{/each}}\\n  </tbody>\\n</table>\\n\\n<p>\\n  <button {{action showMore on=\\\"click\\\" target=\\\"builds\\\" isVisibleBinding=\\\"hasMore\\\"}}>\\n    {{t builds.show_more}}\\n  </button>\\n</p>\\n\");Ember.TEMPLATES['builds/show']=Ember.Handlebars.compile(\"<div {{bindAttr class=\\\"classes\\\"}}>\\n  <dl class=\\\"summary clearfix\\\">\\n    <div class=\\\"left\\\">\\n      <dt>{{t builds.name}}</dt>\\n      <dd class=\\\"number\\\"><a {{action viewBuild href=true}}>{{number}}</a></dd>\\n      <dt class=\\\"finished_at_label\\\">{{t builds.finished_at}}</dt>\\n      <dd class=\\\"finished_at timeago\\\" {{bindAttr title=\\\"finished_at\\\"}}>{{formatTime finished_at}}</dd>\\n      <dt>{{t builds.duration}}</dt>\\n      <dd class=\\\"duration\\\" {{bindAttr title=\\\"started_at\\\"}}>{{formatDuration duration}}</dd>\\n    </div>\\n\\n    <div class=\\\"right\\\">\\n      <dt>{{t builds.commit}}</dt>\\n      <dd class=\\\"commit-hash\\\"><a {{bindAttr href=\\\"urlGithubCommit\\\"}}>{{formatCommit commit}}</a></dd>\\n      {{#if commit.compareUrl}}\\n        <dt>{{t builds.compare}}</dt>\\n        <dd class=\\\"compare_view\\\"><a {{bindAttr href=\\\"commit.compareUrl\\\"}}>{{pathFrom commit.compareUrl}}</a></dd>\\n      {{/if}}\\n      {{#if commit.authorName}}\\n        <dt>{{t builds.author}}</dt>\\n        <dd class=\\\"author\\\"><a {{bindAttr href=\\\"urlAuthor\\\"}}>{{commit.authorName}}</a></dd>\\n      {{/if}}\\n      {{#if commit.committerName}}\\n        <dt>{{t builds.committer}}</dt>\\n        <dd class=\\\"committer\\\"><a {{bindAttr href=\\\"urlCommitter\\\"}}>{{commit.committerName}}</a></dd>\\n      {{/if}}\\n    </div>\\n\\n    <dt>{{t builds.message}}</dt>\\n    <dd class=\\\"commit-message\\\">{{{formatMessage commit.message}}}</dd>\\n\\n    {{#unless isMatrix}}\\n      <dt>{{t builds.config}}</dt>\\n      <dd class=\\\"config\\\">{{formatConfig config}}</dd>\\n    {{/unless}}\\n  </dl>\\n\\n  {{#if isLoaded}}\\n    {{#if view.isMatrix}}\\n      {{view Travis.JobsView jobsBinding=\\\"view.requiredJobs\\\" required=\\\"true\\\"}}\\n      {{view Travis.JobsView jobsBinding=\\\"view.allowedFailureJobs\\\"}}\\n    {{else}}\\n      {{view Travis.LogView contextBinding=\\\"jobs.firstObject\\\"}}\\n    {{/if}}\\n  {{/if}}\\n</div>\\n\");Ember.TEMPLATES['jobs/list']=Ember.Handlebars.compile(\"{{#if view.jobs.length}}\\n  <table id=\\\"jobs\\\">\\n    <caption>\\n      {{#if view.required}}\\n        {{t jobs.build_matrix}}\\n      {{else}}\\n        {{t jobs.allowed_failures}}{{whats_this allow_failure_help}}\\n      {{/if}}\\n    </caption>\\n    <thead>\\n      <tr>\\n        {{#each configKeys}}\\n          <th>{{this}}</th>\\n        {{/each}}\\n      </tr>\\n    </thead>\\n    <tbody>\\n      {{#each view.jobs}}\\n        <tr {{bindAttr class=\\\"color\\\"}}>\\n          <td class=\\\"number\\\"><a {{action viewJob href=true}}>#{{number}}</a></td>\\n          <td class=\\\"duration\\\" {{bindAttr title=\\\"started_at\\\"}}>{{formatDuration duration}}</td>\\n          <td class=\\\"finished_at timeago\\\" {{bindAttr title=\\\"finished_at\\\"}}>{{formatTime finished_at}}</td>\\n          {{#each configValues}}\\n            <td>{{this}}</td>\\n          {{/each}}\\n        </tr>\\n      {{/each}}\\n    </tbody>\\n  </table>\\n\\n  {{#unless view.required}}\\n    <div id=\\\"allow_failure_help\\\" class=\\\"context_help\\\">\\n      <div class=\\\"context_help_caption\\\">{{t \\\"jobs.allowed_failures\\\"}}</div>\\n      <div class=\\\"context_help_body\\\">\\n        <p>\\n          Allowed Failures are items in your build matrix that are allowed to\\n          fail without causing the entire build to be shown as failed. This lets you add\\n          in experimental and preparatory builds to test against versions or\\n          configurations that you are not ready to officially support.\\n        </p>\\n        <p>\\n          You can define allowed failures in the build matrix as follows:\\n        </p>\\n        <pre>\\n      matrix:\\n        allow_failures:\\n          - rvm: ruby-head\\n        </pre>\\n      </div>\\n    </div>\\n  {{/unless}}\\n{{/if}}\\n\");Ember.TEMPLATES['jobs/log']=Ember.Handlebars.compile(\"<pre class=\\\"log\\\">{{{formatLog log.body}}}</pre>\\n\\n{{#if sponsor.name}}\\n  <p class=\\\"sponsor\\\">\\n  {{t builds.messages.sponsored_by}}\\n    <a {{bindAttr href=\\\"sponsor.url\\\"}}>{{sponsor.name}}</a>\\n  </p>\\n{{/if}}\\n\");Ember.TEMPLATES['jobs/show']=Ember.Handlebars.compile(\"<div {{bindAttr class=\\\"classes\\\"}}>\\n  <dl class=\\\"summary clearfix\\\">\\n    <div class=\\\"left\\\">\\n      <dt>Job</dt>\\n      <dd class=\\\"number\\\"><a {{action viewJob href=true}}>{{number}}</a></dd>\\n      <dt class=\\\"finished_at_label\\\">{{t jobs.finished_at}}</dt>\\n      <dd class=\\\"finished_at timeago\\\" {{bindAttr title=\\\"finished_at\\\"}}>{{formatTime finished_at}}</dd>\\n      <dt>{{t jobs.duration}}</dt>\\n      <dd class=\\\"duration\\\" {{bindAttr title=\\\"started_at\\\"}}>{{formatDuration duration}}</dd>\\n    </div>\\n\\n    <div class=\\\"right\\\">\\n      <dt>{{t jobs.commit}}</dt>\\n      <dd class=\\\"commit-hash\\\"><a {{bindAttr href=\\\"urlGithubCommit\\\"}}>{{formatCommit commit}}</a></dd>\\n      {{#if commit.compareUrl}}\\n        <dt>{{t jobs.compare}}</dt>\\n        <dd class=\\\"compare_view\\\"><a {{bindAttr href=\\\"commit.compareUrl\\\"}}>{{pathFrom commit.compareUrl}}</a></dd>\\n      {{/if}}\\n      {{#if commit.authorName}}\\n        <dt>{{t jobs.author}}</dt>\\n        <dd class=\\\"author\\\"><a {{bindAttr href=\\\"urlAuthor\\\"}}>{{commit.authorName}}</a></dd>\\n      {{/if}}\\n      {{#if commit.committerName}}\\n        <dt>{{t jobs.committer}}</dt>\\n        <dd class=\\\"committer\\\"><a {{bindAttr href=\\\"urlCommitter\\\"}}>{{commit.committerName}}</a></dd>\\n      {{/if}}\\n    </div>\\n\\n    <dt>{{t jobs.message}}</dt>\\n    <dd class=\\\"commit-message\\\">{{formatMessage commit.message}}</dd>\\n    <dt>{{t jobs.config}}</dt>\\n    <dd class=\\\"config\\\">{{formatConfig config}}</dd>\\n  </dl>\\n\\n  {{view Travis.LogView}}\\n</div>\\n\\n\");Ember.TEMPLATES['repositories/list']=Ember.Handlebars.compile(\"{{#if content.lastObject.isLoaded}}\\n  <ul id=\\\"repositories\\\">\\n    {{#each repository in content}}\\n      {{#view Travis.RepositoriesItemView tagName=\\\"li\\\" classBinding=\\\"classes\\\" contextBinding=\\\"repository\\\"}}\\n        <div class=\\\"wrapper\\\">\\n          <a {{action viewCurrent href=true}} class=\\\"slug\\\">{{slug}}</a>\\n          <a {{action viewBuild href=true context=\\\"lastBuild\\\"}} class=\\\"build\\\">#{{lastBuildNumber}}</a>\\n        </div>\\n\\n        <p class=\\\"summary\\\">\\n          <span class=\\\"duration_label\\\">{{t repositories.duration}}:</span>\\n          <abbr class=\\\"duration\\\" {{bindAttr title=\\\"lastBuildStartedAt\\\"}}>{{formatDuration lastBuildDuration}}</abbr>,\\n          <span class=\\\"finished_at_label\\\">{{t repositories.finished_at}}:</span>\\n          <abbr class=\\\"finished_at timeago\\\" {{bindAttr title=\\\"lastBuildFinishedAt\\\"}}>{{formatTime lastBuildFinished_at}}</abbr>\\n        </p>\\n        {{#if description}}\\n          <p class=\\\"description\\\">{{description}}</p>\\n        {{/if}}\\n        <span class=\\\"indicator\\\"></span>\\n      {{/view}}\\n    {{/each}}\\n  <ul>\\n{{/if}}\\n\");Ember.TEMPLATES['repositories/show']=Ember.Handlebars.compile(\"<h3>\\n  <a {{bindAttr href=\\\"urlGithub\\\"}}>{{slug}}</a>\\n</h3>\\n\\n<p class=\\\"description\\\">{{description}}</p>\\n\\n<ul class=\\\"github-stats\\\">\\n  <li class=\\\"language\\\">{{last_build_language}}</li>\\n  <li><a class=\\\"watchers\\\" title=\\\"Watches\\\" {{bindAttr href=\\\"urlGithubWatchers\\\"}}>{{stats.watchers}}</a></li>\\n  <li><a class=\\\"forks\\\" title=\\\"Forks\\\" {{bindAttr href=\\\"urlGithubNetwork\\\"}}>{{stats.forks}}</a></li>\\n</ul>\\n\\n{{outlet tabs}}\\n\\n<div class=\\\"tab\\\">\\n  {{outlet tab}}\\n</div>\\n\");Ember.TEMPLATES['repositories/tabs']=Ember.Handlebars.compile(\"<ul class=\\\"tabs\\\">\\n  <li><a {{action viewCurrent href=true context=\\\"repository\\\"}} class=\\\"current\\\">Current</a></li>\\n  <li><a {{action viewBuilds href=true context=\\\"repository\\\"}} class=\\\"history\\\">History</a></li>\\n  {{#if build}}\\n    <li><a {{action viewBuild href=true context=\\\"build\\\"}} class=\\\"build\\\">Build #{{build.number}}</a></li>\\n  {{/if}}\\n  {{#if job}}\\n    <li><a {{action viewJob href=true context=\\\"job\\\"}} class=\\\"job\\\">Job #{{job.number}}</a></li>\\n  {{/if}}\\n</ul>\\n\");\n})();\n//@ sourceURL=templates");minispade.register('app', "(function() {(function() {\n\n  this.Travis = Em.Application.create();\nminispade.require('ext/jquery');\nminispade.require('locales');\nminispade.require('travis/data_store/rest_adapter');\nminispade.require('helpers');\nminispade.require('models');\nminispade.require('views');\nminispade.require('templates');\nminispade.require('controllers');\nminispade.require('routes');\n\n  Travis.store = DS.Store.extend({\n    revision: 4,\n    adapter: Travis.RestAdapter.create()\n  }).create();\n\n}).call(this);\n\n})();\n//@ sourceURL=app");minispade.register('controllers', "(function() {(function() {\n\n  Travis.ApplicationController = Em.Controller.extend();\n\n  Travis.RepositoriesController = Em.ArrayController.extend();\n\n  Travis.RepositoryController = Em.ObjectController.extend(Travis.Urls.Repository);\n\n  Travis.TabsController = Em.Controller.extend();\n\n  Travis.HistoryController = Em.ArrayController.extend();\n\n  Travis.BuildController = Em.ObjectController.extend(Travis.Urls.Commit);\n\n  Travis.JobController = Em.ObjectController.extend(Travis.Urls.Commit);\n\n}).call(this);\n\n})();\n//@ sourceURL=controllers");minispade.register('helpers', "(function() {(function() {\nminispade.require('helpers/handlebars');\nminispade.require('helpers/helpers');\nminispade.require('helpers/urls');\n\n}).call(this);\n\n})();\n//@ sourceURL=helpers");minispade.register('helpers/handlebars', "(function() {(function() {\n  var safe;\nminispade.require('ext/ember/bound_helper');\n\n  safe = function(string) {\n    return new Handlebars.SafeString(string);\n  };\n\n  Handlebars.registerHelper('whats_this', function(id) {\n    return safe('<span title=\"What\\'s This?\" class=\"whats_this\" onclick=\"$.facebox({ div: \\'#' + id + '\\'})\">&nbsp;</span>');\n  });\n\n  Handlebars.registerHelper('tipsy', function(text, tip) {\n    return safe('<span class=\"tool-tip\" original-title=\"' + tip + '\">' + text + '</span>');\n  });\n\n  Handlebars.registerHelper('t', function(key) {\n    return safe(I18n.t(key));\n  });\n\n  Ember.registerBoundHelper('formatTime', function(value, options) {\n    return safe(Travis.Helpers.timeAgoInWords(value) || '-');\n  });\n\n  Ember.registerBoundHelper('formatDuration', function(duration, options) {\n    return safe(Travis.Helpers.timeInWords(duration));\n  });\n\n  Ember.registerBoundHelper('formatCommit', function(commit, options) {\n    if (commit) {\n      return safe(Travis.Helpers.formatCommit(commit.get('sha'), commit.get('branch')));\n    }\n  });\n\n  Ember.registerBoundHelper('formatSha', function(sha, options) {\n    return safe(Travis.Helpers.formatSha(sha));\n  });\n\n  Ember.registerBoundHelper('pathFrom', function(url, options) {\n    return safe(Travis.Helpers.pathFrom(url));\n  });\n\n  Ember.registerBoundHelper('formatMessage', function(message, options) {\n    return safe(Travis.Helpers.formatMessage(message, options));\n  });\n\n  Ember.registerBoundHelper('formatConfig', function(config, options) {\n    return safe(Travis.Helpers.formatConfig(config));\n  });\n\n  Ember.registerBoundHelper('formatLog', function(log, options) {\n    return Travis.Helpers.formatLog(log) || '';\n  });\n\n}).call(this);\n\n})();\n//@ sourceURL=helpers/handlebars");minispade.register('helpers/helpers', "(function() {(function() {\nminispade.require('travis/log');\n\n  this.Travis.Helpers = {\n    safe: function(string) {\n      return new Handlebars.SafeString(string);\n    },\n    colorForResult: function(result) {\n      if (result === 0) {\n        return 'green';\n      } else {\n        if (result === 1) {\n          return 'red';\n        } else {\n          return null;\n        }\n      }\n    },\n    formatCommit: function(sha, branch) {\n      return Travis.Helpers.formatSha(sha) + (branch ? \" (\" + branch + \")\" : '');\n    },\n    formatSha: function(sha) {\n      return (sha || '').substr(0, 7);\n    },\n    formatConfig: function(config) {\n      var values;\n      config = $.only(config, 'rvm', 'gemfile', 'env', 'otp_release', 'php', 'node_js', 'scala', 'jdk', 'python', 'perl');\n      values = $.map(config, function(value, key) {\n        value = (value && value.join ? value.join(', ') : value) || '';\n        return '%@: %@'.fmt($.camelize(key), value);\n      });\n      if (values.length === 0) {\n        return '-';\n      } else {\n        return values.join(', ');\n      }\n    },\n    formatMessage: function(message, options) {\n      message = message || '';\n      if (options.short) {\n        message = message.split(/\\n/)[0];\n      }\n      return this._emojize(this._escape(message)).replace(/\\n/g, '<br/>');\n    },\n    formatLog: function(log) {\n      return Travis.Log.filter(log);\n    },\n    pathFrom: function(url) {\n      return (url || '').split('/').pop();\n    },\n    timeAgoInWords: function(date) {\n      return $.timeago.distanceInWords(date);\n    },\n    durationFrom: function(started, finished) {\n      started = started && this._toUtc(new Date(this._normalizeDateString(started)));\n      finished = finished ? this._toUtc(new Date(this._normalizeDateString(finished))) : this._nowUtc();\n      if (started && finished) {\n        return Math.round((finished - started) / 1000);\n      } else {\n        return 0;\n      }\n    },\n    timeInWords: function(duration) {\n      var days, hours, minutes, result, seconds;\n      days = Math.floor(duration / 86400);\n      hours = Math.floor(duration % 86400 / 3600);\n      minutes = Math.floor(duration % 3600 / 60);\n      seconds = duration % 60;\n      if (days > 0) {\n        return 'more than 24 hrs';\n      } else {\n        result = [];\n        if (hours === 1) {\n          result.push(hours + ' hr');\n        }\n        if (hours > 1) {\n          result.push(hours + ' hrs');\n        }\n        if (minutes > 0) {\n          result.push(minutes + ' min');\n        }\n        if (seconds > 0) {\n          result.push(seconds + ' sec');\n        }\n        if (result.length > 0) {\n          return result.join(' ');\n        } else {\n          return '-';\n        }\n      }\n    },\n    _normalizeDateString: function(string) {\n      if (window.JHW) {\n        string = string.replace('T', ' ').replace(/-/g, '/');\n        string = string.replace('Z', '').replace(/\\..*$/, '');\n      }\n      return string;\n    },\n    _nowUtc: function() {\n      return this._toUtc(new Date());\n    },\n    _toUtc: function(date) {\n      return Date.UTC(date.getFullYear(), date.getMonth(), date.getDate(), date.getHours(), date.getMinutes(), date.getSeconds(), date.getMilliseconds());\n    },\n    _emojize: function(text) {\n      var emojis;\n      emojis = text.match(/:\\S+?:/g);\n      if (emojis !== null) {\n        $.each(emojis.uniq(), function(ix, emoji) {\n          var image, strippedEmoji;\n          strippedEmoji = emoji.substring(1, emoji.length - 1);\n          if (EmojiDictionary.indexOf(strippedEmoji) !== -1) {\n            image = '<img class=\\'emoji\\' title=\\'' + emoji + '\\' alt=\\'' + emoji + '\\' src=\\'' + Travis.assets.host + '/' + Travis.assets.version + '/images/emoji/' + strippedEmoji + '.png\\'/>';\n            return text = text.replace(new RegExp(emoji, 'g'), image);\n          }\n        });\n      }\n      return text;\n    },\n    _escape: function(text) {\n      return text.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');\n    }\n  };\n\n}).call(this);\n\n})();\n//@ sourceURL=helpers/helpers");minispade.register('helpers/urls', "(function() {(function() {\n\n  this.Travis.Urls = {\n    Repository: {\n      urlGithub: (function() {\n        return 'http://github.com/%@'.fmt(this.get('slug'));\n      }).property('slug'),\n      urlGithubWatchers: (function() {\n        return 'http://github.com/%@/watchers'.fmt(this.get('slug'));\n      }).property('slug'),\n      urlGithubNetwork: (function() {\n        return 'http://github.com/%@/network'.fmt(this.get('slug'));\n      }).property('slug'),\n      urlGithubAdmin: (function() {\n        return 'http://github.com/%@/admin/hooks#travis_minibucket'.fmt(this.get('slug'));\n      }).property('slug'),\n      statusImage: (function() {\n        return '%@.png'.fmt(this.get('slug'));\n      }).property('slug')\n    },\n    Commit: {\n      urlGithubCommit: (function() {\n        return 'http://github.com/%@/commit/%@'.fmt(this.getPath('repository.slug'), this.getPath('commit.sha'));\n      }).property('repository.slug', 'commit.sha'),\n      urlAuthor: (function() {\n        return 'mailto:%@'.fmt(this.getPath('commit.authorEmail'));\n      }).property(),\n      urlCommitter: (function() {\n        return 'mailto:%@'.fmt(this.getPath('commit.committerEmail'));\n      }).property()\n    }\n  };\n\n}).call(this);\n\n})();\n//@ sourceURL=helpers/urls");minispade.register('models', "(function() {(function() {\nminispade.require('models/build');\nminispade.require('models/repository');\nminispade.require('models/commit');\nminispade.require('models/job');\nminispade.require('models/artifact');\n\n}).call(this);\n\n})();\n//@ sourceURL=models");minispade.register('models/artifact', "(function() {(function() {\nminispade.require('travis/model');\n\n  this.Travis.Artifact = Travis.Model.extend({\n    body: DS.attr('string')\n  });\n\n}).call(this);\n\n})();\n//@ sourceURL=models/artifact");minispade.register('models/branch', "(function() {(function() {\nminispade.require('travis/model');\n\n  this.Travis.Branch = Travis.Model.extend(Travis.Helpers, {\n    repository_id: DS.attr('number'),\n    number: DS.attr('number'),\n    branch: DS.attr('string'),\n    message: DS.attr('string'),\n    result: DS.attr('number'),\n    duration: DS.attr('number'),\n    started_at: DS.attr('string'),\n    finished_at: DS.attr('string'),\n    commit: DS.belongsTo('Travis.Commit'),\n    repository: (function() {\n      if (this.get('repository_id')) {\n        return Travis.Repository.find(this.get('repository_id'));\n      }\n    }).property('repository_id').cacheable(),\n    tick: function() {\n      this.notifyPropertyChange('started_at');\n      return this.notifyPropertyChange('finished_at');\n    }\n  });\n\n  this.Travis.Branch.reopenClass({\n    byRepositoryId: function(id) {\n      return this.find({\n        repository_id: id\n      });\n    }\n  });\n\n}).call(this);\n\n})();\n//@ sourceURL=models/branch");minispade.register('models/build', "(function() {(function() {\nminispade.require('travis/model');\n\n  this.Travis.Build = Travis.Model.extend({\n    state: DS.attr('string'),\n    number: DS.attr('number'),\n    branch: DS.attr('string'),\n    message: DS.attr('string'),\n    result: DS.attr('number'),\n    duration: DS.attr('number'),\n    started_at: DS.attr('string'),\n    finished_at: DS.attr('string'),\n    committed_at: DS.attr('string'),\n    committer_name: DS.attr('string'),\n    committer_email: DS.attr('string'),\n    author_name: DS.attr('string'),\n    author_email: DS.attr('string'),\n    compare_url: DS.attr('string'),\n    repository: DS.belongsTo('Travis.Repository'),\n    commit: DS.belongsTo('Travis.Commit'),\n    config: (function() {\n      return this.getPath('data.config');\n    }).property('data.config'),\n    jobs: (function() {\n      return Travis.Job.findMany(this.getPath('data.job_ids') || []);\n    }).property('data.job_ids.length'),\n    configKeys: (function() {\n      var config, headers, keys;\n      config = this.get('config');\n      if (!config) {\n        return [];\n      }\n      keys = $.keys($.only(config, 'rvm', 'gemfile', 'env', 'otp_release', 'php', 'node_js', 'perl', 'python', 'scala'));\n      headers = [I18n.t('build.job'), I18n.t('build.duration'), I18n.t('build.finished_at')];\n      return $.map(headers.concat(keys), function(key) {\n        return $.camelize(key);\n      });\n    }).property('config'),\n    tick: function() {\n      this.notifyPropertyChange('duration');\n      return this.notifyPropertyChange('finished_at');\n    }\n  });\n\n  this.Travis.Build.reopenClass({\n    byRepositoryId: function(id, parameters) {\n      return this.find($.extend(parameters || {}, {\n        repository_id: id,\n        orderBy: 'number DESC'\n      }));\n    },\n    olderThanNumber: function(id, build_number) {\n      return this.find({\n        url: '/repositories/' + id + '/builds.json?bare=true&after_number=' + build_number,\n        repository_id: id,\n        orderBy: 'number DESC'\n      });\n    }\n  });\n\n}).call(this);\n\n})();\n//@ sourceURL=models/build");minispade.register('models/commit', "(function() {(function() {\nminispade.require('travis/model');\n\n  this.Travis.Commit = Travis.Model.extend({\n    sha: DS.attr('string'),\n    branch: DS.attr('string'),\n    message: DS.attr('string'),\n    compareUrl: DS.attr('string'),\n    authorName: DS.attr('string'),\n    authorEmail: DS.attr('string'),\n    committerName: DS.attr('string'),\n    committerEmail: DS.attr('string'),\n    build: DS.belongsTo('Travis.Build')\n  });\n\n}).call(this);\n\n})();\n//@ sourceURL=models/commit");minispade.register('models/job', "(function() {(function() {\nminispade.require('travis/model');\n\n  this.Travis.Job = Travis.Model.extend({\n    repository_id: DS.attr('number'),\n    build_id: DS.attr('number'),\n    log_id: DS.attr('number'),\n    queue: DS.attr('string'),\n    state: DS.attr('string'),\n    number: DS.attr('string'),\n    result: DS.attr('number'),\n    duration: DS.attr('number'),\n    started_at: DS.attr('string'),\n    finished_at: DS.attr('string'),\n    allow_failure: DS.attr('boolean'),\n    repository: DS.belongsTo('Travis.Repository'),\n    commit: DS.belongsTo('Travis.Commit'),\n    build: DS.belongsTo('Travis.Build'),\n    log: DS.belongsTo('Travis.Artifact'),\n    config: (function() {\n      return this.getPath('data.config');\n    }).property('data.config'),\n    sponsor: (function() {\n      return this.getPath('data.sponsor');\n    }).property('data.sponsor'),\n    configValues: (function() {\n      var config;\n      config = this.get('config');\n      if (!config) {\n        return [];\n      }\n      return $.values($.only(config, 'rvm', 'gemfile', 'env', 'otp_release', 'php', 'node_js', 'scala', 'jdk', 'python', 'perl'));\n    }).property('config'),\n    appendLog: function(log) {\n      return this.set('log', this.get('log') + log);\n    },\n    subscribe: function() {\n      return Travis.app.subscribe('job-' + this.get('id'));\n    },\n    onStateChange: (function() {\n      if (this.get('state') === 'finished') {\n        return Travis.app.unsubscribe('job-' + this.get('id'));\n      }\n    }).observes('state'),\n    tick: function() {\n      this.notifyPropertyChange('duration');\n      return this.notifyPropertyChange('finished_at');\n    }\n  });\n\n  this.Travis.Job.reopenClass({\n    queued: function(queue) {\n      this.all();\n      return Travis.store.filter(this, function(job) {\n        return job.get('queue') === 'builds.' + queue;\n      });\n    },\n    findMany: function(ids) {\n      return Travis.store.findMany(this, ids);\n    }\n  });\n\n}).call(this);\n\n})();\n//@ sourceURL=models/job");minispade.register('models/repository', "(function() {(function() {\nminispade.require('travis/model');\n\n  this.Travis.Repository = Travis.Model.extend({\n    slug: DS.attr('string'),\n    description: DS.attr('string'),\n    lastBuildId: DS.attr('number'),\n    lastBuildNumber: DS.attr('string'),\n    lastBuildResult: DS.attr('number'),\n    lastBuildStarted_at: DS.attr('string'),\n    lastBuildFinished_at: DS.attr('string'),\n    primaryKey: 'slug',\n    lastBuild: DS.belongsTo('Travis.Build'),\n    builds: (function() {\n      return Travis.Build.byRepositoryId(this.get('id'), {\n        event_type: 'push'\n      });\n    }).property(),\n    pullRequests: (function() {\n      return Travis.Build.byRepositoryId(this.get('id'), {\n        event_type: 'pull_request'\n      });\n    }).property(),\n    owner: (function() {\n      return (this.get('slug') || this._id).split('/')[0];\n    }).property('owner', 'name'),\n    name: (function() {\n      return (this.get('slug') || this._id).split('/')[1];\n    }).property('owner', 'name'),\n    lastBuildDuration: (function() {\n      var duration;\n      duration = this.getPath('data.lastBuildDuration');\n      if (!duration) {\n        duration = Travis.Helpers.durationFrom(this.get('lastBuildStarted_at'), this.get('lastBuildFinished_at'));\n      }\n      return duration;\n    }).property('data.lastBuildDuration', 'lastBuildStartedAt', 'lastBuildFinishedAt'),\n    stats: (function() {}).property('slug'),\n    select: function() {\n      return Travis.Repository.select(self.get('id'));\n    },\n    tick: function() {\n      this.notifyPropertyChange('lastBuildDuration');\n      return this.notifyPropertyChange('lastBuildFinishedAt');\n    }\n  });\n\n  this.Travis.Repository.reopenClass({\n    recent: function() {\n      return this.find();\n    },\n    ownedBy: function(owner) {\n      return this.find({\n        owner: owner,\n        orderBy: 'name'\n      });\n    },\n    search: function(query) {\n      return this.find({\n        search: query,\n        orderBy: 'name'\n      });\n    },\n    bySlug: function(slug) {\n      var repo;\n      repo = $.detect(this.find().toArray(), function(repo) {\n        return repo.get('slug') === slug;\n      });\n      if (repo) {\n        return Ember.ArrayProxy.create({\n          content: [repo]\n        });\n      } else {\n        return this.find({\n          slug: slug\n        });\n      }\n    },\n    select: function(id) {\n      return this.find().forEach(function(repository) {\n        return repository.set('selected', repository.get('id') === id);\n      });\n    },\n    buildURL: function(slug) {\n      if (slug) {\n        return slug;\n      } else {\n        return 'repositories';\n      }\n    }\n  });\n\n}).call(this);\n\n})();\n//@ sourceURL=models/repository");minispade.register('models/service_hook', "(function() {(function() {\nminispade.require('travis/model');\n\n  this.Travis.ServiceHook = Travis.Model.extend({\n    primaryKey: 'slug',\n    name: DS.attr('string'),\n    owner_name: DS.attr('string'),\n    active: DS.attr('boolean'),\n    slug: (function() {\n      return [this.get('owner_name'), this.get('name')].join('/');\n    }).property(),\n    toggle: function() {\n      this.set('active', !this.get('active'));\n      return Travis.app.store.commit();\n    }\n  });\n\n  this.Travis.ServiceHook.reopenClass({\n    url: 'profile/service_hooks'\n  });\n\n}).call(this);\n\n})();\n//@ sourceURL=models/service_hook");minispade.register('models/worker', "(function() {(function() {\nminispade.require('travis/model');\n\n  this.Travis.WorkerGroup = Ember.ArrayProxy.extend({\n    init: function() {\n      return this.set('content', []);\n    },\n    host: (function() {\n      return this.getPath('firstObject.host');\n    }).property()\n  });\n\n  this.Travis.Worker = Travis.Model.extend({\n    state: DS.attr('string'),\n    name: DS.attr('string'),\n    host: DS.attr('string'),\n    lastSeenAt: DS.attr('string'),\n    isTesting: (function() {\n      return this.get('state') === 'working' && !!this.getPath('payload.config');\n    }).property('state', 'config'),\n    number: (function() {\n      return this.get('name').match(/\\d+$/)[0];\n    }).property('name'),\n    display: (function() {\n      var name, number, payload, repo, state;\n      name = this.get('name').replace('travis-', '');\n      state = this.get('state');\n      payload = this.get('payload');\n      if (state === 'working' && payload !== void 0) {\n        repo = payload.repository ? $.truncate(payload.repository.slug, 18) : void 0;\n        number = payload.build && payload.build.number ? ' #' + payload.build.number : '';\n        state = repo ? repo + number : state;\n      }\n      return name + ': ' + state;\n    }).property('state'),\n    urlJob: (function() {\n      return '#!/%@/jobs/%@'.fmt(this.getPath('payload.repository.slug'), this.getPath('payload.build.id'));\n    }).property('payload', 'state')\n  });\n\n}).call(this);\n\n})();\n//@ sourceURL=models/worker");minispade.register('routes', "(function() {(function() {\nminispade.require('hax0rs');\n\n  this.Travis.Router = Em.Router.extend({\n    enableLogging: true,\n    location: 'hash',\n    root: Em.Route.extend({\n      \"default\": Em.Route.extend({\n        route: '/',\n        viewCurrent: Ember.Route.transitionTo('repository.current'),\n        viewBuilds: Ember.Route.transitionTo('repository.builds'),\n        viewBuild: Ember.Route.transitionTo('repository.build'),\n        viewJob: Ember.Route.transitionTo('repository.job'),\n        connectOutlets: function(router) {\n          var repositories;\n          repositories = Travis.Repository.find();\n          router.set('repositories', repositories);\n          router.set('job', void 0);\n          return router.connectLeft(repositories);\n        },\n        index: Em.Route.extend({\n          route: '/',\n          connectOutlets: function(router) {\n            var repositories,\n              _this = this;\n            repositories = router.get('repositories');\n            return onceLoaded(repositories, function() {\n              var build, repository;\n              repository = repositories.get('firstObject');\n              build = Travis.Build.find(repository.get('lastBuildId'));\n              router.connectRepository(repository);\n              router.connectTabs();\n              return router.connectBuild(build);\n            });\n          }\n        }),\n        repository: Em.Route.extend({\n          route: '/:owner/:name',\n          serialize: function(router, repository) {\n            return router.serializeRepository(repository);\n          },\n          deserialize: function(router, params) {\n            return router.deserializeRepository(params);\n          },\n          connectOutlets: function(router, repository) {\n            return router.connectRepository(repository);\n          },\n          current: Em.Route.extend({\n            route: '/',\n            connectOutlets: function(router) {\n              var repository;\n              repository = router.get('repository');\n              return onceLoaded(repository, function() {\n                var build;\n                build = repository.get('lastBuild');\n                router.connectTabs();\n                return router.connectBuild(build);\n              });\n            }\n          }),\n          builds: Em.Route.extend({\n            route: '/builds',\n            connectOutlets: function(router) {\n              var repository,\n                _this = this;\n              repository = router.get('repository');\n              return onceLoaded(repository, function() {\n                router.connectTabs();\n                return router.connectBuilds(repository.get('builds'));\n              });\n            }\n          }),\n          build: Em.Route.extend({\n            route: '/builds/:build_id',\n            connectOutlets: function(router, build) {\n              if (!(build instanceof Travis.Build)) {\n                build = Travis.Build.find(build.id);\n              }\n              router.connectTabs(build);\n              return router.connectBuild(build);\n            }\n          }),\n          job: Em.Route.extend({\n            route: '/jobs/:job_id',\n            connectOutlets: function(router, job) {\n              if (!(job instanceof Travis.Job)) {\n                job = Travis.Job.find(job.id);\n              }\n              router.connectTabs(job.get('build'), job);\n              return router.connectJob(job);\n            }\n          })\n        })\n      })\n    }),\n    connectLeft: function(repositories) {\n      return this.get('applicationController').connectOutlet({\n        outletName: 'left',\n        name: 'repositories',\n        context: repositories\n      });\n    },\n    connectRepository: function(repository) {\n      this.set('repository', repository);\n      return this.get('applicationController').connectOutlet({\n        outletName: 'main',\n        name: 'repository',\n        context: repository\n      });\n    },\n    connectTabs: function(build, job) {\n      this.setPath('tabsController.repository', this.get('repository'));\n      this.setPath('tabsController.build', build);\n      this.setPath('tabsController.job', job);\n      return this.get('repositoryController').connectOutlet({\n        outletName: 'tabs',\n        name: 'tabs'\n      });\n    },\n    connectBuilds: function(builds) {\n      return this.get('repositoryController').connectOutlet({\n        outletName: 'tab',\n        name: 'history',\n        context: builds\n      });\n    },\n    connectBuild: function(build) {\n      return this.get('repositoryController').connectOutlet({\n        outletName: 'tab',\n        name: 'build',\n        context: build\n      });\n    },\n    connectJob: function(job) {\n      return this.get('repositoryController').connectOutlet({\n        outletName: 'tab',\n        name: 'job',\n        context: job\n      });\n    },\n    serializeRepository: function(object) {\n      var slug;\n      if (object instanceof DS.Model) {\n        slug = object.get('slug') || object._id;\n        return {\n          owner: slug.split('/')[0],\n          name: slug.split('/')[1]\n        };\n      } else {\n        return object;\n      }\n    },\n    deserializeRepository: function(params) {\n      return Travis.Repository.find(\"\" + params.owner + \"/\" + params.name);\n    }\n  });\n\n}).call(this);\n\n})();\n//@ sourceURL=routes");minispade.register('views', "(function() {(function() {\n\n  Travis.ApplicationView = Em.View.extend({\n    templateName: 'application'\n  });\n\n  Travis.RepositoriesView = Em.View.extend({\n    templateName: 'repositories/list'\n  });\n\n  Travis.RepositoriesItemView = Em.View.extend({\n    classes: (function() {\n      var classes, color;\n      color = Travis.Helpers.colorForResult(this.getPath('repository.lastBuildResult'));\n      classes = ['repository', color];\n      if (this.getPath('repository.selected')) {\n        classes.push('selected');\n      }\n      return classes.join(' ');\n    }).property('repository.lastBuildResult', 'repository.selected'),\n    lastBuild: (function() {\n      return {\n        owner: this.getPath('repository.owner'),\n        name: this.getPath('repository.name'),\n        id: this.getPath('repository.lastBuildId')\n      };\n    }).property('repository.owner', 'repository.name', 'repository.lastBuildId')\n  });\n\n  Travis.RepositoryView = Em.View.extend({\n    templateName: 'repositories/show'\n  });\n\n  Travis.TabsView = Em.View.extend({\n    templateName: 'repositories/tabs'\n  });\n\n  Travis.HistoryView = Em.View.extend({\n    templateName: 'builds/list'\n  });\n\n  Travis.BuildsItemView = Em.View.extend({\n    classes: (function() {\n      return Travis.Helpers.colorForResult(this.getPath('content.result'));\n    }).property('content.result')\n  });\n\n  Travis.BuildView = Em.View.extend({\n    templateName: 'builds/show',\n    classes: (function() {\n      return Travis.Helpers.colorForResult(this.get('result'));\n    }).property('result'),\n    isMatrix: (function() {\n      return this.getPath('context.data.job_ids.length') > 1;\n    }).property(),\n    requiredJobs: (function() {\n      return this.getPath('context.jobs').filter(function(job) {\n        return job.get('allow_failure') !== true;\n      });\n    }).property(),\n    allowedFailureJobs: (function() {\n      return this.getPath('context.jobs').filter(function(job) {\n        return job.get('allow_failure');\n      });\n    }).property()\n  });\n\n  Travis.JobsView = Em.View.extend({\n    templateName: 'jobs/list'\n  });\n\n  Travis.JobView = Em.View.extend({\n    templateName: 'jobs/show',\n    classes: (function() {\n      return Travis.Helpers.colorForResult(this.get('result'));\n    }).property('result')\n  });\n\n  Travis.LogView = Em.View.extend({\n    templateName: 'jobs/log'\n  });\n\n}).call(this);\n\n})();\n//@ sourceURL=views");minispade.register('emoij', "(function() {(function() {\n\n  this.EmojiDictionary = ['-1', '0', '1', '109', '2', '3', '4', '5', '6', '7', '8', '8ball', '9', 'a', 'ab', 'airplane', 'alien', 'ambulance', 'angel', 'anger', 'angry', 'apple', 'aquarius', 'aries', 'arrow_backward', 'arrow_down', 'arrow_forward', 'arrow_left', 'arrow_lower_left', 'arrow_lower_right', 'arrow_right', 'arrow_up', 'arrow_upper_left', 'arrow_upper_right', 'art', 'astonished', 'atm', 'b', 'baby', 'baby_chick', 'baby_symbol', 'balloon', 'bamboo', 'bank', 'barber', 'baseball', 'basketball', 'bath', 'bear', 'beer', 'beers', 'beginner', 'bell', 'bento', 'bike', 'bikini', 'bird', 'birthday', 'black_square', 'blue_car', 'blue_heart', 'blush', 'boar', 'boat', 'bomb', 'book', 'boot', 'bouquet', 'bow', 'bowtie', 'boy', 'bread', 'briefcase', 'broken_heart', 'bug', 'bulb', 'bullettrain_front', 'bullettrain_side', 'bus', 'busstop', 'cactus', 'cake', 'calling', 'camel', 'camera', 'cancer', 'capricorn', 'car', 'cat', 'cd', 'chart', 'checkered_flag', 'cherry_blossom', 'chicken', 'christmas_tree', 'church', 'cinema', 'city_sunrise', 'city_sunset', 'clap', 'clapper', 'clock1', 'clock10', 'clock11', 'clock12', 'clock2', 'clock3', 'clock4', 'clock5', 'clock6', 'clock7', 'clock8', 'clock9', 'closed_umbrella', 'cloud', 'clubs', 'cn', 'cocktail', 'coffee', 'cold_sweat', 'computer', 'confounded', 'congratulations', 'construction', 'construction_worker', 'convenience_store', 'cool', 'cop', 'copyright', 'couple', 'couple_with_heart', 'couplekiss', 'cow', 'crossed_flags', 'crown', 'cry', 'cupid', 'currency_exchange', 'curry', 'cyclone', 'dancer', 'dancers', 'dango', 'dart', 'dash', 'de', 'department_store', 'diamonds', 'disappointed', 'dog', 'dolls', 'dolphin', 'dress', 'dvd', 'ear', 'ear_of_rice', 'egg', 'eggplant', 'egplant', 'eight_pointed_black_star', 'eight_spoked_asterisk', 'elephant', 'email', 'es', 'european_castle', 'exclamation', 'eyes', 'factory', 'fallen_leaf', 'fast_forward', 'fax', 'fearful', 'feelsgood', 'feet', 'ferris_wheel', 'finnadie', 'fire', 'fire_engine', 'fireworks', 'fish', 'fist', 'flags', 'flushed', 'football', 'fork_and_knife', 'fountain', 'four_leaf_clover', 'fr', 'fries', 'frog', 'fuelpump', 'gb', 'gem', 'gemini', 'ghost', 'gift', 'gift_heart', 'girl', 'goberserk', 'godmode', 'golf', 'green_heart', 'grey_exclamation', 'grey_question', 'grin', 'guardsman', 'guitar', 'gun', 'haircut', 'hamburger', 'hammer', 'hamster', 'hand', 'handbag', 'hankey', 'hash', 'headphones', 'heart', 'heart_decoration', 'heart_eyes', 'heartbeat', 'heartpulse', 'hearts', 'hibiscus', 'high_heel', 'horse', 'hospital', 'hotel', 'hotsprings', 'house', 'hurtrealbad', 'icecream', 'id', 'ideograph_advantage', 'imp', 'information_desk_person', 'iphone', 'it', 'jack_o_lantern', 'japanese_castle', 'joy', 'jp', 'key', 'kimono', 'kiss', 'kissing_face', 'kissing_heart', 'koala', 'koko', 'kr', 'leaves', 'leo', 'libra', 'lips', 'lipstick', 'lock', 'loop', 'loudspeaker', 'love_hotel', 'mag', 'mahjong', 'mailbox', 'man', 'man_with_gua_pi_mao', 'man_with_turban', 'maple_leaf', 'mask', 'massage', 'mega', 'memo', 'mens', 'metal', 'metro', 'microphone', 'minidisc', 'mobile_phone_off', 'moneybag', 'monkey', 'monkey_face', 'moon', 'mortar_board', 'mount_fuji', 'mouse', 'movie_camera', 'muscle', 'musical_note', 'nail_care', 'necktie', 'new', 'no_good', 'no_smoking', 'nose', 'notes', 'o', 'o2', 'ocean', 'octocat', 'octopus', 'oden', 'office', 'ok', 'ok_hand', 'ok_woman', 'older_man', 'older_woman', 'open_hands', 'ophiuchus', 'palm_tree', 'parking', 'part_alternation_mark', 'pencil', 'penguin', 'pensive', 'persevere', 'person_with_blond_hair', 'phone', 'pig', 'pill', 'pisces', 'plus1', 'point_down', 'point_left', 'point_right', 'point_up', 'point_up_2', 'police_car', 'poop', 'post_office', 'postbox', 'pray', 'princess', 'punch', 'purple_heart', 'question', 'rabbit', 'racehorse', 'radio', 'rage', 'rage1', 'rage2', 'rage3', 'rage4', 'rainbow', 'raised_hands', 'ramen', 'red_car', 'red_circle', 'registered', 'relaxed', 'relieved', 'restroom', 'rewind', 'ribbon', 'rice', 'rice_ball', 'rice_cracker', 'rice_scene', 'ring', 'rocket', 'roller_coaster', 'rose', 'ru', 'runner', 'sa', 'sagittarius', 'sailboat', 'sake', 'sandal', 'santa', 'satellite', 'satisfied', 'saxophone', 'school', 'school_satchel', 'scissors', 'scorpius', 'scream', 'seat', 'secret', 'shaved_ice', 'sheep', 'shell', 'ship', 'shipit', 'shirt', 'shit', 'shoe', 'signal_strength', 'six_pointed_star', 'ski', 'skull', 'sleepy', 'slot_machine', 'smile', 'smiley', 'smirk', 'smoking', 'snake', 'snowman', 'sob', 'soccer', 'space_invader', 'spades', 'spaghetti', 'sparkler', 'sparkles', 'speaker', 'speedboat', 'squirrel', 'star', 'star2', 'stars', 'station', 'statue_of_liberty', 'stew', 'strawberry', 'sunflower', 'sunny', 'sunrise', 'sunrise_over_mountains', 'surfer', 'sushi', 'suspect', 'sweat', 'sweat_drops', 'swimmer', 'syringe', 'tada', 'tangerine', 'taurus', 'taxi', 'tea', 'telephone', 'tennis', 'tent', 'thumbsdown', 'thumbsup', 'ticket', 'tiger', 'tm', 'toilet', 'tokyo_tower', 'tomato', 'tongue', 'top', 'tophat', 'traffic_light', 'train', 'trident', 'trophy', 'tropical_fish', 'truck', 'trumpet', 'tshirt', 'tulip', 'tv', 'u5272', 'u55b6', 'u6307', 'u6708', 'u6709', 'u6e80', 'u7121', 'u7533', 'u7a7a', 'umbrella', 'unamused', 'underage', 'unlock', 'up', 'us', 'v', 'vhs', 'vibration_mode', 'virgo', 'vs', 'walking', 'warning', 'watermelon', 'wave', 'wc', 'wedding', 'whale', 'wheelchair', 'white_square', 'wind_chime', 'wink', 'wink2', 'wolf', 'woman', 'womans_hat', 'womens', 'x', 'yellow_heart', 'zap', 'zzz'];\n\n}).call(this);\n\n})();\n//@ sourceURL=emoij");minispade.register('ext/jquery', "(function() {(function() {\n\n  $.fn.extend({\n    outerHtml: function() {\n      return $(this).wrap('<div></div>').parent().html();\n    },\n    outerElement: function() {\n      return $($(this).outerHtml()).empty();\n    },\n    flash: function() {\n      return Utils.flash(this);\n    },\n    unflash: function() {\n      return Utils.unflash(this);\n    },\n    filterLog: function() {\n      this.deansi();\n      return this.foldLog();\n    },\n    deansi: function() {\n      return this.html(Utils.deansi(this.html()));\n    },\n    foldLog: function() {\n      return this.html(Utils.foldLog(this.html()));\n    },\n    unfoldLog: function() {\n      return this.html(Utils.unfoldLog(this.html()));\n    },\n    updateTimes: function() {\n      return Utils.updateTimes(this);\n    },\n    activateTab: function(tab) {\n      return Utils.activateTab(this, tab);\n    },\n    timeInWords: function() {\n      return $(this).each(function() {\n        return $(this).text(Utils.timeInWords(parseInt($(this).attr('title'))));\n      });\n    },\n    updateGithubStats: function(repository) {\n      return Utils.updateGithubStats(repository, $(this));\n    }\n  });\n\n  $.extend({\n    keys: function(obj) {\n      var keys;\n      keys = [];\n      $.each(obj, function(key) {\n        return keys.push(key);\n      });\n      return keys;\n    },\n    values: function(obj) {\n      var values;\n      values = [];\n      $.each(obj, function(key, value) {\n        return values.push(value);\n      });\n      return values;\n    },\n    camelize: function(string, uppercase) {\n      if (uppercase || typeof uppercase === 'undefined') {\n        string = $.capitalize(string);\n      }\n      return string.replace(/_(.)?/g, function(match, chr) {\n        if (chr) {\n          return chr.toUpperCase();\n        } else {\n          return '';\n        }\n      });\n    },\n    capitalize: function(string) {\n      return string[0].toUpperCase() + string.substring(1);\n    },\n    compact: function(array) {\n      return $.grep(array, function(value) {\n        return !!value;\n      });\n    },\n    all: function(array, callback) {\n      var args, i;\n      args = Array.prototype.slice.apply(arguments);\n      callback = args.pop();\n      array = args.pop() || this;\n      i = 0;\n      while (i < array.length) {\n        if (callback(array[i])) {\n          return false;\n        }\n        i++;\n      }\n      return true;\n    },\n    detect: function(array, callback) {\n      var args, i;\n      args = Array.prototype.slice.apply(arguments);\n      callback = args.pop();\n      array = args.pop() || this;\n      i = 0;\n      while (i < array.length) {\n        if (callback(array[i])) {\n          return array[i];\n        }\n        i++;\n      }\n    },\n    select: function(array, callback) {\n      var args, i, result;\n      args = Array.prototype.slice.apply(arguments);\n      callback = args.pop();\n      array = args.pop() || this;\n      result = [];\n      i = 0;\n      while (i < array.length) {\n        if (callback(array[i])) {\n          result.push(array[i]);\n        }\n        i++;\n      }\n      return result;\n    },\n    slice: function(object, key) {\n      var keys, result;\n      keys = Array.prototype.slice.apply(arguments);\n      object = (typeof keys[0] === 'object' ? keys.shift() : this);\n      result = {};\n      for (key in object) {\n        if (keys.indexOf(key) > -1) {\n          result[key] = object[key];\n        }\n      }\n      return result;\n    },\n    only: function(object) {\n      var key, keys, result;\n      keys = Array.prototype.slice.apply(arguments);\n      object = (typeof keys[0] === 'object' ? keys.shift() : this);\n      result = {};\n      for (key in object) {\n        if (keys.indexOf(key) !== -1) {\n          result[key] = object[key];\n        }\n      }\n      return result;\n    },\n    except: function(object) {\n      var key, keys, result;\n      keys = Array.prototype.slice.apply(arguments);\n      object = (typeof keys[0] === 'object' ? keys.shift() : this);\n      result = {};\n      for (key in object) {\n        if (keys.indexOf(key) === -1) {\n          result[key] = object[key];\n        }\n      }\n      return result;\n    },\n    map: function(elems, callback, arg) {\n      var i, isArray, key, length, ret, value;\n      value = void 0;\n      key = void 0;\n      ret = [];\n      i = 0;\n      length = elems.length;\n      isArray = elems instanceof jQuery || length !== void 0 && typeof length === 'number' && (length > 0 && elems[0] && elems[length - 1]) || length === 0 || jQuery.isArray(elems);\n      if (isArray) {\n        while (i < length) {\n          value = callback(elems[i], i, arg);\n          if (value != null) {\n            ret[ret.length] = value;\n          }\n          i++;\n        }\n      } else {\n        for (key in elems) {\n          value = callback(elems[key], key, arg);\n          if (value != null) {\n            ret[ret.length] = value;\n          }\n        }\n      }\n      return ret.concat.apply([], ret);\n    },\n    truncate: function(string, length) {\n      if (string.length > length) {\n        return string.trim().substring(0, length) + '...';\n      } else {\n        return string;\n      }\n    }\n  });\n\n}).call(this);\n\n})();\n//@ sourceURL=ext/jquery");minispade.register('hax0rs', "(function() {(function() {\n\n  window.onTrue = function(object, path, callback) {\n    var observer;\n    if (object.getPath(path)) {\n      return callback();\n    } else {\n      observer = function() {\n        object.removeObserver(path, observer);\n        return callback();\n      };\n      return object.addObserver(path, observer);\n    }\n  };\n\n  window.onceLoaded = function() {\n    var callback, object, objects, path;\n    objects = Array.prototype.slice.apply(arguments);\n    callback = objects.pop();\n    objects = ((function() {\n      var _i, _len, _results;\n      _results = [];\n      for (_i = 0, _len = objects.length; _i < _len; _i++) {\n        object = objects[_i];\n        _results.push(object || null);\n      }\n      return _results;\n    })()).compact();\n    object = objects.shift();\n    if (object) {\n      path = Ember.isArray(object) ? 'firstObject.isLoaded' : 'isLoaded';\n      return onTrue(object, path, function() {\n        if (objects.length === 0) {\n          return callback(object);\n        } else {\n          return onceLoaded.apply(objects + [callback]);\n        }\n      });\n    } else {\n      return callback(object);\n    }\n  };\n\n}).call(this);\n\n})();\n//@ sourceURL=hax0rs");minispade.register('travis/data_store/fixture_adapter', "(function() {(function() {\n\n  this.Travis.FixtureAdapter = DS.Adapter.extend({\n    find: function(store, type, id) {\n      var fixtures;\n      fixtures = type.FIXTURES;\n      Ember.assert(\"Unable to find fixtures for model type \" + type.toString(), !!fixtures);\n      if (fixtures.hasLoaded) {\n        return;\n      }\n      return setTimeout((function() {\n        store.loadMany(type, fixtures);\n        return fixtures.hasLoaded = true;\n      }), 300);\n    },\n    findMany: function() {\n      return this.find.apply(this, arguments);\n    },\n    findAll: function(store, type) {\n      var fixtures, ids;\n      fixtures = type.FIXTURES;\n      Ember.assert(\"Unable to find fixtures for model type \" + type.toString(), !!fixtures);\n      ids = fixtures.map(function(item, index, self) {\n        return item.id;\n      });\n      return store.loadMany(type, ids, fixtures);\n    },\n    findQuery: function(store, type, params, array) {\n      var fixture, fixtures, hashes, key, matches, value;\n      fixtures = type.FIXTURES;\n      Ember.assert(\"Unable to find fixtures for model type \" + type.toString(), !!fixtures);\n      hashes = (function() {\n        var _i, _len, _results;\n        _results = [];\n        for (_i = 0, _len = fixtures.length; _i < _len; _i++) {\n          fixture = fixtures[_i];\n          matches = (function() {\n            var _results1;\n            _results1 = [];\n            for (key in params) {\n              value = params[key];\n              _results1.push(key === 'orderBy' || fixture[key] === value);\n            }\n            return _results1;\n          })();\n          if (matches.reduce(function(a, b) {\n            return a && b;\n          })) {\n            _results.push(fixture);\n          } else {\n            _results.push(null);\n          }\n        }\n        return _results;\n      })();\n      return array.load(hashes.compact());\n    }\n  });\n\n}).call(this);\n\n})();\n//@ sourceURL=travis/data_store/fixture_adapter");minispade.register('travis/data_store/rest_adapter', "(function() {(function() {\n\n  this.Travis.RestAdapter = DS.RESTAdapter.extend({\n    init: function() {\n      this._super();\n      return this.set('mappings', {\n        builds: Travis.Build,\n        commits: Travis.Commit,\n        jobs: Travis.Job,\n        service_hooks: Travis.ServiceHook\n      });\n    },\n    plurals: {\n      repository: 'repositories',\n      branch: 'branches'\n    },\n    find: function(store, type, id) {\n      var url;\n      url = '/' + type.buildURL(id);\n      console.log(\"find: \" + url);\n      return this.ajax(url, 'GET', {\n        success: function(json) {\n          var root;\n          root = type.singularName();\n          this.sideload(store, type, json, root);\n          return store.load(type, json[root]);\n        },\n        accepts: {\n          json: 'application/vnd.travis-ci.2+json'\n        }\n      });\n    },\n    findMany: function(store, type, ids) {\n      var url;\n      url = '/' + type.buildURL();\n      console.log(\"findMany: \" + url);\n      return this.ajax(url, 'GET', {\n        data: {\n          ids: ids\n        },\n        success: function(json) {\n          var root;\n          root = type.pluralName();\n          this.sideload(store, type, json, root);\n          return store.loadMany(type, json[root]);\n        },\n        accepts: {\n          json: 'application/vnd.travis-ci.2+json'\n        }\n      });\n    },\n    findAll: function(store, type) {\n      var url;\n      url = '/' + type.buildURL();\n      console.log(\"findAll: \" + url);\n      return this.ajax(url, 'GET', {\n        success: function(json) {\n          var root;\n          root = type.pluralName();\n          this.sideload(store, type, json, root);\n          return store.loadMany(type, json[root]);\n        },\n        accepts: {\n          json: 'application/vnd.travis-ci.2+json'\n        }\n      });\n    },\n    findQuery: function(store, type, query, recordArray) {\n      var url;\n      url = '/' + type.buildURL();\n      console.log(\"findQuery: \" + url + \" (\" + query + \")\");\n      return this.ajax(url, 'GET', {\n        data: query,\n        success: function(json) {\n          var root;\n          root = type.pluralName();\n          this.sideload(store, type, json, root);\n          return recordArray.load(json[root]);\n        },\n        accepts: {\n          json: 'application/vnd.travis-ci.2+json'\n        }\n      });\n    },\n    updateRecord: function(store, type, record) {\n      var data, id, url;\n      id = get(record, record.get('primaryKey') || 'id');\n      url = '/' + type.buildURL(id);\n      data = {\n        root: record.toJSON()\n      };\n      return this.ajax(url, 'PUT', {\n        data: data,\n        success: function(json) {\n          var root;\n          root = type.singularName();\n          this.sideload(store, type, json, root);\n          return store.didUpdateRecord(record, json && json[root]);\n        }\n      });\n    }\n  });\n\n}).call(this);\n\n})();\n//@ sourceURL=travis/data_store/rest_adapter");minispade.register('travis/log', "(function() {(function() {\n\n  this.Travis.Log = {\n    FOLDS: {\n      schema: /(<p.*?\\/a>\\$ (?:bundle exec )?rake( db:create)? db:schema:load[\\s\\S]*?<p.*?\\/a>-- assume_migrated_upto_version[\\s\\S]*?<\\/p>\\n<p.*?\\/a>.*<\\/p>)/g,\n      migrate: /(<p.*?\\/a>\\$ (?:bundle exec )?rake( db:create)? db:migrate[\\s\\S]*== +\\w+: migrated \\(.*\\) =+)/g,\n      bundle: /(<p.*?\\/a>\\$ bundle install.*<\\/p>\\n(<p.*?\\/a>(Updating|Using|Installing|Fetching|remote:|Receiving|Resolving).*?<\\/p>\\n|<p.*?\\/a><\\/p>\\n)*)/g,\n      exec: /(<p.*?\\/a>[\\/\\w]*.rvm\\/rubies\\/[\\S]*?\\/(ruby|rbx|jruby) .*?<\\/p>)/g\n    },\n    filter: function(log) {\n      log = this.escape(log);\n      log = this.deansi(log);\n      log = log.replace(/\\r/g, '');\n      log = this.number(log);\n      log = this.fold(log);\n      log = log.replace(/\\n/g, '');\n      return log;\n    },\n    stripPaths: function(log) {\n      return log.replace(/\\/home\\/vagrant\\/builds(\\/[^\\/\\n]+){2}\\//g, '');\n    },\n    escape: function(log) {\n      return Handlebars.Utils.escapeExpression(log);\n    },\n    escapeRuby: function(log) {\n      return log.replace(/#<(\\w+.*?)>/, '#&lt;$1&gt;');\n    },\n    number: function(log) {\n      var result;\n      result = '';\n      $.each(log.trim().split('\\n'), function(ix, line) {\n        var number, path;\n        number = ix + 1;\n        path = Travis.Log.location().substr(1).replace(/\\/L\\d+/, '') + '/L' + number;\n        return result += '<p><a href=\\'#%@\\' id=\\'%@\\' name=\\'L%@\\'>%@</a>%@</p>\\n'.fmt(path, path, number, number, line);\n      });\n      return result.trim();\n    },\n    deansi: function(log) {\n      var ansi, text;\n      log = log.replace(/\\r\\r/g, '\\r').replace(/\\033\\[K\\r/g, '\\r').replace(/^.*\\r(?!$)/g, '').replace(/\u001b\\[2K/g, '').replace(/\\033\\(B/g, '');\n      ansi = ansiparse(log);\n      text = '';\n      ansi.forEach(function(part) {\n        var classes;\n        classes = [];\n        part.foreground && classes.push(part.foreground);\n        part.background && classes.push('bg-' + part.background);\n        part.bold && classes.push('bold');\n        part.italic && classes.push('italic');\n        return text += (classes.length ? '<span class=\\'' + classes.join(' ') + '\\'>' + part.text + '</span>' : part.text);\n      });\n      return text.replace(/\\033/g, '');\n    },\n    fold: function(log) {\n      log = this.unfold(log);\n      $.each(Travis.Log.FOLDS, function(name, pattern) {\n        return log = log.replace(pattern, function() {\n          return '<div class=\\'fold ' + name + '\\'>' + arguments[1].trim() + '</div>';\n        });\n      });\n      return log;\n    },\n    unfold: function(log) {\n      return log.replace(/<div class='fold[^']*'>([\\s\\S]*?)<\\/div>/g, '$1\\n');\n    },\n    location: function() {\n      return window.location.hash;\n    }\n  };\n\n}).call(this);\n\n})();\n//@ sourceURL=travis/log");minispade.register('travis/model', "(function() {(function() {\n\n  this.Travis.Model = DS.Model.extend({\n    primaryKey: 'id',\n    id: DS.attr('number'),\n    refresh: function() {\n      var id;\n      id = this.get('id');\n      if (id) {\n        return Travis.store.adapter.find(Travis.store, this.constructor, id);\n      }\n    },\n    update: function(attrs) {\n      var _this = this;\n      $.each(attrs, function(key, value) {\n        if (key !== 'id') {\n          return _this.set(key, value);\n        }\n      });\n      return this;\n    }\n  });\n\n  this.Travis.Model.reopenClass({\n    load: function(attrs) {\n      return Travis.store.load(this, attrs);\n    },\n    buildURL: function(suffix) {\n      var base, url;\n      base = this.url || this.pluralName();\n      Ember.assert('Base URL (' + base + ') must not start with slash', !base || base.toString().charAt(0) !== '/');\n      Ember.assert('URL suffix (' + suffix + ') must not start with slash', !suffix || suffix.toString().charAt(0) !== '/');\n      url = [base];\n      if (suffix !== void 0) {\n        url.push(suffix);\n      }\n      return url.join('/');\n    },\n    singularName: function() {\n      var name, parts;\n      parts = this.toString().split('.');\n      name = parts[parts.length - 1];\n      return name.replace(/([A-Z])/g, '_$1').toLowerCase().slice(1);\n    },\n    pluralName: function() {\n      return Travis.store.adapter.pluralize(this.singularName());\n    }\n  });\n\n}).call(this);\n\n})();\n//@ sourceURL=travis/model");minispade.register('travis/ticker', "(function() {(function() {\n\n  this.Travis.Ticker = Ember.Object.extend({\n    init: function() {\n      this._super();\n      return this.schedule();\n    },\n    tick: function() {\n      var context,\n        _this = this;\n      context = this.get('context');\n      this.get('targets').forEach(function(target) {\n        target = context.get(target);\n        if (!target) {\n          return;\n        }\n        if (target.forEach) {\n          return target.forEach(function(target) {\n            return target.tick();\n          });\n        } else {\n          return target.tick();\n        }\n      });\n      return this.schedule();\n    },\n    schedule: function() {\n      var _this = this;\n      return Ember.run.later((function() {\n        return _this.tick();\n      }), Travis.app.TICK_INTERVAL);\n    }\n  });\n\n}).call(this);\n\n})();\n//@ sourceURL=travis/ticker");minispade.register('i18n', "(function() {console.log('FOO')\nvar I18n = I18n || {};\nI18n.translations = {\"ca\":{\"locales\":{\"en\":\"English\",\"es\":\"Español\",\"fr\":\"Français\",\"ja\":\"日本語\",\"nb\":\"Norsk Bokmål\",\"nl\":\"Nederlands\",\"pl\":\"Polski\",\"pt-BR\":\"português brasileiro\",\"ru\":\"Русский\"}},\"en\":{\"errors\":{\"messages\":{\"not_found\":\"not found\",\"already_confirmed\":\"was already confirmed\",\"not_locked\":\"was not locked\"}},\"devise\":{\"failure\":{\"unauthenticated\":\"You need to sign in or sign up before continuing.\",\"unconfirmed\":\"You have to confirm your account before continuing.\",\"locked\":\"Your account is locked.\",\"invalid\":\"Invalid email or password.\",\"invalid_token\":\"Invalid authentication token.\",\"timeout\":\"Your session expired, please sign in again to continue.\",\"inactive\":\"Your account was not activated yet.\"},\"sessions\":{\"signed_in\":\"Signed in successfully.\",\"signed_out\":\"Signed out successfully.\"},\"passwords\":{\"send_instructions\":\"You will receive an email with instructions about how to reset your password in a few minutes.\",\"updated\":\"Your password was changed successfully. You are now signed in.\"},\"confirmations\":{\"send_instructions\":\"You will receive an email with instructions about how to confirm your account in a few minutes.\",\"confirmed\":\"Your account was successfully confirmed. You are now signed in.\"},\"registrations\":{\"signed_up\":\"You have signed up successfully. If enabled, a confirmation was sent to your e-mail.\",\"updated\":\"You updated your account successfully.\",\"destroyed\":\"Bye! Your account was successfully cancelled. We hope to see you again soon.\"},\"unlocks\":{\"send_instructions\":\"You will receive an email with instructions about how to unlock your account in a few minutes.\",\"unlocked\":\"Your account was successfully unlocked. You are now signed in.\"},\"mailer\":{\"confirmation_instructions\":{\"subject\":\"Confirmation instructions\"},\"reset_password_instructions\":{\"subject\":\"Reset password instructions\"},\"unlock_instructions\":{\"subject\":\"Unlock Instructions\"}}},\"datetime\":{\"distance_in_words\":{\"hours_exact\":{\"one\":\"%{count} hour\",\"other\":\"%{count} hours\"},\"minutes_exact\":{\"one\":\"%{count} minute\",\"other\":\"%{count} minutes\"},\"seconds_exact\":{\"one\":\"%{count} second\",\"other\":\"%{count} seconds\"}}},\"workers\":\"Workers\",\"queue\":\"Queue\",\"no_job\":\"There are no jobs\",\"repositories\":{\"branch\":\"Branch\",\"image_url\":\"Image URL\",\"markdown\":\"Markdown\",\"textile\":\"Textile\",\"rdoc\":\"RDOC\",\"commit\":\"Commit\",\"message\":\"Message\",\"started_at\":\"Started\",\"duration\":\"Duration\",\"finished_at\":\"Finished\",\"tabs\":{\"current\":\"Current\",\"build_history\":\"Build History\",\"branches\":\"Branch Summary\",\"pull_requests\":\"Pull Requests\",\"build\":\"Build\",\"job\":\"Job\"}},\"build\":{\"job\":\"Job\",\"duration\":\"Duration\",\"finished_at\":\"Finished\"},\"jobs\":{\"messages\":{\"sponsored_by\":\"This test suite was run on a worker box sponsored by\"},\"build_matrix\":\"Build Matrix\",\"allowed_failures\":\"Allowed Failures\",\"author\":\"Author\",\"config\":\"Config\",\"compare\":\"Compare\",\"committer\":\"Committer\",\"branch\":\"Branch\",\"commit\":\"Commit\",\"message\":\"Message\",\"started_at\":\"Started\",\"duration\":\"Duration\",\"finished_at\":\"Finished\"},\"builds\":{\"name\":\"Build\",\"messages\":{\"sponsored_by\":\"This test suite was run on a worker box sponsored by\"},\"build_matrix\":\"Build Matrix\",\"allowed_failures\":\"Allowed Failures\",\"author\":\"Author\",\"config\":\"Config\",\"compare\":\"Compare\",\"committer\":\"Committer\",\"branch\":\"Branch\",\"commit\":\"Commit\",\"message\":\"Message\",\"started_at\":\"Started\",\"duration\":\"Duration\",\"finished_at\":\"Finished\",\"show_more\":\"Show more\"},\"layouts\":{\"top\":{\"home\":\"Home\",\"blog\":\"Blog\",\"docs\":\"Docs\",\"stats\":\"Stats\",\"github_login\":\"Sign in with Github\",\"profile\":\"Profile\",\"sign_out\":\"Sign Out\",\"admin\":\"Admin\"},\"application\":{\"fork_me\":\"Fork me on Github\",\"recent\":\"Recent\",\"search\":\"Search\",\"sponsers\":\"Sponsors\",\"sponsors_link\":\"See all of our amazing sponsors &rarr;\",\"my_repositories\":\"My Repositories\"},\"about\":{\"alpha\":\"This stuff is alpha.\",\"messages\":{\"alpha\":\"Please do <strong>not</strong> consider this a stable service. We're still far from that! More info <a href='https://github.com/travis-ci'>here.</a>\"},\"join\":\"Join us and help!\",\"mailing_list\":\"Mailing List\",\"repository\":\"Repository\",\"twitter\":\"Twitter\"},\"mobile\":{\"author\":\"Author\",\"build\":\"Build\",\"build_matrix\":\"Build Matrix\",\"commit\":\"Commit\",\"committer\":\"Committer\",\"compare\":\"Compare\",\"config\":\"Config\",\"duration\":\"Duration\",\"finished_at\":\"Finished at\",\"job\":\"Job\",\"log\":\"Log\"}},\"profiles\":{\"show\":{\"email\":\"Email\",\"github\":\"Github\",\"message\":{\"your_repos\":\"  Flick the switches below to turn on the Travis service hook for your projects, then push to GitHub.<br />\\n  To test against multiple rubies, see\",\"config\":\"how to configure custom build options\"},\"messages\":{\"notice\":\"To get started, please read our <a href=\\\"http://about.travis-ci.org/docs/user/getting-started/\\\">Getting Started guide</a>.\\n  <small>It will only take a couple of minutes.</small>\"},\"token\":\"Token\",\"your_repos\":\"Your Repositories\",\"update\":\"Update\",\"update_locale\":\"Update\",\"your_locale\":\"Your Locale\"}},\"statistics\":{\"index\":{\"count\":\"Count\",\"repo_growth\":\"Repository Growth\",\"total_projects\":\"Total Projects/Repositories\",\"build_count\":\"Build Count\",\"last_month\":\"last month\",\"total_builds\":\"Total Builds\"}},\"locales\":{\"en\":\"English\",\"es\":\"Español\",\"fr\":\"Français\",\"ja\":\"日本語\",\"nb\":\"Norsk Bokmål\",\"pl\":\"Polski\",\"ru\":\"Русский\",\"nl\":\"Nederlands\",\"pt-BR\":\"português brasileiro\"}},\"es\":{\"datetime\":{\"distance_in_words\":{\"hours_exact\":{\"one\":\"%{count} hora\",\"other\":\"%{count} horas\"},\"minutes_exact\":{\"one\":\"%{count} minuto\",\"other\":\"%{count} minutos\"},\"seconds_exact\":{\"one\":\"%{count} segundo\",\"other\":\"%{count} segundos\"}}},\"workers\":\"Procesos\",\"queue\":\"Cola\",\"no_job\":\"No hay trabajos\",\"repositories\":{\"branch\":\"Rama\",\"image_url\":\"Imagen URL\",\"markdown\":\"Markdown\",\"textile\":\"Textile\",\"rdoc\":\"RDOC\",\"commit\":\"Commit\",\"message\":\"Mensaje\",\"started_at\":\"Iniciado\",\"duration\":\"Duración\",\"finished_at\":\"Finalizado\",\"tabs\":{\"current\":\"Actual\",\"build_history\":\"Histórico\",\"branches\":\"Ramas\",\"build\":\"Builds\",\"job\":\"Trabajo\"}},\"build\":{\"job\":\"Trabajo\",\"duration\":\"Duración\",\"finished_at\":\"Finalizado\"},\"jobs\":{\"messages\":{\"sponsored_by\":\"Esta serie de tests han sido ejecutados en una caja de Proceso patrocinada por\"},\"build_matrix\":\"Matriz de Builds\",\"allowed_failures\":\"Fallos Permitidos\",\"author\":\"Autor\",\"config\":\"Configuración\",\"compare\":\"Comparar\",\"committer\":\"Committer\",\"branch\":\"Rama\",\"commit\":\"Commit\",\"message\":\"Mensaje\",\"started_at\":\"Iniciado\",\"duration\":\"Duración\",\"finished_at\":\"Finalizado\",\"sponsored_by\":\"Patrocinado por\"},\"builds\":{\"name\":\"Build\",\"messages\":{\"sponsored_by\":\"Esta serie de tests han sido ejecutados en una caja de Proceso patrocinada por\"},\"build_matrix\":\"Matriz de Builds\",\"allowed_failures\":\"Fallos Permitidos\",\"author\":\"Autor\",\"config\":\"Configuración\",\"compare\":\"Comparar\",\"committer\":\"Committer\",\"branch\":\"Rama\",\"commit\":\"Commit\",\"message\":\"Mensaje\",\"started_at\":\"Iniciado\",\"duration\":\"Duración\",\"finished_at\":\"Finalizado\"},\"layouts\":{\"top\":{\"home\":\"Inicio\",\"blog\":\"Blog\",\"docs\":\"Documentación\",\"stats\":\"Estadísticas\",\"github_login\":\"Iniciar sesión con Github\",\"profile\":\"Perfil\",\"sign_out\":\"Desconectar\",\"admin\":\"Admin\"},\"application\":{\"fork_me\":\"Hazme un Fork en Github\",\"recent\":\"Reciente\",\"search\":\"Buscar\",\"sponsers\":\"Patrocinadores\",\"sponsors_link\":\"Ver todos nuestros patrocinadores &rarr;\",\"my_repositories\":\"Mis Repositorios\"},\"about\":{\"alpha\":\"Esto es alpha.\",\"messages\":{\"alpha\":\"Por favor <strong>no</strong> considereis esto un servicio estable. Estamos estamos aún lejos de ello! Más información <a href='https://github.com/travis-ci'>aquí.</a>\"},\"join\":\"Únetenos y ayudanos!\",\"mailing_list\":\"Lista de Correos\",\"repository\":\"Repositorio\",\"twitter\":\"Twitter\"}},\"profiles\":{\"show\":{\"email\":\"Correo electrónico\",\"github\":\"Github\",\"message\":{\"your_repos\":\"  Activa los interruptores para inicial el  Travis service hook para tus proyectos, y haz un Push en GitHub.<br />\\n  Para probar varias versiones de ruby, mira\",\"config\":\"como configurar tus propias opciones para el Build\"},\"messages\":{\"notice\":\"Para comenzar, por favor lee nuestra <a href=\\\"http://about.travis-ci.org/docs/user/getting-started/\\\">Guía de Inicio </a>.\\n  <small>Solo tomará unos pocos minutos.</small>\"},\"token\":\"Token\",\"your_repos\":\"Tus repositorios\",\"update\":\"Actualizar\",\"update_locale\":\"Actualizar\",\"your_locale\":\"Tu Idioma\"}},\"statistics\":{\"index\":{\"count\":\"Número\",\"repo_growth\":\"Crecimiento de Repositorios\",\"total_projects\":\"Total de Proyectos/Repositorios\",\"build_count\":\"Número de Builds\",\"last_month\":\"mes anterior\",\"total_builds\":\"Total de Builds\"}},\"locales\":{\"en\":\"English\",\"es\":\"Español\",\"fr\":\"Français\",\"ja\":\"日本語\",\"nb\":\"Norsk Bokmål\",\"pl\":\"Polski\",\"ru\":\"Русский\",\"nl\":\"Nederlands\",\"pt-BR\":\"português brasileiro\"}},\"fr\":{\"datetime\":{\"distance_in_words\":{\"hours_exact\":{\"one\":\"%{count} heure\",\"other\":\"%{count} heures\"},\"minutes_exact\":{\"one\":\"%{count} minute\",\"other\":\"%{count} minutes\"},\"seconds_exact\":{\"one\":\"%{count} seconde\",\"other\":\"%{count} secondes\"}}},\"workers\":\"Processus\",\"queue\":\"File\",\"no_job\":\"Pas de tâches\",\"repositories\":{\"branch\":\"Branche\",\"image_url\":\"Image\",\"markdown\":\"Markdown\",\"textile\":\"Textile\",\"rdoc\":\"RDOC\",\"commit\":\"Commit\",\"message\":\"Message\",\"started_at\":\"Commencé\",\"duration\":\"Durée\",\"finished_at\":\"Terminé\",\"tabs\":{\"current\":\"Actuel\",\"build_history\":\"Historique des tâches\",\"branches\":\"Résumé des branches\",\"build\":\"Construction\",\"job\":\"Tâche\"}},\"build\":{\"job\":\"Tâche\",\"duration\":\"Durée\",\"finished_at\":\"Terminé\"},\"jobs\":{\"messages\":{\"sponsored_by\":\"Cette série de tests a été exécutée sur une machine sponsorisée par\"},\"build_matrix\":\"Matrice des versions\",\"allowed_failures\":\"Échecs autorisés\",\"author\":\"Auteur\",\"config\":\"Config\",\"compare\":\"Comparer\",\"committer\":\"Committeur\",\"branch\":\"Branche\",\"commit\":\"Commit\",\"message\":\"Message\",\"started_at\":\"Commencé\",\"duration\":\"Durée\",\"finished_at\":\"Terminé\",\"sponsored_by\":\"Cette série de tests a été exécutée sur une machine sponsorisée par\"},\"builds\":{\"name\":\"Version\",\"messages\":{\"sponsored_by\":\"Cette série de tests a été exécutée sur une machine sponsorisée par\"},\"build_matrix\":\"Matrice des versions\",\"allowed_failures\":\"Échecs autorisés\",\"author\":\"Auteur\",\"config\":\"Config\",\"compare\":\"Comparer\",\"committer\":\"Committeur\",\"branch\":\"Branche\",\"commit\":\"Commit\",\"message\":\"Message\",\"started_at\":\"Commencé\",\"duration\":\"Durée\",\"finished_at\":\"Terminé\"},\"layouts\":{\"top\":{\"home\":\"Accueil\",\"blog\":\"Blog\",\"docs\":\"Documentation\",\"stats\":\"Statistiques\",\"github_login\":\"Connection Github\",\"profile\":\"Profil\",\"sign_out\":\"Déconnection\",\"admin\":\"Admin\"},\"application\":{\"fork_me\":\"Faites un Fork sur Github\",\"recent\":\"Récent\",\"search\":\"Chercher\",\"sponsers\":\"Sponsors\",\"sponsors_link\":\"Voir tous nos extraordinaire sponsors &rarr;\",\"my_repositories\":\"Mes dépôts\"},\"about\":{\"alpha\":\"Ceci est en alpha.\",\"messages\":{\"alpha\":\"S'il vous plaît ne considérez <strong>pas</strong> ce service comme étant stable. Nous sommes loin de ça! Plus d'infos <a href='https://github.com/travis-ci'>ici.</a>\"},\"join\":\"Joignez-vous à nous et aidez-nous!\",\"mailing_list\":\"Liste de distribution\",\"repository\":\"Dépôt\",\"twitter\":\"Twitter\"},\"mobile\":{\"author\":\"Auteur\",\"build\":\"Version\",\"build_matrix\":\"Matrice des versions\",\"commit\":\"Commit\",\"committer\":\"Committeur\",\"compare\":\"Comparer\",\"config\":\"Config\",\"duration\":\"Durée\",\"finished_at\":\"Terminé à\",\"job\":\"Tâche\",\"log\":\"Journal\"}},\"profiles\":{\"show\":{\"github\":\"Github\",\"message\":{\"your_repos\":\"Utilisez les boutons ci-dessous pour activer Travis sur vos projets puis déployez sur GitHub.<br />\\nPour tester sur plus de versions de ruby, voir\",\"config\":\"comment configurer des options de version personnalisées\"},\"messages\":{\"notice\":\"Pour commencer, veuillez lire notre <a href=\\\"http://about.travis-ci.org/docs/user/getting-started/\\\">guide de démarrage</a>.\\n <small>Cela ne vous prendra que quelques minutes.</small>\"},\"token\":\"Jeton\",\"your_repos\":\"Vos dépôts\",\"email\":\"Courriel\",\"update\":\"Modifier\",\"update_locale\":\"Modifier\",\"your_locale\":\"Votre langue\"}},\"statistics\":{\"index\":{\"count\":\"Décompte\",\"repo_growth\":\"Croissance de dépôt\",\"total_projects\":\"Total des projets/dépôts\",\"build_count\":\"Décompte des versions\",\"last_month\":\"mois dernier\",\"total_builds\":\"Total des versions\"}},\"admin\":{\"actions\":{\"create\":\"créer\",\"created\":\"créé\",\"delete\":\"supprimer\",\"deleted\":\"supprimé\",\"update\":\"mise à jour\",\"updated\":\"mis à jour\"},\"credentials\":{\"log_out\":\"Déconnection\"},\"delete\":{\"confirmation\":\"Oui, je suis sure\",\"flash_confirmation\":\"%{name} a été détruit avec succès\"},\"flash\":{\"error\":\"%{name} n'a pas pu être %{action}\",\"noaction\":\"Aucune action n'a été entreprise\",\"successful\":\"%{name} a réussi à %{action}\"},\"history\":{\"name\":\"Historique\",\"no_activity\":\"Aucune activité\",\"page_name\":\"Historique pour %{name}\"},\"list\":{\"add_new\":\"Ajouter un nouveau\",\"delete_action\":\"Supprimer\",\"delete_selected\":\"Supprimer la sélection\",\"edit_action\":\"Modifier\",\"search\":\"Rechercher\",\"select\":\"Sélectionner le %{name} à modifier\",\"select_action\":\"Sélectionner\",\"show_all\":\"Montrer tout\"},\"new\":{\"basic_info\":\"Information de base\",\"cancel\":\"Annuler\",\"chosen\":\"%{name} choisi\",\"chose_all\":\"Choisir tout\",\"clear_all\":\"Déselectionner tout\",\"many_chars\":\"caractères ou moins\",\"one_char\":\"caractère.\",\"optional\":\"Optionnel\",\"required\":\"Requis\",\"save\":\"Sauvegarder\",\"save_and_add_another\":\"Sauvegarder et en ajouter un autre\",\"save_and_edit\":\"Sauvegarder et modifier\",\"select_choice\":\"Faites vos choix et cliquez\"},\"dashboard\":{\"add_new\":\"Ajouter un nouveau\",\"last_used\":\"Dernière utilisation\",\"model_name\":\"Nom du modèle\",\"modify\":\"Modification\",\"name\":\"Tableau de bord\",\"pagename\":\"Administration du site\",\"records\":\"Enregistrements\",\"show\":\"Voir\",\"ago\":\"plus tôt\"}},\"home\":{\"name\":\"accueil\"},\"repository\":{\"duration\":\"Durée\"},\"devise\":{\"confirmations\":{\"confirmed\":\"Votre compte a été crée avec succès. Vous être maintenant connecté.\",\"send_instructions\":\"Vous allez recevoir un courriel avec les instructions de confirmation de votre compte dans quelques minutes.\"},\"failure\":{\"inactive\":\"Votre compte n'a pas encore été activé.\",\"invalid\":\"Adresse courriel ou mot de passe invalide.\",\"invalid_token\":\"Jeton d'authentification invalide.\",\"locked\":\"Votre compte est bloqué.\",\"timeout\":\"Votre session est expirée, veuillez vous reconnecter pour continuer.\",\"unauthenticated\":\"Vous devez vous connecter ou vous enregistrer afin de continuer\",\"unconfirmed\":\"Vous devez confirmer votre compte avant de continuer.\"},\"mailer\":{\"confirmation_instructions\":{\"subject\":\"Instructions de confirmations\"},\"reset_password_instructions\":{\"subject\":\"Instruction de remise à zéro du mot de passe\"},\"unlock_instructions\":{\"subject\":\"Instruction de débloquage\"}},\"passwords\":{\"send_instructions\":\"Vous recevrez un courriel avec les instructions de remise à zéro du mot de passe dans quelques minutes.\",\"updated\":\"Votre mot de passe a été changé avec succès. Vous êtes maintenant connecté.\"},\"registrations\":{\"destroyed\":\"Au revoir! Votre compte a été annulé avec succès. Nous espérons vous revoir bientôt.\",\"signed_up\":\"Vous êtes enregistré avec succès. Si activé, une confirmation vous a été envoyé par courriel.\",\"updated\":\"Votre compte a été mis a jour avec succès\"},\"sessions\":{\"signed_in\":\"Connecté avec succès\",\"signed_out\":\"Déconnecté avec succès\"},\"unlocks\":{\"send_instructions\":\"Vous recevrez un courriel contenant les instructions pour débloquer votre compte dans quelques minutes.\",\"unlocked\":\"Votre compte a été débloqué avec succès.\"}},\"errors\":{\"messages\":{\"already_confirmed\":\"étais déja confirmé\",\"not_found\":\"n'a pas été trouvé\",\"not_locked\":\"n'étais pas bloqué\"}},\"locales\":{\"en\":\"English\",\"es\":\"Español\",\"ja\":\"日本語\",\"ru\":\"Русский\",\"fr\":\"Français\",\"nb\":\"Norsk Bokmål\",\"pl\":\"Polski\",\"nl\":\"Nederlands\",\"pt-BR\":\"português brasileiro\"}},\"ja\":{\"workers\":\"ワーカー\",\"queue\":\"キュー\",\"no_job\":\"ジョブはありません\",\"repositories\":{\"branch\":\"ブランチ\",\"image_url\":\"画像URL\",\"markdown\":\".md\",\"textile\":\".textile\",\"rdoc\":\".rdoc\",\"commit\":\"コミット\",\"message\":\"メッセージ\",\"started_at\":\"開始時刻\",\"duration\":\"処理時間\",\"finished_at\":\"終了時刻\",\"tabs\":{\"current\":\"最新\",\"build_history\":\"ビルド履歴\",\"branches\":\"ブランチまとめ\",\"build\":\"ビルド\",\"job\":\"ジョブ\"}},\"build\":{\"job\":\"ジョブ\",\"duration\":\"処理時間\",\"finished_at\":\"終了時刻\"},\"jobs\":{\"messages\":{\"sponsored_by\":\"このテストは以下のスポンサーの協力で行いました。\"},\"build_matrix\":\"ビルドマトリクス\",\"allowed_failures\":\"失敗許容範囲内\",\"author\":\"制作者\",\"config\":\"設定\",\"compare\":\"比較\",\"committer\":\"コミット者\",\"branch\":\"ブランチ\",\"commit\":\"コミット\",\"message\":\"メッセージ\",\"started_at\":\"開始時刻\",\"duration\":\"処理時間\",\"finished_at\":\"終了時刻\"},\"builds\":{\"name\":\"ビルド\",\"messages\":{\"sponsored_by\":\"このテストは以下のスポンサーの協力で行いました。\"},\"build_matrix\":\"失敗許容範囲外\",\"allowed_failures\":\"失敗許容範囲内\",\"author\":\"制作者\",\"config\":\"設定\",\"compare\":\"比較\",\"committer\":\"コミット者\",\"branch\":\"ブランチ\",\"commit\":\"コミット\",\"message\":\"メッセージ\",\"started_at\":\"開始時刻\",\"duration\":\"処理時間\",\"finished_at\":\"終了時刻\"},\"layouts\":{\"about\":{\"alpha\":\"まだアルファですよ！\",\"join\":\"参加してみよう！\",\"mailing_list\":\"メールリスト\",\"messages\":{\"alpha\":\"Travis-ciは安定したサービスまで後一歩！詳しくは<a href='https://github.com/travis-ci'>こちら</a>\"},\"repository\":\"リポジトリ\",\"twitter\":\"ツイッター\"},\"application\":{\"fork_me\":\"Githubでフォークしよう\",\"my_repositories\":\"マイリポジトリ\",\"recent\":\"最近\",\"search\":\"検索\",\"sponsers\":\"スポンサー\",\"sponsors_link\":\"スポンサーをもっと見る &rarr;\"},\"top\":{\"blog\":\"ブログ\",\"docs\":\"Travisとは？\",\"github_login\":\"Githubでログイン\",\"home\":\"ホーム\",\"profile\":\"プロフィール\",\"sign_out\":\"ログアウト\",\"stats\":\"統計\",\"admin\":\"管理\"},\"mobile\":{\"author\":\"制作者\",\"build\":\"ビルド\",\"build_matrix\":\"ビルドマトリクス\",\"commit\":\"コミット\",\"committer\":\"コミット者\",\"compare\":\"比較\",\"config\":\"設定\",\"duration\":\"処理時間\",\"finished_at\":\"終了時刻\",\"job\":\"ジョブ\",\"log\":\"ログ\"}},\"profiles\":{\"show\":{\"github\":\"Github\",\"email\":\"メール\",\"message\":{\"config\":\"詳細設定\",\"your_repos\":\"以下のスイッチを設定し、Travis-ciを有効にします。Githubへプッシュしたらビルドは自動的に開始します。複数バーションや細かい設定はこちらへ：\"},\"messages\":{\"notice\":\"まずは<a href=\\\"http://about.travis-ci.org/docs/user/getting-started/\\\">Travisのはじめ方</a>を参照してください。\"},\"token\":\"トークン\",\"your_repos\":\"リポジトリ\",\"update\":\"更新\",\"update_locale\":\"更新\",\"your_locale\":\"言語設定\"}},\"statistics\":{\"index\":{\"build_count\":\"ビルド数\",\"count\":\"数\",\"last_month\":\"先月\",\"repo_growth\":\"リポジトリ\",\"total_builds\":\"合計ビルド数\",\"total_projects\":\"合計リポジトリ\"}},\"locales\":{\"en\":\"English\",\"es\":\"Español\",\"fr\":\"Français\",\"ja\":\"日本語\",\"nb\":\"Norsk Bokmål\",\"pl\":\"Polski\",\"ru\":\"Русский\",\"nl\":\"Nederlands\",\"pt-BR\":\"português brasileiro\"}},\"nb\":{\"admin\":{\"actions\":{\"create\":\"opprett\",\"created\":\"opprettet\",\"delete\":\"slett\",\"deleted\":\"slettet\",\"update\":\"oppdater\",\"updated\":\"oppdatert\"},\"credentials\":{\"log_out\":\"Logg ut\"},\"dashboard\":{\"add_new\":\"Legg til ny\",\"ago\":\"siden\",\"last_used\":\"Sist brukt\",\"model_name\":\"Modell\",\"modify\":\"Rediger\",\"name\":\"Dashbord\",\"pagename\":\"Nettstedsadministrasjon\",\"records\":\"Oppføringer\",\"show\":\"Vis\"},\"delete\":{\"confirmation\":\"Ja, jeg er sikker\",\"flash_confirmation\":\"%{name} ble slettet\"},\"flash\":{\"error\":\"%{name} kunne ikke bli %{action}\",\"noaction\":\"Ingen handlinger ble utført\",\"successful\":\"%{name} ble %{action}\"},\"history\":{\"name\":\"Logg\",\"no_activity\":\"Ingen aktivitet\",\"page_name\":\"Logg for %{name}\"},\"list\":{\"add_new\":\"Legg til ny\",\"delete_action\":\"Slett\",\"delete_selected\":\"Slett valgte\",\"edit_action\":\"Rediger\",\"search\":\"Søk\",\"select\":\"Velg %{name} for å redigere\",\"select_action\":\"Velg\",\"show_all\":\"Vis alle \"},\"new\":{\"basic_info\":\"Basisinformasjon\",\"cancel\":\"Avbryt\",\"chosen\":\"Valgt %{name}\",\"chose_all\":\"Velg alle\",\"clear_all\":\"Fjern alle\",\"many_chars\":\"eller færre tegn.\",\"one_char\":\"tegn.\",\"optional\":\"Valgfri\",\"required\":\"Påkrevd\",\"save\":\"Lagre\",\"save_and_add_another\":\"Lagre og legg til ny\",\"save_and_edit\":\"Lagre og rediger\",\"select_choice\":\"Kryss av for dine valg og klikk\"}},\"build\":{\"duration\":\"Varighet\",\"finished_at\":\"Fullført\",\"job\":\"Jobb\"},\"builds\":{\"allowed_failures\":\"Tillatte feil\",\"author\":\"Forfatter\",\"branch\":\"Gren\",\"build_matrix\":\"Jobbmatrise\",\"commit\":\"Innsending\",\"committer\":\"Innsender\",\"compare\":\"Sammenlign\",\"config\":\"Oppsett\",\"duration\":\"Varighet\",\"finished_at\":\"Fullført\",\"message\":\"Beskrivelse\",\"messages\":{\"sponsored_by\":\"Denne testen ble kjørt på en maskin sponset av\"},\"name\":\"Jobb\",\"started_at\":\"Startet\"},\"datetime\":{\"distance_in_words\":{\"hours_exact\":{\"one\":\"%{count} time\",\"other\":\"%{count} timer\"},\"minutes_exact\":{\"one\":\"%{count} minutt\",\"other\":\"%{count} minutter\"},\"seconds_exact\":{\"one\":\"%{count} sekund\",\"other\":\"%{count} sekunder\"}}},\"devise\":{\"confirmations\":{\"confirmed\":\"Din konto er aktivert og du er nå innlogget.\",\"send_instructions\":\"Om noen få minutter så vil du få en e-post med informasjon om hvordan du bekrefter kontoen din.\"},\"failure\":{\"inactive\":\"Kontoen din har ikke blitt aktivert enda.\",\"invalid\":\"Ugyldig e-post eller passord.\",\"invalid_token\":\"Ugyldig autentiseringskode.\",\"locked\":\"Kontoen din er låst.\",\"timeout\":\"Du ble logget ut siden på grunn av mangel på aktivitet, vennligst logg inn på nytt.\",\"unauthenticated\":\"Du må logge inn eller registrere deg for å fortsette.\",\"unconfirmed\":\"Du må bekrefte kontoen din før du kan fortsette.\"},\"mailer\":{\"confirmation_instructions\":{\"subject\":\"Bekreftelsesinformasjon\"},\"reset_password_instructions\":{\"subject\":\"Instruksjoner for å få nytt passord\"},\"unlock_instructions\":{\"subject\":\"Opplåsningsinstruksjoner\"}},\"passwords\":{\"send_instructions\":\"Om noen få minutter så vil du få en epost med informasjon om hvordan du kan få et nytt passord.\",\"updated\":\"Passordet ditt ble endret, og du er logget inn.\"},\"registrations\":{\"destroyed\":\"Adjø! Kontoen din ble kansellert. Vi håper vi ser deg igjen snart.\",\"signed_up\":\"Du er nå registrert.\",\"updated\":\"Kontoen din ble oppdatert.\"},\"sessions\":{\"signed_in\":\"Du er nå logget inn.\",\"signed_out\":\"Du er nå logget ut.\"},\"unlocks\":{\"send_instructions\":\"Om noen få minutter så kommer du til å få en e-post med informasjon om hvordan du kan låse opp kontoen din.\",\"unlocked\":\"Kontoen din ble låst opp, og du er nå logget inn igjen.\"}},\"errors\":{\"messages\":{\"already_confirmed\":\"har allerede blitt bekreftet\",\"not_found\":\"ikke funnnet\",\"not_locked\":\"var ikke låst\"}},\"home\":{\"name\":\"hjem\"},\"jobs\":{\"allowed_failures\":\"Tillatte feil\",\"author\":\"Forfatter\",\"branch\":\"Gren\",\"build_matrix\":\"Jobbmatrise\",\"commit\":\"Innsending\",\"committer\":\"Innsender\",\"compare\":\"Sammenlign\",\"config\":\"Oppsett\",\"duration\":\"Varighet\",\"finished_at\":\"Fullført\",\"message\":\"Beskrivelse\",\"messages\":{\"sponsored_by\":\"Denne testserien ble kjørt på en maskin sponset av\"},\"started_at\":\"Startet\"},\"layouts\":{\"about\":{\"alpha\":\"Dette er alfa-greier.\",\"join\":\"Bli med og hjelp oss!\",\"mailing_list\":\"E-postliste\",\"messages\":{\"alpha\":\"Dette er <strong>ikke</strong> en stabil tjeneste. Vi har fremdeles et stykke igjen! Mer informasjon finner du <a href=\\\"https://github.com/travis-ci\\\">her</a>.\"},\"repository\":\"Kodelager\",\"twitter\":\"Twitter.\"},\"application\":{\"fork_me\":\"Se koden på Github\",\"my_repositories\":\"Mine kodelagre\",\"recent\":\"Nylig\",\"search\":\"Søk\",\"sponsers\":\"Sponsorer\",\"sponsors_link\":\"Se alle de flotte sponsorene våre &rarr;\"},\"mobile\":{\"author\":\"Forfatter\",\"build\":\"Jobb\",\"build_matrix\":\"Jobbmatrise\",\"commit\":\"Innsending\",\"committer\":\"Innsender\",\"compare\":\"Sammenlign\",\"config\":\"Oppsett\",\"duration\":\"Varighet\",\"finished_at\":\"Fullført\",\"job\":\"Jobb\",\"log\":\"Logg\"},\"top\":{\"admin\":\"Administrator\",\"blog\":\"Blogg\",\"docs\":\"Dokumentasjon\",\"github_login\":\"Logg inn med Github\",\"home\":\"Hjem\",\"profile\":\"Profil\",\"sign_out\":\"Logg ut\",\"stats\":\"Statistikk\"}},\"no_job\":\"Ingen jobber finnnes\",\"profiles\":{\"show\":{\"email\":\"E-post\",\"github\":\"Github\",\"message\":{\"config\":\"hvordan sette opp egne jobbinnstillinger\",\"your_repos\":\"Slå\\u0010 på Travis for prosjektene dine ved å dra i bryterne under, og send koden til Github.<br />\\nFor å teste mot flere ruby-versjoner, se dokumentasjonen for\"},\"messages\":{\"notice\":\"For å komme i gang, vennligst les <a href=\\\"http://about.travis-ci.org/docs/user/getting-started/\\\">kom-i-gang-veivisereren</a> vår. <small>Det tar bare et par minutter.</small>\"},\"token\":\"Kode\",\"update\":\"Oppdater\",\"update_locale\":\"Oppdater\",\"your_locale\":\"Ditt språk\",\"your_repos\":\"Dine kodelagre\"}},\"queue\":\"Kø\",\"repositories\":{\"branch\":\"Gren\",\"commit\":\"Innsender\",\"duration\":\"Varighet\",\"finished_at\":\"Fullført\",\"image_url\":\"Bilde-URL\",\"markdown\":\"Markdown\",\"message\":\"Beskrivelse\",\"rdoc\":\"RDOC\",\"started_at\":\"Startet\",\"tabs\":{\"branches\":\"Grensammendrag\",\"build\":\"Jobb\",\"build_history\":\"Jobblogg\",\"current\":\"Siste\",\"job\":\"Jobb\"},\"textile\":\"Textile\"},\"repository\":{\"duration\":\"Varighet\"},\"statistics\":{\"index\":{\"build_count\":\"Antall jobber\",\"count\":\"Antall\",\"last_month\":\"siste måned\",\"repo_growth\":\"Vekst i kodelager\",\"total_builds\":\"Totale jobber\",\"total_projects\":\"Antall prosjekter/kodelagre\"}},\"workers\":\"Arbeidere\",\"locales\":{\"en\":\"English\",\"es\":\"Español\",\"ja\":\"日本語\",\"ru\":\"Русский\",\"fr\":\"Français\",\"nb\":\"Norsk Bokmål\",\"pl\":\"Polski\",\"nl\":\"Nederlands\",\"pt-BR\":\"português brasileiro\"}},\"nl\":{\"admin\":{\"actions\":{\"create\":\"aanmaken\",\"created\":\"aangemaakt\",\"delete\":\"verwijderen\",\"deleted\":\"verwijderd\",\"update\":\"bijwerken\",\"updated\":\"bijgewerkt\"},\"credentials\":{\"log_out\":\"Afmelden\"},\"dashboard\":{\"add_new\":\"Nieuwe toevoegen\",\"ago\":\"geleden\",\"last_used\":\"Laatst gebruikt\",\"model_name\":\"Model naam\",\"modify\":\"Wijzigen\",\"pagename\":\"Site administratie\",\"show\":\"Laten zien\",\"records\":\"Gegevens\"},\"delete\":{\"confirmation\":\"Ja, ik ben zeker\",\"flash_confirmation\":\"%{name} is vernietigd\"},\"flash\":{\"error\":\"%{name} kon niet worden %{action}\",\"noaction\":\"Er zijn geen acties genomen\",\"successful\":\"%{name} is %{action}\"},\"history\":{\"name\":\"Geschiedenis\",\"no_activity\":\"Geen activiteit\",\"page_name\":\"Geschiedenis van %{name}\"},\"list\":{\"add_new\":\"Nieuwe toevoegen\",\"delete_action\":\"Verwijderen\",\"delete_selected\":\"Verwijder geselecteerden\",\"edit_action\":\"Bewerken\",\"search\":\"Zoeken\",\"select\":\"Selecteer %{name} om te bewerken\",\"select_action\":\"Selecteer\",\"show_all\":\"Laat allen zien\"},\"new\":{\"basic_info\":\"Basisinfo\",\"cancel\":\"Annuleren\",\"chosen\":\"%{name} gekozen\",\"chose_all\":\"Kies allen\",\"clear_all\":\"Deselecteer allen\",\"many_chars\":\"tekens of minder.\",\"one_char\":\"teken.\",\"optional\":\"Optioneel\",\"required\":\"Vereist\",\"save\":\"Opslaan\",\"save_and_add_another\":\"Opslaan en een nieuwe toevoegen\",\"save_and_edit\":\"Opslaan en bewerken\",\"select_choice\":\"Selecteer uw keuzes en klik\"}},\"build\":{\"duration\":\"Duur\",\"finished_at\":\"Voltooid\",\"job\":\"Taak\"},\"builds\":{\"allowed_failures\":\"Toegestane mislukkingen\",\"author\":\"Auteur\",\"branch\":\"Tak\",\"build_matrix\":\"Bouw Matrix\",\"compare\":\"Vergelijk\",\"config\":\"Configuratie\",\"duration\":\"Duur\",\"finished_at\":\"Voltooid\",\"message\":\"Bericht\",\"messages\":{\"sponsored_by\":\"Deze tests zijn gedraaid op een machine gesponsord door\"},\"name\":\"Bouw\",\"started_at\":\"Gestart\",\"commit\":\"Commit\",\"committer\":\"Committer\"},\"datetime\":{\"distance_in_words\":{\"hours_exact\":{\"one\":\"%{count} uur\",\"other\":\"%{count} uren\"},\"minutes_exact\":{\"one\":\"%{count} minuut\",\"other\":\"%{count} minuten\"},\"seconds_exact\":{\"one\":\"%{count} seconde\",\"other\":\"%{count} seconden\"}}},\"devise\":{\"confirmations\":{\"confirmed\":\"Uw account is bevestigd. U wordt nu ingelogd.\",\"send_instructions\":\"Binnen enkele minuten zal u een email ontvangen met instructies om uw account te bevestigen.\"},\"failure\":{\"inactive\":\"Uw account is nog niet geactiveerd.\",\"invalid\":\"Ongeldig email adres of wachtwoord.\",\"invalid_token\":\"Ongeldig authenticatie token.\",\"locked\":\"Uw account is vergrendeld.\",\"timeout\":\"Uw sessie is verlopen, gelieve opnieuw in te loggen om verder te gaan.\",\"unauthenticated\":\"U moet inloggen of u registeren voordat u verder gaat.\",\"unconfirmed\":\"U moet uw account bevestigen voordat u verder gaat.\"},\"mailer\":{\"confirmation_instructions\":{\"subject\":\"Bevestigings-instructies\"},\"reset_password_instructions\":{\"subject\":\"Wachtwoord herstel instructies\"},\"unlock_instructions\":{\"subject\":\"Ontgrendel-instructies\"}},\"passwords\":{\"send_instructions\":\"Binnen enkele minuten zal u een email krijgen met instructies om uw wachtwoord opnieuw in te stellen.\",\"updated\":\"Uw wachtwoord is veranderd. U wordt nu ingelogd.\"},\"registrations\":{\"destroyed\":\"Dag! Uw account is geannuleerd. We hopen u vlug terug te zien.\",\"signed_up\":\"Uw registratie is voltooid. Als het ingeschakeld is wordt een bevestiging naar uw email adres verzonden.\",\"updated\":\"Het bijwerken van uw account is gelukt.\"},\"sessions\":{\"signed_in\":\"Inloggen gelukt.\",\"signed_out\":\"Uitloggen gelukt.\"},\"unlocks\":{\"send_instructions\":\"Binnen enkele minuten zal u een email krijgen met instructies om uw account te ontgrendelen.\",\"unlocked\":\"Uw account is ontgrendeld. U wordt nu ingelogd.\"}},\"errors\":{\"messages\":{\"already_confirmed\":\"was al bevestigd\",\"not_found\":\"niet gevonden\",\"not_locked\":\"was niet vergrendeld\"}},\"jobs\":{\"allowed_failures\":\"Toegestane mislukkingen\",\"author\":\"Auteur\",\"branch\":\"Tak\",\"build_matrix\":\"Bouw matrix\",\"compare\":\"Vergelijk\",\"config\":\"Configuratie\",\"duration\":\"Duur\",\"finished_at\":\"Voltooid\",\"message\":\"Bericht\",\"messages\":{\"sponsored_by\":\"Deze testen zijn uitgevoerd op een machine gesponsord door\"},\"started_at\":\"Gestart\",\"commit\":\"Commit\",\"committer\":\"Committer\"},\"layouts\":{\"about\":{\"alpha\":\"Dit is in alfa-stadium.\",\"join\":\"Doe met ons mee en help!\",\"mailing_list\":\"Mailing lijst\",\"messages\":{\"alpha\":\"Gelieve deze service <strong>niet</strong> te beschouwen als stabiel. Daar zijn we nog lang niet! Meer info <a href='https://github.com/travis-ci'>hier.</a>\"},\"repository\":\"Repository\",\"twitter\":\"Twitter\"},\"application\":{\"fork_me\":\"Maak een fork op Github\",\"my_repositories\":\"Mijn repositories\",\"recent\":\"Recent\",\"search\":\"Zoeken\",\"sponsers\":\"Sponsors\",\"sponsors_link\":\"Bekijk al onze geweldige sponsors &rarr;\"},\"mobile\":{\"author\":\"Auteur\",\"build\":\"Bouw\",\"build_matrix\":\"Bouw matrix\",\"compare\":\"Vergelijk\",\"config\":\"Configuratie\",\"duration\":\"Duur\",\"finished_at\":\"Voltooid op\",\"job\":\"Taak\",\"commit\":\"Commit\",\"committer\":\"Committer\",\"log\":\"Logboek\"},\"top\":{\"admin\":\"Administratie\",\"blog\":\"Blog\",\"docs\":\"Documentatie\",\"github_login\":\"Inloggen met Github\",\"home\":\"Home\",\"profile\":\"Profiel\",\"sign_out\":\"Uitloggen\",\"stats\":\"Statistieken\"}},\"locales\":{\"en\":\"English\",\"es\":\"Español\",\"fr\":\"Français\",\"ja\":\"日本語\",\"nb\":\"Norsk Bokmål\",\"nl\":\"Nederlands\",\"pl\":\"Polski\",\"ru\":\"Русский\",\"pt-BR\":\"português brasileiro\"},\"no_job\":\"Er zijn geen taken\",\"profiles\":{\"show\":{\"email\":\"Email adres\",\"github\":\"Github\",\"message\":{\"config\":\"hoe eigen bouw-opties in te stellen\",\"your_repos\":\"Zet de schakelaars hieronder aan om de Travis hook voor uw projecten te activeren en push daarna naar Github<br />\\nOm te testen tegen meerdere rubies, zie\"},\"messages\":{\"notice\":\"Om te beginnen kunt u onze <a href=\\\\\\\"http://about.travis-ci.org/docs/user/getting-started/\\\\\\\">startersgids</a> lezen.\\\\n  <small>Het zal maar enkele minuten van uw tijd vergen.</small>\"},\"update\":\"Bijwerken\",\"update_locale\":\"Bijwerken\",\"your_locale\":\"Uw taal\",\"your_repos\":\"Uw repositories\",\"token\":\"Token\"}},\"queue\":\"Wachtrij\",\"repositories\":{\"branch\":\"Tak\",\"duration\":\"Duur\",\"finished_at\":\"Voltooid\",\"image_url\":\"Afbeeldings URL\",\"message\":\"Bericht\",\"started_at\":\"Gestart\",\"tabs\":{\"branches\":\"Tak samenvatting\",\"build\":\"Bouw\",\"build_history\":\"Bouw geschiedenis\",\"current\":\"Huidig\",\"job\":\"Taak\"},\"commit\":\"Commit\",\"markdown\":\"Markdown\",\"rdoc\":\"RDOC\",\"textile\":\"Textile\"},\"repository\":{\"duration\":\"Duur\"},\"statistics\":{\"index\":{\"build_count\":\"Bouw aantal\",\"count\":\"Aantal\",\"last_month\":\"voorbije maand\",\"repo_growth\":\"Repository groei\",\"total_builds\":\"Bouw totaal\",\"total_projects\":\"Projecten/Repository totaal\"}},\"workers\":\"Machines\",\"home\":{\"name\":\"Hoofdpagina\"}},\"pl\":{\"datetime\":{\"distance_in_words\":{\"hours_exact\":{\"one\":\"%{count} godzina\",\"other\":\"%{count} godziny\"},\"minutes_exact\":{\"one\":\"%{count} minuta\",\"other\":\"%{count} minuty\"},\"seconds_exact\":{\"one\":\"%{count} sekunda\",\"other\":\"%{count} sekundy\"}}},\"workers\":\"Workers\",\"queue\":\"Kolejka\",\"no_job\":\"Brak zadań\",\"repositories\":{\"branch\":\"Gałąź\",\"image_url\":\"URL obrazka\",\"markdown\":\"Markdown\",\"textile\":\"Textile\",\"rdoc\":\"RDOC\",\"commit\":\"Commit\",\"message\":\"Opis\",\"started_at\":\"Rozpoczęto\",\"duration\":\"Czas trwania\",\"finished_at\":\"Zakończono\",\"tabs\":{\"current\":\"Aktualny\",\"build_history\":\"Historia Buildów\",\"branches\":\"Wszystkie Gałęzie\",\"build\":\"Build\",\"job\":\"Zadanie\"}},\"build\":{\"job\":\"Zadanie\",\"duration\":\"Czas trwania\",\"finished_at\":\"Zakończono\"},\"jobs\":{\"messages\":{\"sponsored_by\":\"Te testy zostały uruchomione na maszynie sponsorowanej przez\"},\"build_matrix\":\"Macierz Buildów\",\"allowed_failures\":\"Dopuszczalne Niepowodzenia\",\"author\":\"Autor\",\"config\":\"Konfiguracja\",\"compare\":\"Porównanie\",\"committer\":\"Committer\",\"branch\":\"Gałąź\",\"commit\":\"Commit\",\"message\":\"Opis\",\"started_at\":\"Rozpoczęto\",\"duration\":\"Czas trwania\",\"finished_at\":\"Zakończono\",\"sponsored_by\":\"Te testy zostały uruchomione na maszynie sponsorowanej przez\"},\"builds\":{\"name\":\"Build\",\"messages\":{\"sponsored_by\":\"Te testy zostały uruchomione na maszynie sponsorowanej przez\"},\"build_matrix\":\"Macierz Buildów\",\"allowed_failures\":\"Dopuszczalne Niepowodzenia\",\"author\":\"Autor\",\"config\":\"Konfiguracja\",\"compare\":\"Porównanie\",\"committer\":\"Komitujący\",\"branch\":\"Gałąź\",\"commit\":\"Commit\",\"message\":\"Opis\",\"started_at\":\"Rozpoczęto\",\"duration\":\"Czas trwania\",\"finished_at\":\"Zakończono\"},\"layouts\":{\"top\":{\"home\":\"Start\",\"blog\":\"Blog\",\"docs\":\"Dokumentacja\",\"stats\":\"Statystki\",\"github_login\":\"Zaloguj się przy pomocy Githuba\",\"profile\":\"Profil\",\"sign_out\":\"Wyloguj się\"},\"application\":{\"fork_me\":\"Fork me on Github\",\"recent\":\"Ostatnie\",\"search\":\"Wyniki\",\"sponsers\":\"Sponsorzy\",\"sponsors_link\":\"Zobacz naszych wszystkich wspaniałych sponsorów &rarr;\",\"my_repositories\":\"Moje repozytoria\"},\"about\":{\"alpha\":\"To wciąż jest wersja alpha.\",\"messages\":{\"alpha\":\"Proszę <strong>nie</strong> traktuj tego jako stabilnej usługi. Wciąż nam wiele do tego brakuje! Więcej informacji znajdziesz <a href='https://github.com/travis-ci'>tutaj.</a>\"},\"join\":\"Pomóż i dołącz do nas!\",\"mailing_list\":\"Lista mailingowa\",\"repository\":\"Repozytorium\",\"twitter\":\"Twitter\"},\"mobile\":{\"author\":\"Autor\",\"build\":\"Build\",\"build_matrix\":\"Macierz Buildów\",\"commit\":\"Commit\",\"committer\":\"Komitujący\",\"compare\":\"Porównianie\",\"config\":\"Konfiguracja\",\"duration\":\"Czas trwania\",\"finished_at\":\"Zakończono\",\"job\":\"Zadanie\",\"log\":\"Log\"}},\"profiles\":{\"show\":{\"email\":\"Email\",\"github\":\"Github\",\"message\":{\"your_repos\":\"  Przesuń suwak poniżej, aby włączyć Travisa, dla twoich projektów, a następnie umieść swój kod na GitHubie.<br />\\n Aby testować swój kod przy użyciu wielu wersji Rubiego, zobacz\",\"config\":\"jak skonfigurować niestandardowe opcje builda\"},\"messages\":{\"notice\":\"Aby zacząć, przeczytaj nasz <a href=\\\"http://about.travis-ci.org/docs/user/getting-started/\\\">Przewodnik </a>.\\n  <small>Zajmie ci to tylko kilka minut.</small>\"},\"token\":\"Token\",\"your_repos\":\"Twoje repozytoria\"}},\"statistics\":{\"index\":{\"count\":\"Ilość\",\"repo_growth\":\"Przyrost repozytoriów\",\"total_projects\":\"Łącznie projektów/repozytoriów\",\"build_count\":\"Liczba buildów\",\"last_month\":\"ostatni miesiąc\",\"total_builds\":\"Łącznie Buildów\"}},\"date\":{\"abbr_day_names\":[\"nie\",\"pon\",\"wto\",\"śro\",\"czw\",\"pią\",\"sob\"],\"abbr_month_names\":[\"sty\",\"lut\",\"mar\",\"kwi\",\"maj\",\"cze\",\"lip\",\"sie\",\"wrz\",\"paź\",\"lis\",\"gru\"],\"day_names\":[\"niedziela\",\"poniedziałek\",\"wtorek\",\"środa\",\"czwartek\",\"piątek\",\"sobota\"],\"formats\":{\"default\":\"%d-%m-%Y\",\"long\":\"%B %d, %Y\",\"short\":\"%d %b\"},\"month_names\":[\"styczeń\",\"luty\",\"marzec\",\"kwiecień\",\"maj\",\"czerwiec\",\"lipiec\",\"sierpień\",\"wrzesień\",\"październik\",\"listopad\",\"grudzień\"],\"order\":[\"day\",\"month\",\"year\"]},\"errors\":{\"format\":\"%{attribute} %{message}\",\"messages\":{\"accepted\":\"musi zostać zaakceptowane\",\"blank\":\"nie może być puste\"}},\"locales\":{\"en\":\"English\",\"es\":\"Español\",\"ja\":\"日本語\",\"ru\":\"Русский\",\"fr\":\"Français\",\"nb\":\"Norsk Bokmål\",\"pl\":\"Polski\",\"nl\":\"Nederlands\",\"pt-BR\":\"português brasileiro\"}},\"pt-BR\":{\"admin\":{\"actions\":{\"create\":\"criar\",\"created\":\"criado\",\"delete\":\"deletar\",\"deleted\":\"deletado\",\"update\":\"atualizar\",\"updated\":\"atualizado\"},\"credentials\":{\"log_out\":\"Deslogar\"},\"dashboard\":{\"add_new\":\"Adicionar novo\",\"ago\":\"atrás\",\"last_used\":\"Última utilização\",\"model_name\":\"Nome do modelo\",\"modify\":\"Modificar\",\"name\":\"Dashboard\",\"pagename\":\"Administração do site\",\"records\":\"Registros\",\"show\":\"Mostrar\"},\"delete\":{\"confirmation\":\"Sim, tenho certeza\",\"flash_confirmation\":\"%{name} foi destruído com sucesso\"},\"flash\":{\"error\":\"%{name} falhou ao %{action}\",\"noaction\":\"Nenhuma ação foi tomada\",\"successful\":\"%{name} foi %{action} com sucesso\"},\"history\":{\"name\":\"Histórico\",\"no_activity\":\"Nenhuma Atividade\",\"page_name\":\"Histórico para %{name}\"},\"list\":{\"add_new\":\"Adicionar novo\",\"delete_action\":\"Deletar\",\"delete_selected\":\"Deletar selecionados\",\"edit_action\":\"Editar\",\"search\":\"Buscar\",\"select\":\"Selecionar %{name} para editar\",\"select_action\":\"Selecionar\",\"show_all\":\"Mostrar todos\"},\"new\":{\"basic_info\":\"Informações básicas\",\"cancel\":\"Cancelar\",\"chosen\":\"Escolhido %{name}\",\"chose_all\":\"Escolher todos\",\"clear_all\":\"Limpar todos\",\"many_chars\":\"caracteres ou menos.\",\"one_char\":\"caractere.\",\"optional\":\"Opcional\",\"required\":\"Requerido\",\"save\":\"Salvar\",\"save_and_add_another\":\"Salvar e adicionar outro\",\"save_and_edit\":\"Salvar e alterar\",\"select_choice\":\"Selecione e clique\"}},\"build\":{\"duration\":\"Duração\",\"finished_at\":\"Concluído em\",\"job\":\"Trabalho\"},\"builds\":{\"allowed_failures\":\"Falhas Permitidas\",\"author\":\"Autor\",\"branch\":\"Branch\",\"build_matrix\":\"Matriz de Build\",\"commit\":\"Commit\",\"committer\":\"Committer\",\"compare\":\"Comparar\",\"config\":\"Config\",\"duration\":\"Duração\",\"finished_at\":\"Concluído em\",\"message\":\"Mensagem\",\"messages\":{\"sponsored_by\":\"Esta série de testes foi executada em uma caixa de processos patrocinada por\"},\"name\":\"Build\",\"started_at\":\"Iniciou em\"},\"datetime\":{\"distance_in_words\":{\"hours_exact\":{\"one\":\"%{count} hora\",\"other\":\"%{count} horas\"},\"minutes_exact\":{\"one\":\"%{count} minuto\",\"other\":\"%{count} minutos\"},\"seconds_exact\":{\"one\":\"%{count} segundo\",\"other\":\"%{count} segundos\"}}},\"devise\":{\"confirmations\":{\"confirmed\":\"Sua conta foi confirmada com sucesso. Você agora está logado.\",\"send_instructions\":\"Você receberá um email com instruções de como confirmar sua conta em alguns minutos.\"},\"failure\":{\"inactive\":\"Sua conta ainda não foi ativada.\",\"invalid\":\"Email ou senha inválidos.\",\"invalid_token\":\"Token de autenticação inválido.\",\"locked\":\"Sua conta está trancada.\",\"timeout\":\"Sua sessão expirou, por favor faça seu login novamente.\",\"unauthenticated\":\"Você precisa fazer o login ou cadastrar-se antes de continuar.\",\"unconfirmed\":\"Você precisa confirmar sua conta antes de continuar.\"},\"mailer\":{\"confirmation_instructions\":{\"subject\":\"Instruções de confirmação\"},\"reset_password_instructions\":{\"subject\":\"Instruções de atualização de senha\"},\"unlock_instructions\":{\"subject\":\"Instruções de destrancamento\"}},\"passwords\":{\"send_instructions\":\"Você receberá um email com instruções de como atualizar sua senha em alguns minutos.\",\"updated\":\"Sua senha foi alterada com sucesso. Você agora está logado.\"},\"registrations\":{\"destroyed\":\"Tchau! Sua conta foi cancelada com sucesso. Esperamos vê-lo novamente em breve!\",\"signed_up\":\"Você se cadastrou com sucesso. Se ativada, uma confirmação foi enviada para seu email.\",\"updated\":\"Você atualizou sua conta com sucesso.\"},\"sessions\":{\"signed_in\":\"Logado com sucesso.\",\"signed_out\":\"Deslogado com sucesso.\"},\"unlocks\":{\"send_instructions\":\"Você receberá um email com instruções de como destrancar sua conta em alguns minutos.\",\"unlocked\":\"Sua conta foi destrancada com sucesso. Você agora está logado.\"}},\"errors\":{\"messages\":{\"already_confirmed\":\"já foi confirmado\",\"not_found\":\"não encontrado\",\"not_locked\":\"não estava trancado\"}},\"home\":{\"name\":\"home\"},\"jobs\":{\"allowed_failures\":\"Falhas Permitidas\",\"author\":\"Autor\",\"branch\":\"Branch\",\"build_matrix\":\"Matriz de Build\",\"commit\":\"Commit\",\"committer\":\"Committer\",\"compare\":\"Comparar\",\"config\":\"Config\",\"duration\":\"Duração\",\"finished_at\":\"Concluído em\",\"message\":\"Mensagem\",\"messages\":{\"sponsored_by\":\"Esta série de testes foi executada em uma caixa de processos patrocinada por\"},\"started_at\":\"Iniciou em\"},\"layouts\":{\"about\":{\"alpha\":\"Isto é um alpha.\",\"join\":\"Junte-se à nós e ajude!\",\"mailing_list\":\"Lista de email\",\"messages\":{\"alpha\":\"Por favor, <strong>não</strong> considere isto um serviço estável. Estamos muito longe disso! Mais informações <a href='https://github.com/travis-ci'>aqui.</a>\"},\"repository\":\"Repositório\",\"twitter\":\"Twitter\"},\"application\":{\"fork_me\":\"Faça fork no Github\",\"my_repositories\":\"Meus Repositórios\",\"recent\":\"Recentes\",\"search\":\"Buscar\",\"sponsers\":\"Patrocinadores\",\"sponsors_link\":\"Conheça todos os nossos patrocinadores &rarr;\"},\"mobile\":{\"author\":\"Autor\",\"build\":\"Build\",\"build_matrix\":\"Matriz de Build\",\"commit\":\"Commit\",\"committer\":\"Committer\",\"compare\":\"Comparar\",\"config\":\"Config\",\"duration\":\"Duração\",\"finished_at\":\"Concluído em\",\"job\":\"Trabalho\",\"log\":\"Log\"},\"top\":{\"admin\":\"Admin\",\"blog\":\"Blog\",\"docs\":\"Documentação\",\"github_login\":\"Logue com o Github\",\"home\":\"Home\",\"profile\":\"Perfil\",\"sign_out\":\"Sair\",\"stats\":\"Estatísticas\"}},\"locales\":{\"en\":\"English\",\"es\":\"Español\",\"fr\":\"Français\",\"ja\":\"日本語\",\"nb\":\"Norsk Bokmål\",\"nl\":\"Nederlands\",\"pl\":\"Polski\",\"ru\":\"Русский\",\"pt-BR\":\"português brasileiro\"},\"no_job\":\"Não há trabalhos\",\"profiles\":{\"show\":{\"email\":\"Email\",\"github\":\"Github\",\"message\":{\"config\":\"como configurar opções de build\",\"your_repos\":\"Use os botões abaixo para ligar ou desligar o hook de serviço do Travis para seus projetos, e então, faça um push para o Github.<br />Para testar com múltiplas versões do Ruby, leia\"},\"messages\":{\"notice\":\"Para começar, leia nosso <a href=\\\"http://about.travis-ci.org/docs/user/getting-started/\\\">Guia de início</a>. <small>Só leva alguns minutinhos.</small>\"},\"token\":\"Token\",\"update\":\"Atualizar\",\"update_locale\":\"Atualizar\",\"your_locale\":\"Sua língua\",\"your_repos\":\"Seus Repositórios\"}},\"queue\":\"Fila\",\"repositories\":{\"branch\":\"Branch\",\"commit\":\"Commit\",\"duration\":\"Duração\",\"finished_at\":\"Concluído em\",\"image_url\":\"URL da imagem\",\"markdown\":\"Markdown\",\"message\":\"Mensagem\",\"rdoc\":\"RDOC\",\"started_at\":\"Iniciou em\",\"tabs\":{\"branches\":\"Sumário do Branch\",\"build\":\"Build\",\"build_history\":\"Histórico de Build\",\"current\":\"Atual\",\"job\":\"Trabalho\"},\"textile\":\"Textile\"},\"repository\":{\"duration\":\"Duração\"},\"statistics\":{\"index\":{\"build_count\":\"Número de Builds\",\"count\":\"Número\",\"last_month\":\"último mês\",\"repo_growth\":\"Crescimento de Repositório\",\"total_builds\":\"Total de Builds\",\"total_projects\":\"Total de Projetos/Repositórios\"}},\"workers\":\"Processos\"},\"ru\":{\"admin\":{\"actions\":{\"create\":\"создать\",\"created\":\"создано\",\"delete\":\"удалить\",\"deleted\":\"удалено\",\"update\":\"обновить\",\"updated\":\"обновлено\"},\"credentials\":{\"log_out\":\"Выход\"},\"dashboard\":{\"add_new\":\"Добавить\",\"ago\":\"назад\",\"last_used\":\"Использовалось в последний раз\",\"model_name\":\"Имя модели\",\"modify\":\"Изменить\",\"name\":\"Панель управления\",\"pagename\":\"Управление сайтом\",\"records\":\"Записи\",\"show\":\"Показать\"},\"delete\":{\"confirmation\":\"Да, я уверен\",\"flash_confirmation\":\"%{name} успешно удалено\"},\"history\":{\"name\":\"История\",\"no_activity\":\"Нет активности\",\"page_name\":\"История %{name}\"},\"list\":{\"add_new\":\"Добавить\",\"delete_action\":\"Удалить\",\"delete_selected\":\"Удалить выбранные\",\"edit_action\":\"Редактировать\",\"search\":\"Поиск\",\"select\":\"Для редактирования выберите %{name}\",\"select_action\":\"Выбрать\",\"show_all\":\"Показать все\"},\"new\":{\"basic_info\":\"Основная информация\",\"cancel\":\"Отмена\",\"chosen\":\"Выбрано %{name}\",\"chose_all\":\"Выбрать все\",\"clear_all\":\"Очистить все\",\"one_char\":\"символ.\",\"optional\":\"Необязательно\",\"required\":\"Обязательно\",\"save\":\"Сохранить\",\"save_and_add_another\":\"Сохранить и добавить другое\",\"save_and_edit\":\"Сохранить и продолжить редактирование\",\"select_choice\":\"Выберите и кликните\",\"many_chars\":\"символов или меньше.\"},\"flash\":{\"error\":\"%{name} не удалось %{action}\",\"noaction\":\"Никаких действий не произведено\",\"successful\":\"%{name} было успешно %{action}\"}},\"build\":{\"duration\":\"Длительность\",\"finished_at\":\"Завершен\",\"job\":\"Задача\"},\"builds\":{\"allowed_failures\":\"Допустимые неудачи\",\"author\":\"Автор\",\"branch\":\"Ветка\",\"build_matrix\":\"Матрица\",\"commit\":\"Коммит\",\"committer\":\"Коммитер\",\"compare\":\"Дифф\",\"config\":\"Конфигурация\",\"duration\":\"Длительность\",\"finished_at\":\"Завершен\",\"message\":\"Комментарий\",\"messages\":{\"sponsored_by\":\"Эта серия тестов была запущена на машине, спонсируемой\"},\"name\":\"Билд\",\"started_at\":\"Начало\"},\"datetime\":{\"distance_in_words\":{\"hours_exact\":{\"one\":\"%{count} час\",\"few\":\"%{count} часа\",\"many\":\"%{count} часов\",\"other\":\"%{count} часа\"},\"minutes_exact\":{\"one\":\"%{count} минута\",\"few\":\"%{count} минуты\",\"many\":\"%{count} минут\",\"other\":\"%{count} минуты\"},\"seconds_exact\":{\"one\":\"%{count} секунда\",\"few\":\"%{count} секунды\",\"many\":\"%{count} секунд\",\"other\":\"%{count} секунды\"}}},\"devise\":{\"confirmations\":{\"confirmed\":\"Ваш аккаунт успешно подтвержден. Приветствуем!\",\"send_instructions\":\"В течении нескольких минут вы получите электронное письмо с инструкциями для прохождения процедуры подтверждения аккаунта.\"},\"failure\":{\"inactive\":\"Ваш аккаунт еще не активирован.\",\"invalid\":\"Ошибка в адресе почты или пароле.\",\"invalid_token\":\"Неправильный токен аутентификации.\",\"locked\":\"Ваш аккаунт заблокирован.\",\"timeout\":\"Сессия окончена. Для продолжения работы войдите снова.\",\"unauthenticated\":\"Вам нужно войти или зарегистрироваться.\",\"unconfirmed\":\"Вы должны сначала подтвердить свой аккаунт.\"},\"mailer\":{\"confirmation_instructions\":{\"subject\":\"Инструкции для подтверждению аккаунта\"},\"reset_password_instructions\":{\"subject\":\"Инструкции для сброса пароля\"},\"unlock_instructions\":{\"subject\":\"Инструкции для разблокирования аккаунта\"}},\"passwords\":{\"send_instructions\":\"В течении нескольких минут вы получите электронное письмо с инструкциями для сброса пароля.\",\"updated\":\"Ваш пароль успешно изменен. Приветствуем!\"},\"registrations\":{\"destroyed\":\"Ваш аккаунт был успешно удален. Живите долго и процветайте!\",\"signed_up\":\"Вы успешно прошли регистрацию. Инструкции для подтверждения аккаунта отправлены на ваш электронный адрес.\",\"updated\":\"Аккаунт успешно обновлен.\"},\"sessions\":{\"signed_in\":\"Приветствуем!\",\"signed_out\":\"Удачи!\"},\"unlocks\":{\"send_instructions\":\"В течении нескольких минут вы получите электронное письмо с инструкциям для разблокировния аккаунта.\",\"unlocked\":\"Ваш аккаунт успешно разблокирован. Приветствуем!\"}},\"errors\":{\"messages\":{\"already_confirmed\":\"уже подтвержден\",\"not_found\":\"не найден\",\"not_locked\":\"не заблокирован\"}},\"home\":{\"name\":\"Главная\"},\"jobs\":{\"allowed_failures\":\"Допустимые неудачи\",\"author\":\"Автор\",\"branch\":\"Ветка\",\"build_matrix\":\"Матрица\",\"commit\":\"Коммит\",\"committer\":\"Коммитер\",\"compare\":\"Сравнение\",\"config\":\"Конфигурация\",\"duration\":\"Длительность\",\"finished_at\":\"Завершен\",\"message\":\"Комментарий\",\"messages\":{\"sponsored_by\":\"Эта серия тестов была запущена на машине спонсируемой\"},\"started_at\":\"Начало\"},\"layouts\":{\"about\":{\"alpha\":\"Это альфа-версия\",\"join\":\"Присоединяйтесь к нам и помогайте!\",\"mailing_list\":\"Лист рассылки\",\"messages\":{\"alpha\":\"Пожалуйста, <strong>не</strong> считайте данный сервис стабильным. Мы еще очень далеки от стабильности! <a href='https://github.com/travis-ci'>Подробности</a>\"},\"repository\":\"Репозиторий\",\"twitter\":\"Twitter\"},\"application\":{\"fork_me\":\"Fork me on Github\",\"my_repositories\":\"Мои репозитории\",\"recent\":\"Недавние\",\"search\":\"Поиск\",\"sponsers\":\"Спонсоры\",\"sponsors_link\":\"Список всех наших замечательных спонсоров &rarr;\"},\"mobile\":{\"author\":\"Автор\",\"build\":\"Сборка\",\"build_matrix\":\"Матрица сборок\",\"commit\":\"Коммит\",\"committer\":\"Коммитер\",\"compare\":\"Сравнение\",\"config\":\"Конфигурация\",\"duration\":\"Длительность\",\"finished_at\":\"Завершен\",\"job\":\"Задача\",\"log\":\"Журнал\"},\"top\":{\"admin\":\"Управление\",\"blog\":\"Блог\",\"docs\":\"Документация\",\"github_login\":\"Войти через Github\",\"home\":\"Главная\",\"profile\":\"Профиль\",\"sign_out\":\"Выход\",\"stats\":\"Статистика\"}},\"no_job\":\"Очередь пуста\",\"profiles\":{\"show\":{\"email\":\"Электронная почта\",\"github\":\"Github\",\"message\":{\"config\":\"как настроить специальные опции билда\",\"your_repos\":\"Используйте переключатели, чтобы включить Travis service hook для вашего проекта, а потом отправьте код на GitHub.<br />\\nДля тестирования на нескольких версиях Ruby смотрите\"},\"messages\":{\"notice\":\"Перед началом, пожалуйста, прочтите <a href=\\\"http://about.travis-ci.org/docs/user/getting-started/\\\">Руководство для быстрого старта</a>. <small>Это займет всего несколько минут.</small>\"},\"token\":\"Токен\",\"update\":\"Обновить\",\"update_locale\":\"Обновить\",\"your_locale\":\"Ваш язык\",\"your_repos\":\"Ваши репозитории\"}},\"queue\":\"Очередь\",\"repositories\":{\"branch\":\"Ветка\",\"commit\":\"Коммит\",\"duration\":\"Длительность\",\"finished_at\":\"Завершен\",\"image_url\":\"URL изображения\",\"markdown\":\"Markdown\",\"message\":\"Комментарий\",\"rdoc\":\"RDOC\",\"started_at\":\"Начало\",\"tabs\":{\"branches\":\"Статус веток\",\"build\":\"Билд\",\"build_history\":\"История\",\"current\":\"Текущий\",\"job\":\"Задача\"},\"textile\":\"Textile\"},\"repository\":{\"duration\":\"Длительность\"},\"statistics\":{\"index\":{\"build_count\":\"Количество билдов\",\"count\":\"Количество\",\"last_month\":\"прошлый месяц\",\"repo_growth\":\"Рост числа репозиториев\",\"total_builds\":\"Всего билдов\",\"total_projects\":\"Всего проектов/репозиториев\"}},\"workers\":\"Машины\",\"locales\":{\"en\":\"English\",\"es\":\"Español\",\"ja\":\"日本語\",\"ru\":\"Русский\",\"fr\":\"Français\",\"nb\":\"Norsk Bokmål\",\"pl\":\"Polski\",\"nl\":\"Nederlands\",\"pt-BR\":\"português brasileiro\"}}};\n\n\n})();\n//@ sourceURL=i18n");minispade.register('locales', "(function() {window.I18n.translations = {\"ca\":{\"locales\":{\"en\":\"English\",\"es\":\"Español\",\"fr\":\"Français\",\"ja\":\"日本語\",\"nb\":\"Norsk Bokmål\",\"nl\":\"Nederlands\",\"pl\":\"Polski\",\"pt-BR\":\"português brasileiro\",\"ru\":\"Русский\"}},\"en\":{\"errors\":{\"messages\":{\"not_found\":\"not found\",\"already_confirmed\":\"was already confirmed\",\"not_locked\":\"was not locked\"}},\"devise\":{\"failure\":{\"unauthenticated\":\"You need to sign in or sign up before continuing.\",\"unconfirmed\":\"You have to confirm your account before continuing.\",\"locked\":\"Your account is locked.\",\"invalid\":\"Invalid email or password.\",\"invalid_token\":\"Invalid authentication token.\",\"timeout\":\"Your session expired, please sign in again to continue.\",\"inactive\":\"Your account was not activated yet.\"},\"sessions\":{\"signed_in\":\"Signed in successfully.\",\"signed_out\":\"Signed out successfully.\"},\"passwords\":{\"send_instructions\":\"You will receive an email with instructions about how to reset your password in a few minutes.\",\"updated\":\"Your password was changed successfully. You are now signed in.\"},\"confirmations\":{\"send_instructions\":\"You will receive an email with instructions about how to confirm your account in a few minutes.\",\"confirmed\":\"Your account was successfully confirmed. You are now signed in.\"},\"registrations\":{\"signed_up\":\"You have signed up successfully. If enabled, a confirmation was sent to your e-mail.\",\"updated\":\"You updated your account successfully.\",\"destroyed\":\"Bye! Your account was successfully cancelled. We hope to see you again soon.\"},\"unlocks\":{\"send_instructions\":\"You will receive an email with instructions about how to unlock your account in a few minutes.\",\"unlocked\":\"Your account was successfully unlocked. You are now signed in.\"},\"mailer\":{\"confirmation_instructions\":{\"subject\":\"Confirmation instructions\"},\"reset_password_instructions\":{\"subject\":\"Reset password instructions\"},\"unlock_instructions\":{\"subject\":\"Unlock Instructions\"}}},\"datetime\":{\"distance_in_words\":{\"hours_exact\":{\"one\":\"%{count} hour\",\"other\":\"%{count} hours\"},\"minutes_exact\":{\"one\":\"%{count} minute\",\"other\":\"%{count} minutes\"},\"seconds_exact\":{\"one\":\"%{count} second\",\"other\":\"%{count} seconds\"}}},\"workers\":\"Workers\",\"queue\":\"Queue\",\"no_job\":\"There are no jobs\",\"repositories\":{\"branch\":\"Branch\",\"image_url\":\"Image URL\",\"markdown\":\"Markdown\",\"textile\":\"Textile\",\"rdoc\":\"RDOC\",\"commit\":\"Commit\",\"message\":\"Message\",\"started_at\":\"Started\",\"duration\":\"Duration\",\"finished_at\":\"Finished\",\"tabs\":{\"current\":\"Current\",\"build_history\":\"Build History\",\"branches\":\"Branch Summary\",\"pull_requests\":\"Pull Requests\",\"build\":\"Build\",\"job\":\"Job\"}},\"build\":{\"job\":\"Job\",\"duration\":\"Duration\",\"finished_at\":\"Finished\"},\"jobs\":{\"messages\":{\"sponsored_by\":\"This test suite was run on a worker box sponsored by\"},\"build_matrix\":\"Build Matrix\",\"allowed_failures\":\"Allowed Failures\",\"author\":\"Author\",\"config\":\"Config\",\"compare\":\"Compare\",\"committer\":\"Committer\",\"branch\":\"Branch\",\"commit\":\"Commit\",\"message\":\"Message\",\"started_at\":\"Started\",\"duration\":\"Duration\",\"finished_at\":\"Finished\"},\"builds\":{\"name\":\"Build\",\"messages\":{\"sponsored_by\":\"This test suite was run on a worker box sponsored by\"},\"build_matrix\":\"Build Matrix\",\"allowed_failures\":\"Allowed Failures\",\"author\":\"Author\",\"config\":\"Config\",\"compare\":\"Compare\",\"committer\":\"Committer\",\"branch\":\"Branch\",\"commit\":\"Commit\",\"message\":\"Message\",\"started_at\":\"Started\",\"duration\":\"Duration\",\"finished_at\":\"Finished\",\"show_more\":\"Show more\"},\"layouts\":{\"top\":{\"home\":\"Home\",\"blog\":\"Blog\",\"docs\":\"Docs\",\"stats\":\"Stats\",\"github_login\":\"Sign in with Github\",\"profile\":\"Profile\",\"sign_out\":\"Sign Out\",\"admin\":\"Admin\"},\"application\":{\"fork_me\":\"Fork me on Github\",\"recent\":\"Recent\",\"search\":\"Search\",\"sponsers\":\"Sponsors\",\"sponsors_link\":\"See all of our amazing sponsors &rarr;\",\"my_repositories\":\"My Repositories\"},\"about\":{\"alpha\":\"This stuff is alpha.\",\"messages\":{\"alpha\":\"Please do <strong>not</strong> consider this a stable service. We're still far from that! More info <a href='https://github.com/travis-ci'>here.</a>\"},\"join\":\"Join us and help!\",\"mailing_list\":\"Mailing List\",\"repository\":\"Repository\",\"twitter\":\"Twitter\"},\"mobile\":{\"author\":\"Author\",\"build\":\"Build\",\"build_matrix\":\"Build Matrix\",\"commit\":\"Commit\",\"committer\":\"Committer\",\"compare\":\"Compare\",\"config\":\"Config\",\"duration\":\"Duration\",\"finished_at\":\"Finished at\",\"job\":\"Job\",\"log\":\"Log\"}},\"profiles\":{\"show\":{\"email\":\"Email\",\"github\":\"Github\",\"message\":{\"your_repos\":\"  Flick the switches below to turn on the Travis service hook for your projects, then push to GitHub.<br />\\n  To test against multiple rubies, see\",\"config\":\"how to configure custom build options\"},\"messages\":{\"notice\":\"To get started, please read our <a href=\\\"http://about.travis-ci.org/docs/user/getting-started/\\\">Getting Started guide</a>.\\n  <small>It will only take a couple of minutes.</small>\"},\"token\":\"Token\",\"your_repos\":\"Your Repositories\",\"update\":\"Update\",\"update_locale\":\"Update\",\"your_locale\":\"Your Locale\"}},\"statistics\":{\"index\":{\"count\":\"Count\",\"repo_growth\":\"Repository Growth\",\"total_projects\":\"Total Projects/Repositories\",\"build_count\":\"Build Count\",\"last_month\":\"last month\",\"total_builds\":\"Total Builds\"}},\"locales\":{\"en\":\"English\",\"es\":\"Español\",\"fr\":\"Français\",\"ja\":\"日本語\",\"nb\":\"Norsk Bokmål\",\"pl\":\"Polski\",\"ru\":\"Русский\",\"nl\":\"Nederlands\",\"pt-BR\":\"português brasileiro\"}},\"es\":{\"datetime\":{\"distance_in_words\":{\"hours_exact\":{\"one\":\"%{count} hora\",\"other\":\"%{count} horas\"},\"minutes_exact\":{\"one\":\"%{count} minuto\",\"other\":\"%{count} minutos\"},\"seconds_exact\":{\"one\":\"%{count} segundo\",\"other\":\"%{count} segundos\"}}},\"workers\":\"Procesos\",\"queue\":\"Cola\",\"no_job\":\"No hay trabajos\",\"repositories\":{\"branch\":\"Rama\",\"image_url\":\"Imagen URL\",\"markdown\":\"Markdown\",\"textile\":\"Textile\",\"rdoc\":\"RDOC\",\"commit\":\"Commit\",\"message\":\"Mensaje\",\"started_at\":\"Iniciado\",\"duration\":\"Duración\",\"finished_at\":\"Finalizado\",\"tabs\":{\"current\":\"Actual\",\"build_history\":\"Histórico\",\"branches\":\"Ramas\",\"build\":\"Builds\",\"job\":\"Trabajo\"}},\"build\":{\"job\":\"Trabajo\",\"duration\":\"Duración\",\"finished_at\":\"Finalizado\"},\"jobs\":{\"messages\":{\"sponsored_by\":\"Esta serie de tests han sido ejecutados en una caja de Proceso patrocinada por\"},\"build_matrix\":\"Matriz de Builds\",\"allowed_failures\":\"Fallos Permitidos\",\"author\":\"Autor\",\"config\":\"Configuración\",\"compare\":\"Comparar\",\"committer\":\"Committer\",\"branch\":\"Rama\",\"commit\":\"Commit\",\"message\":\"Mensaje\",\"started_at\":\"Iniciado\",\"duration\":\"Duración\",\"finished_at\":\"Finalizado\",\"sponsored_by\":\"Patrocinado por\"},\"builds\":{\"name\":\"Build\",\"messages\":{\"sponsored_by\":\"Esta serie de tests han sido ejecutados en una caja de Proceso patrocinada por\"},\"build_matrix\":\"Matriz de Builds\",\"allowed_failures\":\"Fallos Permitidos\",\"author\":\"Autor\",\"config\":\"Configuración\",\"compare\":\"Comparar\",\"committer\":\"Committer\",\"branch\":\"Rama\",\"commit\":\"Commit\",\"message\":\"Mensaje\",\"started_at\":\"Iniciado\",\"duration\":\"Duración\",\"finished_at\":\"Finalizado\"},\"layouts\":{\"top\":{\"home\":\"Inicio\",\"blog\":\"Blog\",\"docs\":\"Documentación\",\"stats\":\"Estadísticas\",\"github_login\":\"Iniciar sesión con Github\",\"profile\":\"Perfil\",\"sign_out\":\"Desconectar\",\"admin\":\"Admin\"},\"application\":{\"fork_me\":\"Hazme un Fork en Github\",\"recent\":\"Reciente\",\"search\":\"Buscar\",\"sponsers\":\"Patrocinadores\",\"sponsors_link\":\"Ver todos nuestros patrocinadores &rarr;\",\"my_repositories\":\"Mis Repositorios\"},\"about\":{\"alpha\":\"Esto es alpha.\",\"messages\":{\"alpha\":\"Por favor <strong>no</strong> considereis esto un servicio estable. Estamos estamos aún lejos de ello! Más información <a href='https://github.com/travis-ci'>aquí.</a>\"},\"join\":\"Únetenos y ayudanos!\",\"mailing_list\":\"Lista de Correos\",\"repository\":\"Repositorio\",\"twitter\":\"Twitter\"}},\"profiles\":{\"show\":{\"email\":\"Correo electrónico\",\"github\":\"Github\",\"message\":{\"your_repos\":\"  Activa los interruptores para inicial el  Travis service hook para tus proyectos, y haz un Push en GitHub.<br />\\n  Para probar varias versiones de ruby, mira\",\"config\":\"como configurar tus propias opciones para el Build\"},\"messages\":{\"notice\":\"Para comenzar, por favor lee nuestra <a href=\\\"http://about.travis-ci.org/docs/user/getting-started/\\\">Guía de Inicio </a>.\\n  <small>Solo tomará unos pocos minutos.</small>\"},\"token\":\"Token\",\"your_repos\":\"Tus repositorios\",\"update\":\"Actualizar\",\"update_locale\":\"Actualizar\",\"your_locale\":\"Tu Idioma\"}},\"statistics\":{\"index\":{\"count\":\"Número\",\"repo_growth\":\"Crecimiento de Repositorios\",\"total_projects\":\"Total de Proyectos/Repositorios\",\"build_count\":\"Número de Builds\",\"last_month\":\"mes anterior\",\"total_builds\":\"Total de Builds\"}},\"locales\":{\"en\":\"English\",\"es\":\"Español\",\"fr\":\"Français\",\"ja\":\"日本語\",\"nb\":\"Norsk Bokmål\",\"pl\":\"Polski\",\"ru\":\"Русский\",\"nl\":\"Nederlands\",\"pt-BR\":\"português brasileiro\"}},\"fr\":{\"datetime\":{\"distance_in_words\":{\"hours_exact\":{\"one\":\"%{count} heure\",\"other\":\"%{count} heures\"},\"minutes_exact\":{\"one\":\"%{count} minute\",\"other\":\"%{count} minutes\"},\"seconds_exact\":{\"one\":\"%{count} seconde\",\"other\":\"%{count} secondes\"}}},\"workers\":\"Processus\",\"queue\":\"File\",\"no_job\":\"Pas de tâches\",\"repositories\":{\"branch\":\"Branche\",\"image_url\":\"Image\",\"markdown\":\"Markdown\",\"textile\":\"Textile\",\"rdoc\":\"RDOC\",\"commit\":\"Commit\",\"message\":\"Message\",\"started_at\":\"Commencé\",\"duration\":\"Durée\",\"finished_at\":\"Terminé\",\"tabs\":{\"current\":\"Actuel\",\"build_history\":\"Historique des tâches\",\"branches\":\"Résumé des branches\",\"build\":\"Construction\",\"job\":\"Tâche\"}},\"build\":{\"job\":\"Tâche\",\"duration\":\"Durée\",\"finished_at\":\"Terminé\"},\"jobs\":{\"messages\":{\"sponsored_by\":\"Cette série de tests a été exécutée sur une machine sponsorisée par\"},\"build_matrix\":\"Matrice des versions\",\"allowed_failures\":\"Échecs autorisés\",\"author\":\"Auteur\",\"config\":\"Config\",\"compare\":\"Comparer\",\"committer\":\"Committeur\",\"branch\":\"Branche\",\"commit\":\"Commit\",\"message\":\"Message\",\"started_at\":\"Commencé\",\"duration\":\"Durée\",\"finished_at\":\"Terminé\",\"sponsored_by\":\"Cette série de tests a été exécutée sur une machine sponsorisée par\"},\"builds\":{\"name\":\"Version\",\"messages\":{\"sponsored_by\":\"Cette série de tests a été exécutée sur une machine sponsorisée par\"},\"build_matrix\":\"Matrice des versions\",\"allowed_failures\":\"Échecs autorisés\",\"author\":\"Auteur\",\"config\":\"Config\",\"compare\":\"Comparer\",\"committer\":\"Committeur\",\"branch\":\"Branche\",\"commit\":\"Commit\",\"message\":\"Message\",\"started_at\":\"Commencé\",\"duration\":\"Durée\",\"finished_at\":\"Terminé\"},\"layouts\":{\"top\":{\"home\":\"Accueil\",\"blog\":\"Blog\",\"docs\":\"Documentation\",\"stats\":\"Statistiques\",\"github_login\":\"Connection Github\",\"profile\":\"Profil\",\"sign_out\":\"Déconnection\",\"admin\":\"Admin\"},\"application\":{\"fork_me\":\"Faites un Fork sur Github\",\"recent\":\"Récent\",\"search\":\"Chercher\",\"sponsers\":\"Sponsors\",\"sponsors_link\":\"Voir tous nos extraordinaire sponsors &rarr;\",\"my_repositories\":\"Mes dépôts\"},\"about\":{\"alpha\":\"Ceci est en alpha.\",\"messages\":{\"alpha\":\"S'il vous plaît ne considérez <strong>pas</strong> ce service comme étant stable. Nous sommes loin de ça! Plus d'infos <a href='https://github.com/travis-ci'>ici.</a>\"},\"join\":\"Joignez-vous à nous et aidez-nous!\",\"mailing_list\":\"Liste de distribution\",\"repository\":\"Dépôt\",\"twitter\":\"Twitter\"},\"mobile\":{\"author\":\"Auteur\",\"build\":\"Version\",\"build_matrix\":\"Matrice des versions\",\"commit\":\"Commit\",\"committer\":\"Committeur\",\"compare\":\"Comparer\",\"config\":\"Config\",\"duration\":\"Durée\",\"finished_at\":\"Terminé à\",\"job\":\"Tâche\",\"log\":\"Journal\"}},\"profiles\":{\"show\":{\"github\":\"Github\",\"message\":{\"your_repos\":\"Utilisez les boutons ci-dessous pour activer Travis sur vos projets puis déployez sur GitHub.<br />\\nPour tester sur plus de versions de ruby, voir\",\"config\":\"comment configurer des options de version personnalisées\"},\"messages\":{\"notice\":\"Pour commencer, veuillez lire notre <a href=\\\"http://about.travis-ci.org/docs/user/getting-started/\\\">guide de démarrage</a>.\\n <small>Cela ne vous prendra que quelques minutes.</small>\"},\"token\":\"Jeton\",\"your_repos\":\"Vos dépôts\",\"email\":\"Courriel\",\"update\":\"Modifier\",\"update_locale\":\"Modifier\",\"your_locale\":\"Votre langue\"}},\"statistics\":{\"index\":{\"count\":\"Décompte\",\"repo_growth\":\"Croissance de dépôt\",\"total_projects\":\"Total des projets/dépôts\",\"build_count\":\"Décompte des versions\",\"last_month\":\"mois dernier\",\"total_builds\":\"Total des versions\"}},\"admin\":{\"actions\":{\"create\":\"créer\",\"created\":\"créé\",\"delete\":\"supprimer\",\"deleted\":\"supprimé\",\"update\":\"mise à jour\",\"updated\":\"mis à jour\"},\"credentials\":{\"log_out\":\"Déconnection\"},\"delete\":{\"confirmation\":\"Oui, je suis sure\",\"flash_confirmation\":\"%{name} a été détruit avec succès\"},\"flash\":{\"error\":\"%{name} n'a pas pu être %{action}\",\"noaction\":\"Aucune action n'a été entreprise\",\"successful\":\"%{name} a réussi à %{action}\"},\"history\":{\"name\":\"Historique\",\"no_activity\":\"Aucune activité\",\"page_name\":\"Historique pour %{name}\"},\"list\":{\"add_new\":\"Ajouter un nouveau\",\"delete_action\":\"Supprimer\",\"delete_selected\":\"Supprimer la sélection\",\"edit_action\":\"Modifier\",\"search\":\"Rechercher\",\"select\":\"Sélectionner le %{name} à modifier\",\"select_action\":\"Sélectionner\",\"show_all\":\"Montrer tout\"},\"new\":{\"basic_info\":\"Information de base\",\"cancel\":\"Annuler\",\"chosen\":\"%{name} choisi\",\"chose_all\":\"Choisir tout\",\"clear_all\":\"Déselectionner tout\",\"many_chars\":\"caractères ou moins\",\"one_char\":\"caractère.\",\"optional\":\"Optionnel\",\"required\":\"Requis\",\"save\":\"Sauvegarder\",\"save_and_add_another\":\"Sauvegarder et en ajouter un autre\",\"save_and_edit\":\"Sauvegarder et modifier\",\"select_choice\":\"Faites vos choix et cliquez\"},\"dashboard\":{\"add_new\":\"Ajouter un nouveau\",\"last_used\":\"Dernière utilisation\",\"model_name\":\"Nom du modèle\",\"modify\":\"Modification\",\"name\":\"Tableau de bord\",\"pagename\":\"Administration du site\",\"records\":\"Enregistrements\",\"show\":\"Voir\",\"ago\":\"plus tôt\"}},\"home\":{\"name\":\"accueil\"},\"repository\":{\"duration\":\"Durée\"},\"devise\":{\"confirmations\":{\"confirmed\":\"Votre compte a été crée avec succès. Vous être maintenant connecté.\",\"send_instructions\":\"Vous allez recevoir un courriel avec les instructions de confirmation de votre compte dans quelques minutes.\"},\"failure\":{\"inactive\":\"Votre compte n'a pas encore été activé.\",\"invalid\":\"Adresse courriel ou mot de passe invalide.\",\"invalid_token\":\"Jeton d'authentification invalide.\",\"locked\":\"Votre compte est bloqué.\",\"timeout\":\"Votre session est expirée, veuillez vous reconnecter pour continuer.\",\"unauthenticated\":\"Vous devez vous connecter ou vous enregistrer afin de continuer\",\"unconfirmed\":\"Vous devez confirmer votre compte avant de continuer.\"},\"mailer\":{\"confirmation_instructions\":{\"subject\":\"Instructions de confirmations\"},\"reset_password_instructions\":{\"subject\":\"Instruction de remise à zéro du mot de passe\"},\"unlock_instructions\":{\"subject\":\"Instruction de débloquage\"}},\"passwords\":{\"send_instructions\":\"Vous recevrez un courriel avec les instructions de remise à zéro du mot de passe dans quelques minutes.\",\"updated\":\"Votre mot de passe a été changé avec succès. Vous êtes maintenant connecté.\"},\"registrations\":{\"destroyed\":\"Au revoir! Votre compte a été annulé avec succès. Nous espérons vous revoir bientôt.\",\"signed_up\":\"Vous êtes enregistré avec succès. Si activé, une confirmation vous a été envoyé par courriel.\",\"updated\":\"Votre compte a été mis a jour avec succès\"},\"sessions\":{\"signed_in\":\"Connecté avec succès\",\"signed_out\":\"Déconnecté avec succès\"},\"unlocks\":{\"send_instructions\":\"Vous recevrez un courriel contenant les instructions pour débloquer votre compte dans quelques minutes.\",\"unlocked\":\"Votre compte a été débloqué avec succès.\"}},\"errors\":{\"messages\":{\"already_confirmed\":\"étais déja confirmé\",\"not_found\":\"n'a pas été trouvé\",\"not_locked\":\"n'étais pas bloqué\"}},\"locales\":{\"en\":\"English\",\"es\":\"Español\",\"ja\":\"日本語\",\"ru\":\"Русский\",\"fr\":\"Français\",\"nb\":\"Norsk Bokmål\",\"pl\":\"Polski\",\"nl\":\"Nederlands\",\"pt-BR\":\"português brasileiro\"}},\"ja\":{\"workers\":\"ワーカー\",\"queue\":\"キュー\",\"no_job\":\"ジョブはありません\",\"repositories\":{\"branch\":\"ブランチ\",\"image_url\":\"画像URL\",\"markdown\":\".md\",\"textile\":\".textile\",\"rdoc\":\".rdoc\",\"commit\":\"コミット\",\"message\":\"メッセージ\",\"started_at\":\"開始時刻\",\"duration\":\"処理時間\",\"finished_at\":\"終了時刻\",\"tabs\":{\"current\":\"最新\",\"build_history\":\"ビルド履歴\",\"branches\":\"ブランチまとめ\",\"build\":\"ビルド\",\"job\":\"ジョブ\"}},\"build\":{\"job\":\"ジョブ\",\"duration\":\"処理時間\",\"finished_at\":\"終了時刻\"},\"jobs\":{\"messages\":{\"sponsored_by\":\"このテストは以下のスポンサーの協力で行いました。\"},\"build_matrix\":\"ビルドマトリクス\",\"allowed_failures\":\"失敗許容範囲内\",\"author\":\"制作者\",\"config\":\"設定\",\"compare\":\"比較\",\"committer\":\"コミット者\",\"branch\":\"ブランチ\",\"commit\":\"コミット\",\"message\":\"メッセージ\",\"started_at\":\"開始時刻\",\"duration\":\"処理時間\",\"finished_at\":\"終了時刻\"},\"builds\":{\"name\":\"ビルド\",\"messages\":{\"sponsored_by\":\"このテストは以下のスポンサーの協力で行いました。\"},\"build_matrix\":\"失敗許容範囲外\",\"allowed_failures\":\"失敗許容範囲内\",\"author\":\"制作者\",\"config\":\"設定\",\"compare\":\"比較\",\"committer\":\"コミット者\",\"branch\":\"ブランチ\",\"commit\":\"コミット\",\"message\":\"メッセージ\",\"started_at\":\"開始時刻\",\"duration\":\"処理時間\",\"finished_at\":\"終了時刻\"},\"layouts\":{\"about\":{\"alpha\":\"まだアルファですよ！\",\"join\":\"参加してみよう！\",\"mailing_list\":\"メールリスト\",\"messages\":{\"alpha\":\"Travis-ciは安定したサービスまで後一歩！詳しくは<a href='https://github.com/travis-ci'>こちら</a>\"},\"repository\":\"リポジトリ\",\"twitter\":\"ツイッター\"},\"application\":{\"fork_me\":\"Githubでフォークしよう\",\"my_repositories\":\"マイリポジトリ\",\"recent\":\"最近\",\"search\":\"検索\",\"sponsers\":\"スポンサー\",\"sponsors_link\":\"スポンサーをもっと見る &rarr;\"},\"top\":{\"blog\":\"ブログ\",\"docs\":\"Travisとは？\",\"github_login\":\"Githubでログイン\",\"home\":\"ホーム\",\"profile\":\"プロフィール\",\"sign_out\":\"ログアウト\",\"stats\":\"統計\",\"admin\":\"管理\"},\"mobile\":{\"author\":\"制作者\",\"build\":\"ビルド\",\"build_matrix\":\"ビルドマトリクス\",\"commit\":\"コミット\",\"committer\":\"コミット者\",\"compare\":\"比較\",\"config\":\"設定\",\"duration\":\"処理時間\",\"finished_at\":\"終了時刻\",\"job\":\"ジョブ\",\"log\":\"ログ\"}},\"profiles\":{\"show\":{\"github\":\"Github\",\"email\":\"メール\",\"message\":{\"config\":\"詳細設定\",\"your_repos\":\"以下のスイッチを設定し、Travis-ciを有効にします。Githubへプッシュしたらビルドは自動的に開始します。複数バーションや細かい設定はこちらへ：\"},\"messages\":{\"notice\":\"まずは<a href=\\\"http://about.travis-ci.org/docs/user/getting-started/\\\">Travisのはじめ方</a>を参照してください。\"},\"token\":\"トークン\",\"your_repos\":\"リポジトリ\",\"update\":\"更新\",\"update_locale\":\"更新\",\"your_locale\":\"言語設定\"}},\"statistics\":{\"index\":{\"build_count\":\"ビルド数\",\"count\":\"数\",\"last_month\":\"先月\",\"repo_growth\":\"リポジトリ\",\"total_builds\":\"合計ビルド数\",\"total_projects\":\"合計リポジトリ\"}},\"locales\":{\"en\":\"English\",\"es\":\"Español\",\"fr\":\"Français\",\"ja\":\"日本語\",\"nb\":\"Norsk Bokmål\",\"pl\":\"Polski\",\"ru\":\"Русский\",\"nl\":\"Nederlands\",\"pt-BR\":\"português brasileiro\"}},\"nb\":{\"admin\":{\"actions\":{\"create\":\"opprett\",\"created\":\"opprettet\",\"delete\":\"slett\",\"deleted\":\"slettet\",\"update\":\"oppdater\",\"updated\":\"oppdatert\"},\"credentials\":{\"log_out\":\"Logg ut\"},\"dashboard\":{\"add_new\":\"Legg til ny\",\"ago\":\"siden\",\"last_used\":\"Sist brukt\",\"model_name\":\"Modell\",\"modify\":\"Rediger\",\"name\":\"Dashbord\",\"pagename\":\"Nettstedsadministrasjon\",\"records\":\"Oppføringer\",\"show\":\"Vis\"},\"delete\":{\"confirmation\":\"Ja, jeg er sikker\",\"flash_confirmation\":\"%{name} ble slettet\"},\"flash\":{\"error\":\"%{name} kunne ikke bli %{action}\",\"noaction\":\"Ingen handlinger ble utført\",\"successful\":\"%{name} ble %{action}\"},\"history\":{\"name\":\"Logg\",\"no_activity\":\"Ingen aktivitet\",\"page_name\":\"Logg for %{name}\"},\"list\":{\"add_new\":\"Legg til ny\",\"delete_action\":\"Slett\",\"delete_selected\":\"Slett valgte\",\"edit_action\":\"Rediger\",\"search\":\"Søk\",\"select\":\"Velg %{name} for å redigere\",\"select_action\":\"Velg\",\"show_all\":\"Vis alle \"},\"new\":{\"basic_info\":\"Basisinformasjon\",\"cancel\":\"Avbryt\",\"chosen\":\"Valgt %{name}\",\"chose_all\":\"Velg alle\",\"clear_all\":\"Fjern alle\",\"many_chars\":\"eller færre tegn.\",\"one_char\":\"tegn.\",\"optional\":\"Valgfri\",\"required\":\"Påkrevd\",\"save\":\"Lagre\",\"save_and_add_another\":\"Lagre og legg til ny\",\"save_and_edit\":\"Lagre og rediger\",\"select_choice\":\"Kryss av for dine valg og klikk\"}},\"build\":{\"duration\":\"Varighet\",\"finished_at\":\"Fullført\",\"job\":\"Jobb\"},\"builds\":{\"allowed_failures\":\"Tillatte feil\",\"author\":\"Forfatter\",\"branch\":\"Gren\",\"build_matrix\":\"Jobbmatrise\",\"commit\":\"Innsending\",\"committer\":\"Innsender\",\"compare\":\"Sammenlign\",\"config\":\"Oppsett\",\"duration\":\"Varighet\",\"finished_at\":\"Fullført\",\"message\":\"Beskrivelse\",\"messages\":{\"sponsored_by\":\"Denne testen ble kjørt på en maskin sponset av\"},\"name\":\"Jobb\",\"started_at\":\"Startet\"},\"datetime\":{\"distance_in_words\":{\"hours_exact\":{\"one\":\"%{count} time\",\"other\":\"%{count} timer\"},\"minutes_exact\":{\"one\":\"%{count} minutt\",\"other\":\"%{count} minutter\"},\"seconds_exact\":{\"one\":\"%{count} sekund\",\"other\":\"%{count} sekunder\"}}},\"devise\":{\"confirmations\":{\"confirmed\":\"Din konto er aktivert og du er nå innlogget.\",\"send_instructions\":\"Om noen få minutter så vil du få en e-post med informasjon om hvordan du bekrefter kontoen din.\"},\"failure\":{\"inactive\":\"Kontoen din har ikke blitt aktivert enda.\",\"invalid\":\"Ugyldig e-post eller passord.\",\"invalid_token\":\"Ugyldig autentiseringskode.\",\"locked\":\"Kontoen din er låst.\",\"timeout\":\"Du ble logget ut siden på grunn av mangel på aktivitet, vennligst logg inn på nytt.\",\"unauthenticated\":\"Du må logge inn eller registrere deg for å fortsette.\",\"unconfirmed\":\"Du må bekrefte kontoen din før du kan fortsette.\"},\"mailer\":{\"confirmation_instructions\":{\"subject\":\"Bekreftelsesinformasjon\"},\"reset_password_instructions\":{\"subject\":\"Instruksjoner for å få nytt passord\"},\"unlock_instructions\":{\"subject\":\"Opplåsningsinstruksjoner\"}},\"passwords\":{\"send_instructions\":\"Om noen få minutter så vil du få en epost med informasjon om hvordan du kan få et nytt passord.\",\"updated\":\"Passordet ditt ble endret, og du er logget inn.\"},\"registrations\":{\"destroyed\":\"Adjø! Kontoen din ble kansellert. Vi håper vi ser deg igjen snart.\",\"signed_up\":\"Du er nå registrert.\",\"updated\":\"Kontoen din ble oppdatert.\"},\"sessions\":{\"signed_in\":\"Du er nå logget inn.\",\"signed_out\":\"Du er nå logget ut.\"},\"unlocks\":{\"send_instructions\":\"Om noen få minutter så kommer du til å få en e-post med informasjon om hvordan du kan låse opp kontoen din.\",\"unlocked\":\"Kontoen din ble låst opp, og du er nå logget inn igjen.\"}},\"errors\":{\"messages\":{\"already_confirmed\":\"har allerede blitt bekreftet\",\"not_found\":\"ikke funnnet\",\"not_locked\":\"var ikke låst\"}},\"home\":{\"name\":\"hjem\"},\"jobs\":{\"allowed_failures\":\"Tillatte feil\",\"author\":\"Forfatter\",\"branch\":\"Gren\",\"build_matrix\":\"Jobbmatrise\",\"commit\":\"Innsending\",\"committer\":\"Innsender\",\"compare\":\"Sammenlign\",\"config\":\"Oppsett\",\"duration\":\"Varighet\",\"finished_at\":\"Fullført\",\"message\":\"Beskrivelse\",\"messages\":{\"sponsored_by\":\"Denne testserien ble kjørt på en maskin sponset av\"},\"started_at\":\"Startet\"},\"layouts\":{\"about\":{\"alpha\":\"Dette er alfa-greier.\",\"join\":\"Bli med og hjelp oss!\",\"mailing_list\":\"E-postliste\",\"messages\":{\"alpha\":\"Dette er <strong>ikke</strong> en stabil tjeneste. Vi har fremdeles et stykke igjen! Mer informasjon finner du <a href=\\\"https://github.com/travis-ci\\\">her</a>.\"},\"repository\":\"Kodelager\",\"twitter\":\"Twitter.\"},\"application\":{\"fork_me\":\"Se koden på Github\",\"my_repositories\":\"Mine kodelagre\",\"recent\":\"Nylig\",\"search\":\"Søk\",\"sponsers\":\"Sponsorer\",\"sponsors_link\":\"Se alle de flotte sponsorene våre &rarr;\"},\"mobile\":{\"author\":\"Forfatter\",\"build\":\"Jobb\",\"build_matrix\":\"Jobbmatrise\",\"commit\":\"Innsending\",\"committer\":\"Innsender\",\"compare\":\"Sammenlign\",\"config\":\"Oppsett\",\"duration\":\"Varighet\",\"finished_at\":\"Fullført\",\"job\":\"Jobb\",\"log\":\"Logg\"},\"top\":{\"admin\":\"Administrator\",\"blog\":\"Blogg\",\"docs\":\"Dokumentasjon\",\"github_login\":\"Logg inn med Github\",\"home\":\"Hjem\",\"profile\":\"Profil\",\"sign_out\":\"Logg ut\",\"stats\":\"Statistikk\"}},\"no_job\":\"Ingen jobber finnnes\",\"profiles\":{\"show\":{\"email\":\"E-post\",\"github\":\"Github\",\"message\":{\"config\":\"hvordan sette opp egne jobbinnstillinger\",\"your_repos\":\"Slå\\u0010 på Travis for prosjektene dine ved å dra i bryterne under, og send koden til Github.<br />\\nFor å teste mot flere ruby-versjoner, se dokumentasjonen for\"},\"messages\":{\"notice\":\"For å komme i gang, vennligst les <a href=\\\"http://about.travis-ci.org/docs/user/getting-started/\\\">kom-i-gang-veivisereren</a> vår. <small>Det tar bare et par minutter.</small>\"},\"token\":\"Kode\",\"update\":\"Oppdater\",\"update_locale\":\"Oppdater\",\"your_locale\":\"Ditt språk\",\"your_repos\":\"Dine kodelagre\"}},\"queue\":\"Kø\",\"repositories\":{\"branch\":\"Gren\",\"commit\":\"Innsender\",\"duration\":\"Varighet\",\"finished_at\":\"Fullført\",\"image_url\":\"Bilde-URL\",\"markdown\":\"Markdown\",\"message\":\"Beskrivelse\",\"rdoc\":\"RDOC\",\"started_at\":\"Startet\",\"tabs\":{\"branches\":\"Grensammendrag\",\"build\":\"Jobb\",\"build_history\":\"Jobblogg\",\"current\":\"Siste\",\"job\":\"Jobb\"},\"textile\":\"Textile\"},\"repository\":{\"duration\":\"Varighet\"},\"statistics\":{\"index\":{\"build_count\":\"Antall jobber\",\"count\":\"Antall\",\"last_month\":\"siste måned\",\"repo_growth\":\"Vekst i kodelager\",\"total_builds\":\"Totale jobber\",\"total_projects\":\"Antall prosjekter/kodelagre\"}},\"workers\":\"Arbeidere\",\"locales\":{\"en\":\"English\",\"es\":\"Español\",\"ja\":\"日本語\",\"ru\":\"Русский\",\"fr\":\"Français\",\"nb\":\"Norsk Bokmål\",\"pl\":\"Polski\",\"nl\":\"Nederlands\",\"pt-BR\":\"português brasileiro\"}},\"nl\":{\"admin\":{\"actions\":{\"create\":\"aanmaken\",\"created\":\"aangemaakt\",\"delete\":\"verwijderen\",\"deleted\":\"verwijderd\",\"update\":\"bijwerken\",\"updated\":\"bijgewerkt\"},\"credentials\":{\"log_out\":\"Afmelden\"},\"dashboard\":{\"add_new\":\"Nieuwe toevoegen\",\"ago\":\"geleden\",\"last_used\":\"Laatst gebruikt\",\"model_name\":\"Model naam\",\"modify\":\"Wijzigen\",\"pagename\":\"Site administratie\",\"show\":\"Laten zien\",\"records\":\"Gegevens\"},\"delete\":{\"confirmation\":\"Ja, ik ben zeker\",\"flash_confirmation\":\"%{name} is vernietigd\"},\"flash\":{\"error\":\"%{name} kon niet worden %{action}\",\"noaction\":\"Er zijn geen acties genomen\",\"successful\":\"%{name} is %{action}\"},\"history\":{\"name\":\"Geschiedenis\",\"no_activity\":\"Geen activiteit\",\"page_name\":\"Geschiedenis van %{name}\"},\"list\":{\"add_new\":\"Nieuwe toevoegen\",\"delete_action\":\"Verwijderen\",\"delete_selected\":\"Verwijder geselecteerden\",\"edit_action\":\"Bewerken\",\"search\":\"Zoeken\",\"select\":\"Selecteer %{name} om te bewerken\",\"select_action\":\"Selecteer\",\"show_all\":\"Laat allen zien\"},\"new\":{\"basic_info\":\"Basisinfo\",\"cancel\":\"Annuleren\",\"chosen\":\"%{name} gekozen\",\"chose_all\":\"Kies allen\",\"clear_all\":\"Deselecteer allen\",\"many_chars\":\"tekens of minder.\",\"one_char\":\"teken.\",\"optional\":\"Optioneel\",\"required\":\"Vereist\",\"save\":\"Opslaan\",\"save_and_add_another\":\"Opslaan en een nieuwe toevoegen\",\"save_and_edit\":\"Opslaan en bewerken\",\"select_choice\":\"Selecteer uw keuzes en klik\"}},\"build\":{\"duration\":\"Duur\",\"finished_at\":\"Voltooid\",\"job\":\"Taak\"},\"builds\":{\"allowed_failures\":\"Toegestane mislukkingen\",\"author\":\"Auteur\",\"branch\":\"Tak\",\"build_matrix\":\"Bouw Matrix\",\"compare\":\"Vergelijk\",\"config\":\"Configuratie\",\"duration\":\"Duur\",\"finished_at\":\"Voltooid\",\"message\":\"Bericht\",\"messages\":{\"sponsored_by\":\"Deze tests zijn gedraaid op een machine gesponsord door\"},\"name\":\"Bouw\",\"started_at\":\"Gestart\",\"commit\":\"Commit\",\"committer\":\"Committer\"},\"datetime\":{\"distance_in_words\":{\"hours_exact\":{\"one\":\"%{count} uur\",\"other\":\"%{count} uren\"},\"minutes_exact\":{\"one\":\"%{count} minuut\",\"other\":\"%{count} minuten\"},\"seconds_exact\":{\"one\":\"%{count} seconde\",\"other\":\"%{count} seconden\"}}},\"devise\":{\"confirmations\":{\"confirmed\":\"Uw account is bevestigd. U wordt nu ingelogd.\",\"send_instructions\":\"Binnen enkele minuten zal u een email ontvangen met instructies om uw account te bevestigen.\"},\"failure\":{\"inactive\":\"Uw account is nog niet geactiveerd.\",\"invalid\":\"Ongeldig email adres of wachtwoord.\",\"invalid_token\":\"Ongeldig authenticatie token.\",\"locked\":\"Uw account is vergrendeld.\",\"timeout\":\"Uw sessie is verlopen, gelieve opnieuw in te loggen om verder te gaan.\",\"unauthenticated\":\"U moet inloggen of u registeren voordat u verder gaat.\",\"unconfirmed\":\"U moet uw account bevestigen voordat u verder gaat.\"},\"mailer\":{\"confirmation_instructions\":{\"subject\":\"Bevestigings-instructies\"},\"reset_password_instructions\":{\"subject\":\"Wachtwoord herstel instructies\"},\"unlock_instructions\":{\"subject\":\"Ontgrendel-instructies\"}},\"passwords\":{\"send_instructions\":\"Binnen enkele minuten zal u een email krijgen met instructies om uw wachtwoord opnieuw in te stellen.\",\"updated\":\"Uw wachtwoord is veranderd. U wordt nu ingelogd.\"},\"registrations\":{\"destroyed\":\"Dag! Uw account is geannuleerd. We hopen u vlug terug te zien.\",\"signed_up\":\"Uw registratie is voltooid. Als het ingeschakeld is wordt een bevestiging naar uw email adres verzonden.\",\"updated\":\"Het bijwerken van uw account is gelukt.\"},\"sessions\":{\"signed_in\":\"Inloggen gelukt.\",\"signed_out\":\"Uitloggen gelukt.\"},\"unlocks\":{\"send_instructions\":\"Binnen enkele minuten zal u een email krijgen met instructies om uw account te ontgrendelen.\",\"unlocked\":\"Uw account is ontgrendeld. U wordt nu ingelogd.\"}},\"errors\":{\"messages\":{\"already_confirmed\":\"was al bevestigd\",\"not_found\":\"niet gevonden\",\"not_locked\":\"was niet vergrendeld\"}},\"jobs\":{\"allowed_failures\":\"Toegestane mislukkingen\",\"author\":\"Auteur\",\"branch\":\"Tak\",\"build_matrix\":\"Bouw matrix\",\"compare\":\"Vergelijk\",\"config\":\"Configuratie\",\"duration\":\"Duur\",\"finished_at\":\"Voltooid\",\"message\":\"Bericht\",\"messages\":{\"sponsored_by\":\"Deze testen zijn uitgevoerd op een machine gesponsord door\"},\"started_at\":\"Gestart\",\"commit\":\"Commit\",\"committer\":\"Committer\"},\"layouts\":{\"about\":{\"alpha\":\"Dit is in alfa-stadium.\",\"join\":\"Doe met ons mee en help!\",\"mailing_list\":\"Mailing lijst\",\"messages\":{\"alpha\":\"Gelieve deze service <strong>niet</strong> te beschouwen als stabiel. Daar zijn we nog lang niet! Meer info <a href='https://github.com/travis-ci'>hier.</a>\"},\"repository\":\"Repository\",\"twitter\":\"Twitter\"},\"application\":{\"fork_me\":\"Maak een fork op Github\",\"my_repositories\":\"Mijn repositories\",\"recent\":\"Recent\",\"search\":\"Zoeken\",\"sponsers\":\"Sponsors\",\"sponsors_link\":\"Bekijk al onze geweldige sponsors &rarr;\"},\"mobile\":{\"author\":\"Auteur\",\"build\":\"Bouw\",\"build_matrix\":\"Bouw matrix\",\"compare\":\"Vergelijk\",\"config\":\"Configuratie\",\"duration\":\"Duur\",\"finished_at\":\"Voltooid op\",\"job\":\"Taak\",\"commit\":\"Commit\",\"committer\":\"Committer\",\"log\":\"Logboek\"},\"top\":{\"admin\":\"Administratie\",\"blog\":\"Blog\",\"docs\":\"Documentatie\",\"github_login\":\"Inloggen met Github\",\"home\":\"Home\",\"profile\":\"Profiel\",\"sign_out\":\"Uitloggen\",\"stats\":\"Statistieken\"}},\"locales\":{\"en\":\"English\",\"es\":\"Español\",\"fr\":\"Français\",\"ja\":\"日本語\",\"nb\":\"Norsk Bokmål\",\"nl\":\"Nederlands\",\"pl\":\"Polski\",\"ru\":\"Русский\",\"pt-BR\":\"português brasileiro\"},\"no_job\":\"Er zijn geen taken\",\"profiles\":{\"show\":{\"email\":\"Email adres\",\"github\":\"Github\",\"message\":{\"config\":\"hoe eigen bouw-opties in te stellen\",\"your_repos\":\"Zet de schakelaars hieronder aan om de Travis hook voor uw projecten te activeren en push daarna naar Github<br />\\nOm te testen tegen meerdere rubies, zie\"},\"messages\":{\"notice\":\"Om te beginnen kunt u onze <a href=\\\\\\\"http://about.travis-ci.org/docs/user/getting-started/\\\\\\\">startersgids</a> lezen.\\\\n  <small>Het zal maar enkele minuten van uw tijd vergen.</small>\"},\"update\":\"Bijwerken\",\"update_locale\":\"Bijwerken\",\"your_locale\":\"Uw taal\",\"your_repos\":\"Uw repositories\",\"token\":\"Token\"}},\"queue\":\"Wachtrij\",\"repositories\":{\"branch\":\"Tak\",\"duration\":\"Duur\",\"finished_at\":\"Voltooid\",\"image_url\":\"Afbeeldings URL\",\"message\":\"Bericht\",\"started_at\":\"Gestart\",\"tabs\":{\"branches\":\"Tak samenvatting\",\"build\":\"Bouw\",\"build_history\":\"Bouw geschiedenis\",\"current\":\"Huidig\",\"job\":\"Taak\"},\"commit\":\"Commit\",\"markdown\":\"Markdown\",\"rdoc\":\"RDOC\",\"textile\":\"Textile\"},\"repository\":{\"duration\":\"Duur\"},\"statistics\":{\"index\":{\"build_count\":\"Bouw aantal\",\"count\":\"Aantal\",\"last_month\":\"voorbije maand\",\"repo_growth\":\"Repository groei\",\"total_builds\":\"Bouw totaal\",\"total_projects\":\"Projecten/Repository totaal\"}},\"workers\":\"Machines\",\"home\":{\"name\":\"Hoofdpagina\"}},\"pl\":{\"datetime\":{\"distance_in_words\":{\"hours_exact\":{\"one\":\"%{count} godzina\",\"other\":\"%{count} godziny\"},\"minutes_exact\":{\"one\":\"%{count} minuta\",\"other\":\"%{count} minuty\"},\"seconds_exact\":{\"one\":\"%{count} sekunda\",\"other\":\"%{count} sekundy\"}}},\"workers\":\"Workers\",\"queue\":\"Kolejka\",\"no_job\":\"Brak zadań\",\"repositories\":{\"branch\":\"Gałąź\",\"image_url\":\"URL obrazka\",\"markdown\":\"Markdown\",\"textile\":\"Textile\",\"rdoc\":\"RDOC\",\"commit\":\"Commit\",\"message\":\"Opis\",\"started_at\":\"Rozpoczęto\",\"duration\":\"Czas trwania\",\"finished_at\":\"Zakończono\",\"tabs\":{\"current\":\"Aktualny\",\"build_history\":\"Historia Buildów\",\"branches\":\"Wszystkie Gałęzie\",\"build\":\"Build\",\"job\":\"Zadanie\"}},\"build\":{\"job\":\"Zadanie\",\"duration\":\"Czas trwania\",\"finished_at\":\"Zakończono\"},\"jobs\":{\"messages\":{\"sponsored_by\":\"Te testy zostały uruchomione na maszynie sponsorowanej przez\"},\"build_matrix\":\"Macierz Buildów\",\"allowed_failures\":\"Dopuszczalne Niepowodzenia\",\"author\":\"Autor\",\"config\":\"Konfiguracja\",\"compare\":\"Porównanie\",\"committer\":\"Committer\",\"branch\":\"Gałąź\",\"commit\":\"Commit\",\"message\":\"Opis\",\"started_at\":\"Rozpoczęto\",\"duration\":\"Czas trwania\",\"finished_at\":\"Zakończono\",\"sponsored_by\":\"Te testy zostały uruchomione na maszynie sponsorowanej przez\"},\"builds\":{\"name\":\"Build\",\"messages\":{\"sponsored_by\":\"Te testy zostały uruchomione na maszynie sponsorowanej przez\"},\"build_matrix\":\"Macierz Buildów\",\"allowed_failures\":\"Dopuszczalne Niepowodzenia\",\"author\":\"Autor\",\"config\":\"Konfiguracja\",\"compare\":\"Porównanie\",\"committer\":\"Komitujący\",\"branch\":\"Gałąź\",\"commit\":\"Commit\",\"message\":\"Opis\",\"started_at\":\"Rozpoczęto\",\"duration\":\"Czas trwania\",\"finished_at\":\"Zakończono\"},\"layouts\":{\"top\":{\"home\":\"Start\",\"blog\":\"Blog\",\"docs\":\"Dokumentacja\",\"stats\":\"Statystki\",\"github_login\":\"Zaloguj się przy pomocy Githuba\",\"profile\":\"Profil\",\"sign_out\":\"Wyloguj się\"},\"application\":{\"fork_me\":\"Fork me on Github\",\"recent\":\"Ostatnie\",\"search\":\"Wyniki\",\"sponsers\":\"Sponsorzy\",\"sponsors_link\":\"Zobacz naszych wszystkich wspaniałych sponsorów &rarr;\",\"my_repositories\":\"Moje repozytoria\"},\"about\":{\"alpha\":\"To wciąż jest wersja alpha.\",\"messages\":{\"alpha\":\"Proszę <strong>nie</strong> traktuj tego jako stabilnej usługi. Wciąż nam wiele do tego brakuje! Więcej informacji znajdziesz <a href='https://github.com/travis-ci'>tutaj.</a>\"},\"join\":\"Pomóż i dołącz do nas!\",\"mailing_list\":\"Lista mailingowa\",\"repository\":\"Repozytorium\",\"twitter\":\"Twitter\"},\"mobile\":{\"author\":\"Autor\",\"build\":\"Build\",\"build_matrix\":\"Macierz Buildów\",\"commit\":\"Commit\",\"committer\":\"Komitujący\",\"compare\":\"Porównianie\",\"config\":\"Konfiguracja\",\"duration\":\"Czas trwania\",\"finished_at\":\"Zakończono\",\"job\":\"Zadanie\",\"log\":\"Log\"}},\"profiles\":{\"show\":{\"email\":\"Email\",\"github\":\"Github\",\"message\":{\"your_repos\":\"  Przesuń suwak poniżej, aby włączyć Travisa, dla twoich projektów, a następnie umieść swój kod na GitHubie.<br />\\n Aby testować swój kod przy użyciu wielu wersji Rubiego, zobacz\",\"config\":\"jak skonfigurować niestandardowe opcje builda\"},\"messages\":{\"notice\":\"Aby zacząć, przeczytaj nasz <a href=\\\"http://about.travis-ci.org/docs/user/getting-started/\\\">Przewodnik </a>.\\n  <small>Zajmie ci to tylko kilka minut.</small>\"},\"token\":\"Token\",\"your_repos\":\"Twoje repozytoria\"}},\"statistics\":{\"index\":{\"count\":\"Ilość\",\"repo_growth\":\"Przyrost repozytoriów\",\"total_projects\":\"Łącznie projektów/repozytoriów\",\"build_count\":\"Liczba buildów\",\"last_month\":\"ostatni miesiąc\",\"total_builds\":\"Łącznie Buildów\"}},\"date\":{\"abbr_day_names\":[\"nie\",\"pon\",\"wto\",\"śro\",\"czw\",\"pią\",\"sob\"],\"abbr_month_names\":[\"sty\",\"lut\",\"mar\",\"kwi\",\"maj\",\"cze\",\"lip\",\"sie\",\"wrz\",\"paź\",\"lis\",\"gru\"],\"day_names\":[\"niedziela\",\"poniedziałek\",\"wtorek\",\"środa\",\"czwartek\",\"piątek\",\"sobota\"],\"formats\":{\"default\":\"%d-%m-%Y\",\"long\":\"%B %d, %Y\",\"short\":\"%d %b\"},\"month_names\":[\"styczeń\",\"luty\",\"marzec\",\"kwiecień\",\"maj\",\"czerwiec\",\"lipiec\",\"sierpień\",\"wrzesień\",\"październik\",\"listopad\",\"grudzień\"],\"order\":[\"day\",\"month\",\"year\"]},\"errors\":{\"format\":\"%{attribute} %{message}\",\"messages\":{\"accepted\":\"musi zostać zaakceptowane\",\"blank\":\"nie może być puste\"}},\"locales\":{\"en\":\"English\",\"es\":\"Español\",\"ja\":\"日本語\",\"ru\":\"Русский\",\"fr\":\"Français\",\"nb\":\"Norsk Bokmål\",\"pl\":\"Polski\",\"nl\":\"Nederlands\",\"pt-BR\":\"português brasileiro\"}},\"pt-BR\":{\"admin\":{\"actions\":{\"create\":\"criar\",\"created\":\"criado\",\"delete\":\"deletar\",\"deleted\":\"deletado\",\"update\":\"atualizar\",\"updated\":\"atualizado\"},\"credentials\":{\"log_out\":\"Deslogar\"},\"dashboard\":{\"add_new\":\"Adicionar novo\",\"ago\":\"atrás\",\"last_used\":\"Última utilização\",\"model_name\":\"Nome do modelo\",\"modify\":\"Modificar\",\"name\":\"Dashboard\",\"pagename\":\"Administração do site\",\"records\":\"Registros\",\"show\":\"Mostrar\"},\"delete\":{\"confirmation\":\"Sim, tenho certeza\",\"flash_confirmation\":\"%{name} foi destruído com sucesso\"},\"flash\":{\"error\":\"%{name} falhou ao %{action}\",\"noaction\":\"Nenhuma ação foi tomada\",\"successful\":\"%{name} foi %{action} com sucesso\"},\"history\":{\"name\":\"Histórico\",\"no_activity\":\"Nenhuma Atividade\",\"page_name\":\"Histórico para %{name}\"},\"list\":{\"add_new\":\"Adicionar novo\",\"delete_action\":\"Deletar\",\"delete_selected\":\"Deletar selecionados\",\"edit_action\":\"Editar\",\"search\":\"Buscar\",\"select\":\"Selecionar %{name} para editar\",\"select_action\":\"Selecionar\",\"show_all\":\"Mostrar todos\"},\"new\":{\"basic_info\":\"Informações básicas\",\"cancel\":\"Cancelar\",\"chosen\":\"Escolhido %{name}\",\"chose_all\":\"Escolher todos\",\"clear_all\":\"Limpar todos\",\"many_chars\":\"caracteres ou menos.\",\"one_char\":\"caractere.\",\"optional\":\"Opcional\",\"required\":\"Requerido\",\"save\":\"Salvar\",\"save_and_add_another\":\"Salvar e adicionar outro\",\"save_and_edit\":\"Salvar e alterar\",\"select_choice\":\"Selecione e clique\"}},\"build\":{\"duration\":\"Duração\",\"finished_at\":\"Concluído em\",\"job\":\"Trabalho\"},\"builds\":{\"allowed_failures\":\"Falhas Permitidas\",\"author\":\"Autor\",\"branch\":\"Branch\",\"build_matrix\":\"Matriz de Build\",\"commit\":\"Commit\",\"committer\":\"Committer\",\"compare\":\"Comparar\",\"config\":\"Config\",\"duration\":\"Duração\",\"finished_at\":\"Concluído em\",\"message\":\"Mensagem\",\"messages\":{\"sponsored_by\":\"Esta série de testes foi executada em uma caixa de processos patrocinada por\"},\"name\":\"Build\",\"started_at\":\"Iniciou em\"},\"datetime\":{\"distance_in_words\":{\"hours_exact\":{\"one\":\"%{count} hora\",\"other\":\"%{count} horas\"},\"minutes_exact\":{\"one\":\"%{count} minuto\",\"other\":\"%{count} minutos\"},\"seconds_exact\":{\"one\":\"%{count} segundo\",\"other\":\"%{count} segundos\"}}},\"devise\":{\"confirmations\":{\"confirmed\":\"Sua conta foi confirmada com sucesso. Você agora está logado.\",\"send_instructions\":\"Você receberá um email com instruções de como confirmar sua conta em alguns minutos.\"},\"failure\":{\"inactive\":\"Sua conta ainda não foi ativada.\",\"invalid\":\"Email ou senha inválidos.\",\"invalid_token\":\"Token de autenticação inválido.\",\"locked\":\"Sua conta está trancada.\",\"timeout\":\"Sua sessão expirou, por favor faça seu login novamente.\",\"unauthenticated\":\"Você precisa fazer o login ou cadastrar-se antes de continuar.\",\"unconfirmed\":\"Você precisa confirmar sua conta antes de continuar.\"},\"mailer\":{\"confirmation_instructions\":{\"subject\":\"Instruções de confirmação\"},\"reset_password_instructions\":{\"subject\":\"Instruções de atualização de senha\"},\"unlock_instructions\":{\"subject\":\"Instruções de destrancamento\"}},\"passwords\":{\"send_instructions\":\"Você receberá um email com instruções de como atualizar sua senha em alguns minutos.\",\"updated\":\"Sua senha foi alterada com sucesso. Você agora está logado.\"},\"registrations\":{\"destroyed\":\"Tchau! Sua conta foi cancelada com sucesso. Esperamos vê-lo novamente em breve!\",\"signed_up\":\"Você se cadastrou com sucesso. Se ativada, uma confirmação foi enviada para seu email.\",\"updated\":\"Você atualizou sua conta com sucesso.\"},\"sessions\":{\"signed_in\":\"Logado com sucesso.\",\"signed_out\":\"Deslogado com sucesso.\"},\"unlocks\":{\"send_instructions\":\"Você receberá um email com instruções de como destrancar sua conta em alguns minutos.\",\"unlocked\":\"Sua conta foi destrancada com sucesso. Você agora está logado.\"}},\"errors\":{\"messages\":{\"already_confirmed\":\"já foi confirmado\",\"not_found\":\"não encontrado\",\"not_locked\":\"não estava trancado\"}},\"home\":{\"name\":\"home\"},\"jobs\":{\"allowed_failures\":\"Falhas Permitidas\",\"author\":\"Autor\",\"branch\":\"Branch\",\"build_matrix\":\"Matriz de Build\",\"commit\":\"Commit\",\"committer\":\"Committer\",\"compare\":\"Comparar\",\"config\":\"Config\",\"duration\":\"Duração\",\"finished_at\":\"Concluído em\",\"message\":\"Mensagem\",\"messages\":{\"sponsored_by\":\"Esta série de testes foi executada em uma caixa de processos patrocinada por\"},\"started_at\":\"Iniciou em\"},\"layouts\":{\"about\":{\"alpha\":\"Isto é um alpha.\",\"join\":\"Junte-se à nós e ajude!\",\"mailing_list\":\"Lista de email\",\"messages\":{\"alpha\":\"Por favor, <strong>não</strong> considere isto um serviço estável. Estamos muito longe disso! Mais informações <a href='https://github.com/travis-ci'>aqui.</a>\"},\"repository\":\"Repositório\",\"twitter\":\"Twitter\"},\"application\":{\"fork_me\":\"Faça fork no Github\",\"my_repositories\":\"Meus Repositórios\",\"recent\":\"Recentes\",\"search\":\"Buscar\",\"sponsers\":\"Patrocinadores\",\"sponsors_link\":\"Conheça todos os nossos patrocinadores &rarr;\"},\"mobile\":{\"author\":\"Autor\",\"build\":\"Build\",\"build_matrix\":\"Matriz de Build\",\"commit\":\"Commit\",\"committer\":\"Committer\",\"compare\":\"Comparar\",\"config\":\"Config\",\"duration\":\"Duração\",\"finished_at\":\"Concluído em\",\"job\":\"Trabalho\",\"log\":\"Log\"},\"top\":{\"admin\":\"Admin\",\"blog\":\"Blog\",\"docs\":\"Documentação\",\"github_login\":\"Logue com o Github\",\"home\":\"Home\",\"profile\":\"Perfil\",\"sign_out\":\"Sair\",\"stats\":\"Estatísticas\"}},\"locales\":{\"en\":\"English\",\"es\":\"Español\",\"fr\":\"Français\",\"ja\":\"日本語\",\"nb\":\"Norsk Bokmål\",\"nl\":\"Nederlands\",\"pl\":\"Polski\",\"ru\":\"Русский\",\"pt-BR\":\"português brasileiro\"},\"no_job\":\"Não há trabalhos\",\"profiles\":{\"show\":{\"email\":\"Email\",\"github\":\"Github\",\"message\":{\"config\":\"como configurar opções de build\",\"your_repos\":\"Use os botões abaixo para ligar ou desligar o hook de serviço do Travis para seus projetos, e então, faça um push para o Github.<br />Para testar com múltiplas versões do Ruby, leia\"},\"messages\":{\"notice\":\"Para começar, leia nosso <a href=\\\"http://about.travis-ci.org/docs/user/getting-started/\\\">Guia de início</a>. <small>Só leva alguns minutinhos.</small>\"},\"token\":\"Token\",\"update\":\"Atualizar\",\"update_locale\":\"Atualizar\",\"your_locale\":\"Sua língua\",\"your_repos\":\"Seus Repositórios\"}},\"queue\":\"Fila\",\"repositories\":{\"branch\":\"Branch\",\"commit\":\"Commit\",\"duration\":\"Duração\",\"finished_at\":\"Concluído em\",\"image_url\":\"URL da imagem\",\"markdown\":\"Markdown\",\"message\":\"Mensagem\",\"rdoc\":\"RDOC\",\"started_at\":\"Iniciou em\",\"tabs\":{\"branches\":\"Sumário do Branch\",\"build\":\"Build\",\"build_history\":\"Histórico de Build\",\"current\":\"Atual\",\"job\":\"Trabalho\"},\"textile\":\"Textile\"},\"repository\":{\"duration\":\"Duração\"},\"statistics\":{\"index\":{\"build_count\":\"Número de Builds\",\"count\":\"Número\",\"last_month\":\"último mês\",\"repo_growth\":\"Crescimento de Repositório\",\"total_builds\":\"Total de Builds\",\"total_projects\":\"Total de Projetos/Repositórios\"}},\"workers\":\"Processos\"},\"ru\":{\"admin\":{\"actions\":{\"create\":\"создать\",\"created\":\"создано\",\"delete\":\"удалить\",\"deleted\":\"удалено\",\"update\":\"обновить\",\"updated\":\"обновлено\"},\"credentials\":{\"log_out\":\"Выход\"},\"dashboard\":{\"add_new\":\"Добавить\",\"ago\":\"назад\",\"last_used\":\"Использовалось в последний раз\",\"model_name\":\"Имя модели\",\"modify\":\"Изменить\",\"name\":\"Панель управления\",\"pagename\":\"Управление сайтом\",\"records\":\"Записи\",\"show\":\"Показать\"},\"delete\":{\"confirmation\":\"Да, я уверен\",\"flash_confirmation\":\"%{name} успешно удалено\"},\"history\":{\"name\":\"История\",\"no_activity\":\"Нет активности\",\"page_name\":\"История %{name}\"},\"list\":{\"add_new\":\"Добавить\",\"delete_action\":\"Удалить\",\"delete_selected\":\"Удалить выбранные\",\"edit_action\":\"Редактировать\",\"search\":\"Поиск\",\"select\":\"Для редактирования выберите %{name}\",\"select_action\":\"Выбрать\",\"show_all\":\"Показать все\"},\"new\":{\"basic_info\":\"Основная информация\",\"cancel\":\"Отмена\",\"chosen\":\"Выбрано %{name}\",\"chose_all\":\"Выбрать все\",\"clear_all\":\"Очистить все\",\"one_char\":\"символ.\",\"optional\":\"Необязательно\",\"required\":\"Обязательно\",\"save\":\"Сохранить\",\"save_and_add_another\":\"Сохранить и добавить другое\",\"save_and_edit\":\"Сохранить и продолжить редактирование\",\"select_choice\":\"Выберите и кликните\",\"many_chars\":\"символов или меньше.\"},\"flash\":{\"error\":\"%{name} не удалось %{action}\",\"noaction\":\"Никаких действий не произведено\",\"successful\":\"%{name} было успешно %{action}\"}},\"build\":{\"duration\":\"Длительность\",\"finished_at\":\"Завершен\",\"job\":\"Задача\"},\"builds\":{\"allowed_failures\":\"Допустимые неудачи\",\"author\":\"Автор\",\"branch\":\"Ветка\",\"build_matrix\":\"Матрица\",\"commit\":\"Коммит\",\"committer\":\"Коммитер\",\"compare\":\"Дифф\",\"config\":\"Конфигурация\",\"duration\":\"Длительность\",\"finished_at\":\"Завершен\",\"message\":\"Комментарий\",\"messages\":{\"sponsored_by\":\"Эта серия тестов была запущена на машине, спонсируемой\"},\"name\":\"Билд\",\"started_at\":\"Начало\"},\"datetime\":{\"distance_in_words\":{\"hours_exact\":{\"one\":\"%{count} час\",\"few\":\"%{count} часа\",\"many\":\"%{count} часов\",\"other\":\"%{count} часа\"},\"minutes_exact\":{\"one\":\"%{count} минута\",\"few\":\"%{count} минуты\",\"many\":\"%{count} минут\",\"other\":\"%{count} минуты\"},\"seconds_exact\":{\"one\":\"%{count} секунда\",\"few\":\"%{count} секунды\",\"many\":\"%{count} секунд\",\"other\":\"%{count} секунды\"}}},\"devise\":{\"confirmations\":{\"confirmed\":\"Ваш аккаунт успешно подтвержден. Приветствуем!\",\"send_instructions\":\"В течении нескольких минут вы получите электронное письмо с инструкциями для прохождения процедуры подтверждения аккаунта.\"},\"failure\":{\"inactive\":\"Ваш аккаунт еще не активирован.\",\"invalid\":\"Ошибка в адресе почты или пароле.\",\"invalid_token\":\"Неправильный токен аутентификации.\",\"locked\":\"Ваш аккаунт заблокирован.\",\"timeout\":\"Сессия окончена. Для продолжения работы войдите снова.\",\"unauthenticated\":\"Вам нужно войти или зарегистрироваться.\",\"unconfirmed\":\"Вы должны сначала подтвердить свой аккаунт.\"},\"mailer\":{\"confirmation_instructions\":{\"subject\":\"Инструкции для подтверждению аккаунта\"},\"reset_password_instructions\":{\"subject\":\"Инструкции для сброса пароля\"},\"unlock_instructions\":{\"subject\":\"Инструкции для разблокирования аккаунта\"}},\"passwords\":{\"send_instructions\":\"В течении нескольких минут вы получите электронное письмо с инструкциями для сброса пароля.\",\"updated\":\"Ваш пароль успешно изменен. Приветствуем!\"},\"registrations\":{\"destroyed\":\"Ваш аккаунт был успешно удален. Живите долго и процветайте!\",\"signed_up\":\"Вы успешно прошли регистрацию. Инструкции для подтверждения аккаунта отправлены на ваш электронный адрес.\",\"updated\":\"Аккаунт успешно обновлен.\"},\"sessions\":{\"signed_in\":\"Приветствуем!\",\"signed_out\":\"Удачи!\"},\"unlocks\":{\"send_instructions\":\"В течении нескольких минут вы получите электронное письмо с инструкциям для разблокировния аккаунта.\",\"unlocked\":\"Ваш аккаунт успешно разблокирован. Приветствуем!\"}},\"errors\":{\"messages\":{\"already_confirmed\":\"уже подтвержден\",\"not_found\":\"не найден\",\"not_locked\":\"не заблокирован\"}},\"home\":{\"name\":\"Главная\"},\"jobs\":{\"allowed_failures\":\"Допустимые неудачи\",\"author\":\"Автор\",\"branch\":\"Ветка\",\"build_matrix\":\"Матрица\",\"commit\":\"Коммит\",\"committer\":\"Коммитер\",\"compare\":\"Сравнение\",\"config\":\"Конфигурация\",\"duration\":\"Длительность\",\"finished_at\":\"Завершен\",\"message\":\"Комментарий\",\"messages\":{\"sponsored_by\":\"Эта серия тестов была запущена на машине спонсируемой\"},\"started_at\":\"Начало\"},\"layouts\":{\"about\":{\"alpha\":\"Это альфа-версия\",\"join\":\"Присоединяйтесь к нам и помогайте!\",\"mailing_list\":\"Лист рассылки\",\"messages\":{\"alpha\":\"Пожалуйста, <strong>не</strong> считайте данный сервис стабильным. Мы еще очень далеки от стабильности! <a href='https://github.com/travis-ci'>Подробности</a>\"},\"repository\":\"Репозиторий\",\"twitter\":\"Twitter\"},\"application\":{\"fork_me\":\"Fork me on Github\",\"my_repositories\":\"Мои репозитории\",\"recent\":\"Недавние\",\"search\":\"Поиск\",\"sponsers\":\"Спонсоры\",\"sponsors_link\":\"Список всех наших замечательных спонсоров &rarr;\"},\"mobile\":{\"author\":\"Автор\",\"build\":\"Сборка\",\"build_matrix\":\"Матрица сборок\",\"commit\":\"Коммит\",\"committer\":\"Коммитер\",\"compare\":\"Сравнение\",\"config\":\"Конфигурация\",\"duration\":\"Длительность\",\"finished_at\":\"Завершен\",\"job\":\"Задача\",\"log\":\"Журнал\"},\"top\":{\"admin\":\"Управление\",\"blog\":\"Блог\",\"docs\":\"Документация\",\"github_login\":\"Войти через Github\",\"home\":\"Главная\",\"profile\":\"Профиль\",\"sign_out\":\"Выход\",\"stats\":\"Статистика\"}},\"no_job\":\"Очередь пуста\",\"profiles\":{\"show\":{\"email\":\"Электронная почта\",\"github\":\"Github\",\"message\":{\"config\":\"как настроить специальные опции билда\",\"your_repos\":\"Используйте переключатели, чтобы включить Travis service hook для вашего проекта, а потом отправьте код на GitHub.<br />\\nДля тестирования на нескольких версиях Ruby смотрите\"},\"messages\":{\"notice\":\"Перед началом, пожалуйста, прочтите <a href=\\\"http://about.travis-ci.org/docs/user/getting-started/\\\">Руководство для быстрого старта</a>. <small>Это займет всего несколько минут.</small>\"},\"token\":\"Токен\",\"update\":\"Обновить\",\"update_locale\":\"Обновить\",\"your_locale\":\"Ваш язык\",\"your_repos\":\"Ваши репозитории\"}},\"queue\":\"Очередь\",\"repositories\":{\"branch\":\"Ветка\",\"commit\":\"Коммит\",\"duration\":\"Длительность\",\"finished_at\":\"Завершен\",\"image_url\":\"URL изображения\",\"markdown\":\"Markdown\",\"message\":\"Комментарий\",\"rdoc\":\"RDOC\",\"started_at\":\"Начало\",\"tabs\":{\"branches\":\"Статус веток\",\"build\":\"Билд\",\"build_history\":\"История\",\"current\":\"Текущий\",\"job\":\"Задача\"},\"textile\":\"Textile\"},\"repository\":{\"duration\":\"Длительность\"},\"statistics\":{\"index\":{\"build_count\":\"Количество билдов\",\"count\":\"Количество\",\"last_month\":\"прошлый месяц\",\"repo_growth\":\"Рост числа репозиториев\",\"total_builds\":\"Всего билдов\",\"total_projects\":\"Всего проектов/репозиториев\"}},\"workers\":\"Машины\",\"locales\":{\"en\":\"English\",\"es\":\"Español\",\"ja\":\"日本語\",\"ru\":\"Русский\",\"fr\":\"Français\",\"nb\":\"Norsk Bokmål\",\"pl\":\"Polski\",\"nl\":\"Nederlands\",\"pt-BR\":\"português brasileiro\"}}};\n\n\n})();\n//@ sourceURL=locales");minispade.register('ext/ember/bound_helper', "(function() {// https://gist.github.com/2018185\n// For reference: https://github.com/wagenet/ember.js/blob/ac66dcb8a1cbe91d736074441f853e0da474ee6e/packages/ember-handlebars/lib/views/bound_property_view.js\nvar BoundHelperView = Ember.View.extend(Ember._Metamorph, {\n\n  context: null,\n  options: null,\n  property: null,\n  // paths of the property that are also observed\n  propertyPaths: [],\n\n  value: Ember.K,\n\n  valueForRender: function() {\n    var value = this.value(Ember.getPath(this.context, this.property), this.options);\n    if (this.options.escaped) { value = Handlebars.Utils.escapeExpression(value); }\n    return value;\n  },\n\n  render: function(buffer) {\n    buffer.push(this.valueForRender());\n  },\n\n  valueDidChange: function() {\n    if (this.morph.isRemoved()) { return; }\n    this.morph.html(this.valueForRender());\n  },\n\n  didInsertElement: function() {\n    this.valueDidChange();\n  },\n\n  init: function() {\n    this._super();\n    Ember.addObserver(this.context, this.property, this, 'valueDidChange');\n    this.get('propertyPaths').forEach(function(propName) {\n        Ember.addObserver(this.context, this.property + '.' + propName, this, 'valueDidChange');\n    }, this);\n  },\n\n  destroy: function() {\n    Ember.removeObserver(this.context, this.property, this, 'valueDidChange');\n    this.get('propertyPaths').forEach(function(propName) {\n        this.context.removeObserver(this.property + '.' + propName, this, 'valueDidChange');\n    }, this);\n    this._super();\n  }\n\n});\n\nEmber.registerBoundHelper = function(name, func) {\n  var propertyPaths = Array.prototype.slice.call(arguments, 2);\n  Ember.Handlebars.registerHelper(name, function(property, options) {\n    var data = options.data,\n        view = data.view,\n        ctx  = this;\n\n    var bindView = view.createChildView(BoundHelperView, {\n      property: property,\n      propertyPaths: propertyPaths,\n      context: ctx,\n      options: options.hash,\n      value: func\n    });\n\n    view.appendChild(bindView);\n  });\n};\n\n\n})();\n//@ sourceURL=ext/ember/bound_helper");
\ No newline at end of file
diff --git a/public/javascripts/spec/foo_spec.js b/public/javascripts/spec/foo_spec.js
new file mode 100644
index 00000000..45a301a3
--- /dev/null
+++ b/public/javascripts/spec/foo_spec.js
@@ -0,0 +1,21 @@
+(function() {
+
+  console.log('foo');
+
+  describe('Foo', function() {
+    it('bar', function() {
+      var link;
+      console.log('before spec');
+      link = $($('#repositories a.slug')[0]);
+      console.log($('body').html().toString());
+      return console.log('after spec');
+    });
+    return it('bar', function() {
+      var link;
+      console.log('before spec');
+      link = $($('#repositories a.slug')[0]);
+      return console.log('after spec');
+    });
+  });
+
+}).call(this);
diff --git a/public/javascripts/spec/spec_helper.js b/public/javascripts/spec/spec_helper.js
new file mode 100644
index 00000000..f1a33935
--- /dev/null
+++ b/public/javascripts/spec/spec_helper.js
@@ -0,0 +1,15 @@
+(function() {
+
+  require('app');
+
+  $('body').append($('<div id="spec_content"></div>'));
+
+  Travis.rootElement = '#spec_content';
+
+  Travis.initialize();
+
+  beforeEach(function() {});
+
+  afterEach(function() {});
+
+}).call(this);
diff --git a/public/javascripts/specs/specs.js b/public/javascripts/specs/specs.js
new file mode 100644
index 00000000..c480daf4
--- /dev/null
+++ b/public/javascripts/specs/specs.js
@@ -0,0 +1,28 @@
+(function() {
+
+  describe('Foo', function() {
+    it('bar', function() {
+      var link;
+      console.log('before spec');
+      link = $($('#repositories a.slug')[0]);
+      console.log($('body').html().toString());
+      return console.log('after spec');
+    });
+    return it('bar', function() {
+      var link;
+      console.log('before spec');
+      link = $($('#repositories a.slug')[0]);
+      return console.log('after spec');
+    });
+  });
+
+}).call(this);
+(function() {
+
+  minispade.require('app');
+
+  $('body').append($('<div id="spec_content"></div>'));
+
+  Travis.rootElement = '#spec_content';
+
+}).call(this);
diff --git a/public/javascripts/specs/vendor.js b/public/javascripts/specs/vendor.js
new file mode 100644
index 00000000..b6e83884
--- /dev/null
+++ b/public/javascripts/specs/vendor.js
@@ -0,0 +1,8005 @@
+var isCommonJS = typeof window == "undefined";
+
+/**
+ * Top level namespace for Jasmine, a lightweight JavaScript BDD/spec/testing framework.
+ *
+ * @namespace
+ */
+var jasmine = {};
+if (isCommonJS) exports.jasmine = jasmine;
+/**
+ * @private
+ */
+jasmine.unimplementedMethod_ = function() {
+  throw new Error("unimplemented method");
+};
+
+/**
+ * Use <code>jasmine.undefined</code> instead of <code>undefined</code>, since <code>undefined</code> is just
+ * a plain old variable and may be redefined by somebody else.
+ *
+ * @private
+ */
+jasmine.undefined = jasmine.___undefined___;
+
+/**
+ * Show diagnostic messages in the console if set to true
+ *
+ */
+jasmine.VERBOSE = false;
+
+/**
+ * Default interval in milliseconds for event loop yields (e.g. to allow network activity or to refresh the screen with the HTML-based runner). Small values here may result in slow test running. Zero means no updates until all tests have completed.
+ *
+ */
+jasmine.DEFAULT_UPDATE_INTERVAL = 250;
+
+/**
+ * Default timeout interval in milliseconds for waitsFor() blocks.
+ */
+jasmine.DEFAULT_TIMEOUT_INTERVAL = 5000;
+
+jasmine.getGlobal = function() {
+  function getGlobal() {
+    return this;
+  }
+
+  return getGlobal();
+};
+
+/**
+ * Allows for bound functions to be compared.  Internal use only.
+ *
+ * @ignore
+ * @private
+ * @param base {Object} bound 'this' for the function
+ * @param name {Function} function to find
+ */
+jasmine.bindOriginal_ = function(base, name) {
+  var original = base[name];
+  if (original.apply) {
+    return function() {
+      return original.apply(base, arguments);
+    };
+  } else {
+    // IE support
+    return jasmine.getGlobal()[name];
+  }
+};
+
+jasmine.setTimeout = jasmine.bindOriginal_(jasmine.getGlobal(), 'setTimeout');
+jasmine.clearTimeout = jasmine.bindOriginal_(jasmine.getGlobal(), 'clearTimeout');
+jasmine.setInterval = jasmine.bindOriginal_(jasmine.getGlobal(), 'setInterval');
+jasmine.clearInterval = jasmine.bindOriginal_(jasmine.getGlobal(), 'clearInterval');
+
+jasmine.MessageResult = function(values) {
+  this.type = 'log';
+  this.values = values;
+  this.trace = new Error(); // todo: test better
+};
+
+jasmine.MessageResult.prototype.toString = function() {
+  var text = "";
+  for (var i = 0; i < this.values.length; i++) {
+    if (i > 0) text += " ";
+    if (jasmine.isString_(this.values[i])) {
+      text += this.values[i];
+    } else {
+      text += jasmine.pp(this.values[i]);
+    }
+  }
+  return text;
+};
+
+jasmine.ExpectationResult = function(params) {
+  this.type = 'expect';
+  this.matcherName = params.matcherName;
+  this.passed_ = params.passed;
+  this.expected = params.expected;
+  this.actual = params.actual;
+  this.message = this.passed_ ? 'Passed.' : params.message;
+
+  var trace = (params.trace || new Error(this.message));
+  this.trace = this.passed_ ? '' : trace;
+};
+
+jasmine.ExpectationResult.prototype.toString = function () {
+  return this.message;
+};
+
+jasmine.ExpectationResult.prototype.passed = function () {
+  return this.passed_;
+};
+
+/**
+ * Getter for the Jasmine environment. Ensures one gets created
+ */
+jasmine.getEnv = function() {
+  var env = jasmine.currentEnv_ = jasmine.currentEnv_ || new jasmine.Env();
+  return env;
+};
+
+/**
+ * @ignore
+ * @private
+ * @param value
+ * @returns {Boolean}
+ */
+jasmine.isArray_ = function(value) {
+  return jasmine.isA_("Array", value);
+};
+
+/**
+ * @ignore
+ * @private
+ * @param value
+ * @returns {Boolean}
+ */
+jasmine.isString_ = function(value) {
+  return jasmine.isA_("String", value);
+};
+
+/**
+ * @ignore
+ * @private
+ * @param value
+ * @returns {Boolean}
+ */
+jasmine.isNumber_ = function(value) {
+  return jasmine.isA_("Number", value);
+};
+
+/**
+ * @ignore
+ * @private
+ * @param {String} typeName
+ * @param value
+ * @returns {Boolean}
+ */
+jasmine.isA_ = function(typeName, value) {
+  return Object.prototype.toString.apply(value) === '[object ' + typeName + ']';
+};
+
+/**
+ * Pretty printer for expecations.  Takes any object and turns it into a human-readable string.
+ *
+ * @param value {Object} an object to be outputted
+ * @returns {String}
+ */
+jasmine.pp = function(value) {
+  var stringPrettyPrinter = new jasmine.StringPrettyPrinter();
+  stringPrettyPrinter.format(value);
+  return stringPrettyPrinter.string;
+};
+
+/**
+ * Returns true if the object is a DOM Node.
+ *
+ * @param {Object} obj object to check
+ * @returns {Boolean}
+ */
+jasmine.isDomNode = function(obj) {
+  return obj.nodeType > 0;
+};
+
+/**
+ * Returns a matchable 'generic' object of the class type.  For use in expecations of type when values don't matter.
+ *
+ * @example
+ * // don't care about which function is passed in, as long as it's a function
+ * expect(mySpy).toHaveBeenCalledWith(jasmine.any(Function));
+ *
+ * @param {Class} clazz
+ * @returns matchable object of the type clazz
+ */
+jasmine.any = function(clazz) {
+  return new jasmine.Matchers.Any(clazz);
+};
+
+/**
+ * Returns a matchable subset of a JSON object. For use in expectations when you don't care about all of the
+ * attributes on the object.
+ *
+ * @example
+ * // don't care about any other attributes than foo.
+ * expect(mySpy).toHaveBeenCalledWith(jasmine.objectContaining({foo: "bar"});
+ *
+ * @param sample {Object} sample
+ * @returns matchable object for the sample
+ */
+jasmine.objectContaining = function (sample) {
+    return new jasmine.Matchers.ObjectContaining(sample);
+};
+
+/**
+ * Jasmine Spies are test doubles that can act as stubs, spies, fakes or when used in an expecation, mocks.
+ *
+ * Spies should be created in test setup, before expectations.  They can then be checked, using the standard Jasmine
+ * expectation syntax. Spies can be checked if they were called or not and what the calling params were.
+ *
+ * A Spy has the following fields: wasCalled, callCount, mostRecentCall, and argsForCall (see docs).
+ *
+ * Spies are torn down at the end of every spec.
+ *
+ * Note: Do <b>not</b> call new jasmine.Spy() directly - a spy must be created using spyOn, jasmine.createSpy or jasmine.createSpyObj.
+ *
+ * @example
+ * // a stub
+ * var myStub = jasmine.createSpy('myStub');  // can be used anywhere
+ *
+ * // spy example
+ * var foo = {
+ *   not: function(bool) { return !bool; }
+ * }
+ *
+ * // actual foo.not will not be called, execution stops
+ * spyOn(foo, 'not');
+
+ // foo.not spied upon, execution will continue to implementation
+ * spyOn(foo, 'not').andCallThrough();
+ *
+ * // fake example
+ * var foo = {
+ *   not: function(bool) { return !bool; }
+ * }
+ *
+ * // foo.not(val) will return val
+ * spyOn(foo, 'not').andCallFake(function(value) {return value;});
+ *
+ * // mock example
+ * foo.not(7 == 7);
+ * expect(foo.not).toHaveBeenCalled();
+ * expect(foo.not).toHaveBeenCalledWith(true);
+ *
+ * @constructor
+ * @see spyOn, jasmine.createSpy, jasmine.createSpyObj
+ * @param {String} name
+ */
+jasmine.Spy = function(name) {
+  /**
+   * The name of the spy, if provided.
+   */
+  this.identity = name || 'unknown';
+  /**
+   *  Is this Object a spy?
+   */
+  this.isSpy = true;
+  /**
+   * The actual function this spy stubs.
+   */
+  this.plan = function() {
+  };
+  /**
+   * Tracking of the most recent call to the spy.
+   * @example
+   * var mySpy = jasmine.createSpy('foo');
+   * mySpy(1, 2);
+   * mySpy.mostRecentCall.args = [1, 2];
+   */
+  this.mostRecentCall = {};
+
+  /**
+   * Holds arguments for each call to the spy, indexed by call count
+   * @example
+   * var mySpy = jasmine.createSpy('foo');
+   * mySpy(1, 2);
+   * mySpy(7, 8);
+   * mySpy.mostRecentCall.args = [7, 8];
+   * mySpy.argsForCall[0] = [1, 2];
+   * mySpy.argsForCall[1] = [7, 8];
+   */
+  this.argsForCall = [];
+  this.calls = [];
+};
+
+/**
+ * Tells a spy to call through to the actual implemenatation.
+ *
+ * @example
+ * var foo = {
+ *   bar: function() { // do some stuff }
+ * }
+ *
+ * // defining a spy on an existing property: foo.bar
+ * spyOn(foo, 'bar').andCallThrough();
+ */
+jasmine.Spy.prototype.andCallThrough = function() {
+  this.plan = this.originalValue;
+  return this;
+};
+
+/**
+ * For setting the return value of a spy.
+ *
+ * @example
+ * // defining a spy from scratch: foo() returns 'baz'
+ * var foo = jasmine.createSpy('spy on foo').andReturn('baz');
+ *
+ * // defining a spy on an existing property: foo.bar() returns 'baz'
+ * spyOn(foo, 'bar').andReturn('baz');
+ *
+ * @param {Object} value
+ */
+jasmine.Spy.prototype.andReturn = function(value) {
+  this.plan = function() {
+    return value;
+  };
+  return this;
+};
+
+/**
+ * For throwing an exception when a spy is called.
+ *
+ * @example
+ * // defining a spy from scratch: foo() throws an exception w/ message 'ouch'
+ * var foo = jasmine.createSpy('spy on foo').andThrow('baz');
+ *
+ * // defining a spy on an existing property: foo.bar() throws an exception w/ message 'ouch'
+ * spyOn(foo, 'bar').andThrow('baz');
+ *
+ * @param {String} exceptionMsg
+ */
+jasmine.Spy.prototype.andThrow = function(exceptionMsg) {
+  this.plan = function() {
+    throw exceptionMsg;
+  };
+  return this;
+};
+
+/**
+ * Calls an alternate implementation when a spy is called.
+ *
+ * @example
+ * var baz = function() {
+ *   // do some stuff, return something
+ * }
+ * // defining a spy from scratch: foo() calls the function baz
+ * var foo = jasmine.createSpy('spy on foo').andCall(baz);
+ *
+ * // defining a spy on an existing property: foo.bar() calls an anonymnous function
+ * spyOn(foo, 'bar').andCall(function() { return 'baz';} );
+ *
+ * @param {Function} fakeFunc
+ */
+jasmine.Spy.prototype.andCallFake = function(fakeFunc) {
+  this.plan = fakeFunc;
+  return this;
+};
+
+/**
+ * Resets all of a spy's the tracking variables so that it can be used again.
+ *
+ * @example
+ * spyOn(foo, 'bar');
+ *
+ * foo.bar();
+ *
+ * expect(foo.bar.callCount).toEqual(1);
+ *
+ * foo.bar.reset();
+ *
+ * expect(foo.bar.callCount).toEqual(0);
+ */
+jasmine.Spy.prototype.reset = function() {
+  this.wasCalled = false;
+  this.callCount = 0;
+  this.argsForCall = [];
+  this.calls = [];
+  this.mostRecentCall = {};
+};
+
+jasmine.createSpy = function(name) {
+
+  var spyObj = function() {
+    spyObj.wasCalled = true;
+    spyObj.callCount++;
+    var args = jasmine.util.argsToArray(arguments);
+    spyObj.mostRecentCall.object = this;
+    spyObj.mostRecentCall.args = args;
+    spyObj.argsForCall.push(args);
+    spyObj.calls.push({object: this, args: args});
+    return spyObj.plan.apply(this, arguments);
+  };
+
+  var spy = new jasmine.Spy(name);
+
+  for (var prop in spy) {
+    spyObj[prop] = spy[prop];
+  }
+
+  spyObj.reset();
+
+  return spyObj;
+};
+
+/**
+ * Determines whether an object is a spy.
+ *
+ * @param {jasmine.Spy|Object} putativeSpy
+ * @returns {Boolean}
+ */
+jasmine.isSpy = function(putativeSpy) {
+  return putativeSpy && putativeSpy.isSpy;
+};
+
+/**
+ * Creates a more complicated spy: an Object that has every property a function that is a spy.  Used for stubbing something
+ * large in one call.
+ *
+ * @param {String} baseName name of spy class
+ * @param {Array} methodNames array of names of methods to make spies
+ */
+jasmine.createSpyObj = function(baseName, methodNames) {
+  if (!jasmine.isArray_(methodNames) || methodNames.length === 0) {
+    throw new Error('createSpyObj requires a non-empty array of method names to create spies for');
+  }
+  var obj = {};
+  for (var i = 0; i < methodNames.length; i++) {
+    obj[methodNames[i]] = jasmine.createSpy(baseName + '.' + methodNames[i]);
+  }
+  return obj;
+};
+
+/**
+ * All parameters are pretty-printed and concatenated together, then written to the current spec's output.
+ *
+ * Be careful not to leave calls to <code>jasmine.log</code> in production code.
+ */
+jasmine.log = function() {
+  var spec = jasmine.getEnv().currentSpec;
+  spec.log.apply(spec, arguments);
+};
+
+/**
+ * Function that installs a spy on an existing object's method name.  Used within a Spec to create a spy.
+ *
+ * @example
+ * // spy example
+ * var foo = {
+ *   not: function(bool) { return !bool; }
+ * }
+ * spyOn(foo, 'not'); // actual foo.not will not be called, execution stops
+ *
+ * @see jasmine.createSpy
+ * @param obj
+ * @param methodName
+ * @returns a Jasmine spy that can be chained with all spy methods
+ */
+var spyOn = function(obj, methodName) {
+  return jasmine.getEnv().currentSpec.spyOn(obj, methodName);
+};
+if (isCommonJS) exports.spyOn = spyOn;
+
+/**
+ * Creates a Jasmine spec that will be added to the current suite.
+ *
+ * // TODO: pending tests
+ *
+ * @example
+ * it('should be true', function() {
+ *   expect(true).toEqual(true);
+ * });
+ *
+ * @param {String} desc description of this specification
+ * @param {Function} func defines the preconditions and expectations of the spec
+ */
+var it = function(desc, func) {
+  return jasmine.getEnv().it(desc, func);
+};
+if (isCommonJS) exports.it = it;
+
+/**
+ * Creates a <em>disabled</em> Jasmine spec.
+ *
+ * A convenience method that allows existing specs to be disabled temporarily during development.
+ *
+ * @param {String} desc description of this specification
+ * @param {Function} func defines the preconditions and expectations of the spec
+ */
+var xit = function(desc, func) {
+  return jasmine.getEnv().xit(desc, func);
+};
+if (isCommonJS) exports.xit = xit;
+
+/**
+ * Starts a chain for a Jasmine expectation.
+ *
+ * It is passed an Object that is the actual value and should chain to one of the many
+ * jasmine.Matchers functions.
+ *
+ * @param {Object} actual Actual value to test against and expected value
+ */
+var expect = function(actual) {
+  return jasmine.getEnv().currentSpec.expect(actual);
+};
+if (isCommonJS) exports.expect = expect;
+
+/**
+ * Defines part of a jasmine spec.  Used in cominbination with waits or waitsFor in asynchrnous specs.
+ *
+ * @param {Function} func Function that defines part of a jasmine spec.
+ */
+var runs = function(func) {
+  jasmine.getEnv().currentSpec.runs(func);
+};
+if (isCommonJS) exports.runs = runs;
+
+/**
+ * Waits a fixed time period before moving to the next block.
+ *
+ * @deprecated Use waitsFor() instead
+ * @param {Number} timeout milliseconds to wait
+ */
+var waits = function(timeout) {
+  jasmine.getEnv().currentSpec.waits(timeout);
+};
+if (isCommonJS) exports.waits = waits;
+
+/**
+ * Waits for the latchFunction to return true before proceeding to the next block.
+ *
+ * @param {Function} latchFunction
+ * @param {String} optional_timeoutMessage
+ * @param {Number} optional_timeout
+ */
+var waitsFor = function(latchFunction, optional_timeoutMessage, optional_timeout) {
+  jasmine.getEnv().currentSpec.waitsFor.apply(jasmine.getEnv().currentSpec, arguments);
+};
+if (isCommonJS) exports.waitsFor = waitsFor;
+
+/**
+ * A function that is called before each spec in a suite.
+ *
+ * Used for spec setup, including validating assumptions.
+ *
+ * @param {Function} beforeEachFunction
+ */
+var beforeEach = function(beforeEachFunction) {
+  jasmine.getEnv().beforeEach(beforeEachFunction);
+};
+if (isCommonJS) exports.beforeEach = beforeEach;
+
+/**
+ * A function that is called after each spec in a suite.
+ *
+ * Used for restoring any state that is hijacked during spec execution.
+ *
+ * @param {Function} afterEachFunction
+ */
+var afterEach = function(afterEachFunction) {
+  jasmine.getEnv().afterEach(afterEachFunction);
+};
+if (isCommonJS) exports.afterEach = afterEach;
+
+/**
+ * Defines a suite of specifications.
+ *
+ * Stores the description and all defined specs in the Jasmine environment as one suite of specs. Variables declared
+ * are accessible by calls to beforeEach, it, and afterEach. Describe blocks can be nested, allowing for specialization
+ * of setup in some tests.
+ *
+ * @example
+ * // TODO: a simple suite
+ *
+ * // TODO: a simple suite with a nested describe block
+ *
+ * @param {String} description A string, usually the class under test.
+ * @param {Function} specDefinitions function that defines several specs.
+ */
+var describe = function(description, specDefinitions) {
+  return jasmine.getEnv().describe(description, specDefinitions);
+};
+if (isCommonJS) exports.describe = describe;
+
+/**
+ * Disables a suite of specifications.  Used to disable some suites in a file, or files, temporarily during development.
+ *
+ * @param {String} description A string, usually the class under test.
+ * @param {Function} specDefinitions function that defines several specs.
+ */
+var xdescribe = function(description, specDefinitions) {
+  return jasmine.getEnv().xdescribe(description, specDefinitions);
+};
+if (isCommonJS) exports.xdescribe = xdescribe;
+
+
+// Provide the XMLHttpRequest class for IE 5.x-6.x:
+jasmine.XmlHttpRequest = (typeof XMLHttpRequest == "undefined") ? function() {
+  function tryIt(f) {
+    try {
+      return f();
+    } catch(e) {
+    }
+    return null;
+  }
+
+  var xhr = tryIt(function() {
+    return new ActiveXObject("Msxml2.XMLHTTP.6.0");
+  }) ||
+    tryIt(function() {
+      return new ActiveXObject("Msxml2.XMLHTTP.3.0");
+    }) ||
+    tryIt(function() {
+      return new ActiveXObject("Msxml2.XMLHTTP");
+    }) ||
+    tryIt(function() {
+      return new ActiveXObject("Microsoft.XMLHTTP");
+    });
+
+  if (!xhr) throw new Error("This browser does not support XMLHttpRequest.");
+
+  return xhr;
+} : XMLHttpRequest;
+/**
+ * @namespace
+ */
+jasmine.util = {};
+
+/**
+ * Declare that a child class inherit it's prototype from the parent class.
+ *
+ * @private
+ * @param {Function} childClass
+ * @param {Function} parentClass
+ */
+jasmine.util.inherit = function(childClass, parentClass) {
+  /**
+   * @private
+   */
+  var subclass = function() {
+  };
+  subclass.prototype = parentClass.prototype;
+  childClass.prototype = new subclass();
+};
+
+jasmine.util.formatException = function(e) {
+  var lineNumber;
+  if (e.line) {
+    lineNumber = e.line;
+  }
+  else if (e.lineNumber) {
+    lineNumber = e.lineNumber;
+  }
+
+  var file;
+
+  if (e.sourceURL) {
+    file = e.sourceURL;
+  }
+  else if (e.fileName) {
+    file = e.fileName;
+  }
+
+  var message = (e.name && e.message) ? (e.name + ': ' + e.message) : e.toString();
+
+  if (file && lineNumber) {
+    message += ' in ' + file + ' (line ' + lineNumber + ')';
+  }
+
+  return message;
+};
+
+jasmine.util.htmlEscape = function(str) {
+  if (!str) return str;
+  return str.replace(/&/g, '&amp;')
+    .replace(/</g, '&lt;')
+    .replace(/>/g, '&gt;');
+};
+
+jasmine.util.argsToArray = function(args) {
+  var arrayOfArgs = [];
+  for (var i = 0; i < args.length; i++) arrayOfArgs.push(args[i]);
+  return arrayOfArgs;
+};
+
+jasmine.util.extend = function(destination, source) {
+  for (var property in source) destination[property] = source[property];
+  return destination;
+};
+
+/**
+ * Environment for Jasmine
+ *
+ * @constructor
+ */
+jasmine.Env = function() {
+  this.currentSpec = null;
+  this.currentSuite = null;
+  this.currentRunner_ = new jasmine.Runner(this);
+
+  this.reporter = new jasmine.MultiReporter();
+
+  this.updateInterval = jasmine.DEFAULT_UPDATE_INTERVAL;
+  this.defaultTimeoutInterval = jasmine.DEFAULT_TIMEOUT_INTERVAL;
+  this.lastUpdate = 0;
+  this.specFilter = function() {
+    return true;
+  };
+
+  this.nextSpecId_ = 0;
+  this.nextSuiteId_ = 0;
+  this.equalityTesters_ = [];
+
+  // wrap matchers
+  this.matchersClass = function() {
+    jasmine.Matchers.apply(this, arguments);
+  };
+  jasmine.util.inherit(this.matchersClass, jasmine.Matchers);
+
+  jasmine.Matchers.wrapInto_(jasmine.Matchers.prototype, this.matchersClass);
+};
+
+
+jasmine.Env.prototype.setTimeout = jasmine.setTimeout;
+jasmine.Env.prototype.clearTimeout = jasmine.clearTimeout;
+jasmine.Env.prototype.setInterval = jasmine.setInterval;
+jasmine.Env.prototype.clearInterval = jasmine.clearInterval;
+
+/**
+ * @returns an object containing jasmine version build info, if set.
+ */
+jasmine.Env.prototype.version = function () {
+  if (jasmine.version_) {
+    return jasmine.version_;
+  } else {
+    throw new Error('Version not set');
+  }
+};
+
+/**
+ * @returns string containing jasmine version build info, if set.
+ */
+jasmine.Env.prototype.versionString = function() {
+  if (!jasmine.version_) {
+    return "version unknown";
+  }
+
+  var version = this.version();
+  var versionString = version.major + "." + version.minor + "." + version.build;
+  if (version.release_candidate) {
+    versionString += ".rc" + version.release_candidate;
+  }
+  versionString += " revision " + version.revision;
+  return versionString;
+};
+
+/**
+ * @returns a sequential integer starting at 0
+ */
+jasmine.Env.prototype.nextSpecId = function () {
+  return this.nextSpecId_++;
+};
+
+/**
+ * @returns a sequential integer starting at 0
+ */
+jasmine.Env.prototype.nextSuiteId = function () {
+  return this.nextSuiteId_++;
+};
+
+/**
+ * Register a reporter to receive status updates from Jasmine.
+ * @param {jasmine.Reporter} reporter An object which will receive status updates.
+ */
+jasmine.Env.prototype.addReporter = function(reporter) {
+  this.reporter.addReporter(reporter);
+};
+
+jasmine.Env.prototype.execute = function() {
+  this.currentRunner_.execute();
+};
+
+jasmine.Env.prototype.describe = function(description, specDefinitions) {
+  var suite = new jasmine.Suite(this, description, specDefinitions, this.currentSuite);
+
+  var parentSuite = this.currentSuite;
+  if (parentSuite) {
+    parentSuite.add(suite);
+  } else {
+    this.currentRunner_.add(suite);
+  }
+
+  this.currentSuite = suite;
+
+  var declarationError = null;
+  try {
+    specDefinitions.call(suite);
+  } catch(e) {
+    declarationError = e;
+  }
+
+  if (declarationError) {
+    this.it("encountered a declaration exception", function() {
+      throw declarationError;
+    });
+  }
+
+  this.currentSuite = parentSuite;
+
+  return suite;
+};
+
+jasmine.Env.prototype.beforeEach = function(beforeEachFunction) {
+  if (this.currentSuite) {
+    this.currentSuite.beforeEach(beforeEachFunction);
+  } else {
+    this.currentRunner_.beforeEach(beforeEachFunction);
+  }
+};
+
+jasmine.Env.prototype.currentRunner = function () {
+  return this.currentRunner_;
+};
+
+jasmine.Env.prototype.afterEach = function(afterEachFunction) {
+  if (this.currentSuite) {
+    this.currentSuite.afterEach(afterEachFunction);
+  } else {
+    this.currentRunner_.afterEach(afterEachFunction);
+  }
+
+};
+
+jasmine.Env.prototype.xdescribe = function(desc, specDefinitions) {
+  return {
+    execute: function() {
+    }
+  };
+};
+
+jasmine.Env.prototype.it = function(description, func) {
+  var spec = new jasmine.Spec(this, this.currentSuite, description);
+  this.currentSuite.add(spec);
+  this.currentSpec = spec;
+
+  if (func) {
+    spec.runs(func);
+  }
+
+  return spec;
+};
+
+jasmine.Env.prototype.xit = function(desc, func) {
+  return {
+    id: this.nextSpecId(),
+    runs: function() {
+    }
+  };
+};
+
+jasmine.Env.prototype.compareObjects_ = function(a, b, mismatchKeys, mismatchValues) {
+  if (a.__Jasmine_been_here_before__ === b && b.__Jasmine_been_here_before__ === a) {
+    return true;
+  }
+
+  a.__Jasmine_been_here_before__ = b;
+  b.__Jasmine_been_here_before__ = a;
+
+  var hasKey = function(obj, keyName) {
+    return obj !== null && obj[keyName] !== jasmine.undefined;
+  };
+
+  for (var property in b) {
+    if (!hasKey(a, property) && hasKey(b, property)) {
+      mismatchKeys.push("expected has key '" + property + "', but missing from actual.");
+    }
+  }
+  for (property in a) {
+    if (!hasKey(b, property) && hasKey(a, property)) {
+      mismatchKeys.push("expected missing key '" + property + "', but present in actual.");
+    }
+  }
+  for (property in b) {
+    if (property == '__Jasmine_been_here_before__') continue;
+    if (!this.equals_(a[property], b[property], mismatchKeys, mismatchValues)) {
+      mismatchValues.push("'" + property + "' was '" + (b[property] ? jasmine.util.htmlEscape(b[property].toString()) : b[property]) + "' in expected, but was '" + (a[property] ? jasmine.util.htmlEscape(a[property].toString()) : a[property]) + "' in actual.");
+    }
+  }
+
+  if (jasmine.isArray_(a) && jasmine.isArray_(b) && a.length != b.length) {
+    mismatchValues.push("arrays were not the same length");
+  }
+
+  delete a.__Jasmine_been_here_before__;
+  delete b.__Jasmine_been_here_before__;
+  return (mismatchKeys.length === 0 && mismatchValues.length === 0);
+};
+
+jasmine.Env.prototype.equals_ = function(a, b, mismatchKeys, mismatchValues) {
+  mismatchKeys = mismatchKeys || [];
+  mismatchValues = mismatchValues || [];
+
+  for (var i = 0; i < this.equalityTesters_.length; i++) {
+    var equalityTester = this.equalityTesters_[i];
+    var result = equalityTester(a, b, this, mismatchKeys, mismatchValues);
+    if (result !== jasmine.undefined) return result;
+  }
+
+  if (a === b) return true;
+
+  if (a === jasmine.undefined || a === null || b === jasmine.undefined || b === null) {
+    return (a == jasmine.undefined && b == jasmine.undefined);
+  }
+
+  if (jasmine.isDomNode(a) && jasmine.isDomNode(b)) {
+    return a === b;
+  }
+
+  if (a instanceof Date && b instanceof Date) {
+    return a.getTime() == b.getTime();
+  }
+
+  if (a.jasmineMatches) {
+    return a.jasmineMatches(b);
+  }
+
+  if (b.jasmineMatches) {
+    return b.jasmineMatches(a);
+  }
+
+  if (a instanceof jasmine.Matchers.ObjectContaining) {
+    return a.matches(b);
+  }
+
+  if (b instanceof jasmine.Matchers.ObjectContaining) {
+    return b.matches(a);
+  }
+
+  if (jasmine.isString_(a) && jasmine.isString_(b)) {
+    return (a == b);
+  }
+
+  if (jasmine.isNumber_(a) && jasmine.isNumber_(b)) {
+    return (a == b);
+  }
+
+  if (typeof a === "object" && typeof b === "object") {
+    return this.compareObjects_(a, b, mismatchKeys, mismatchValues);
+  }
+
+  //Straight check
+  return (a === b);
+};
+
+jasmine.Env.prototype.contains_ = function(haystack, needle) {
+  if (jasmine.isArray_(haystack)) {
+    for (var i = 0; i < haystack.length; i++) {
+      if (this.equals_(haystack[i], needle)) return true;
+    }
+    return false;
+  }
+  return haystack.indexOf(needle) >= 0;
+};
+
+jasmine.Env.prototype.addEqualityTester = function(equalityTester) {
+  this.equalityTesters_.push(equalityTester);
+};
+/** No-op base class for Jasmine reporters.
+ *
+ * @constructor
+ */
+jasmine.Reporter = function() {
+};
+
+//noinspection JSUnusedLocalSymbols
+jasmine.Reporter.prototype.reportRunnerStarting = function(runner) {
+};
+
+//noinspection JSUnusedLocalSymbols
+jasmine.Reporter.prototype.reportRunnerResults = function(runner) {
+};
+
+//noinspection JSUnusedLocalSymbols
+jasmine.Reporter.prototype.reportSuiteResults = function(suite) {
+};
+
+//noinspection JSUnusedLocalSymbols
+jasmine.Reporter.prototype.reportSpecStarting = function(spec) {
+};
+
+//noinspection JSUnusedLocalSymbols
+jasmine.Reporter.prototype.reportSpecResults = function(spec) {
+};
+
+//noinspection JSUnusedLocalSymbols
+jasmine.Reporter.prototype.log = function(str) {
+};
+
+/**
+ * Blocks are functions with executable code that make up a spec.
+ *
+ * @constructor
+ * @param {jasmine.Env} env
+ * @param {Function} func
+ * @param {jasmine.Spec} spec
+ */
+jasmine.Block = function(env, func, spec) {
+  this.env = env;
+  this.func = func;
+  this.spec = spec;
+};
+
+jasmine.Block.prototype.execute = function(onComplete) {
+  try {
+    this.func.apply(this.spec);
+  } catch (e) {
+    this.spec.fail(e);
+  }
+  onComplete();
+};
+/** JavaScript API reporter.
+ *
+ * @constructor
+ */
+jasmine.JsApiReporter = function() {
+  this.started = false;
+  this.finished = false;
+  this.suites_ = [];
+  this.results_ = {};
+};
+
+jasmine.JsApiReporter.prototype.reportRunnerStarting = function(runner) {
+  this.started = true;
+  var suites = runner.topLevelSuites();
+  for (var i = 0; i < suites.length; i++) {
+    var suite = suites[i];
+    this.suites_.push(this.summarize_(suite));
+  }
+};
+
+jasmine.JsApiReporter.prototype.suites = function() {
+  return this.suites_;
+};
+
+jasmine.JsApiReporter.prototype.summarize_ = function(suiteOrSpec) {
+  var isSuite = suiteOrSpec instanceof jasmine.Suite;
+  var summary = {
+    id: suiteOrSpec.id,
+    name: suiteOrSpec.description,
+    type: isSuite ? 'suite' : 'spec',
+    children: []
+  };
+
+  if (isSuite) {
+    var children = suiteOrSpec.children();
+    for (var i = 0; i < children.length; i++) {
+      summary.children.push(this.summarize_(children[i]));
+    }
+  }
+  return summary;
+};
+
+jasmine.JsApiReporter.prototype.results = function() {
+  return this.results_;
+};
+
+jasmine.JsApiReporter.prototype.resultsForSpec = function(specId) {
+  return this.results_[specId];
+};
+
+//noinspection JSUnusedLocalSymbols
+jasmine.JsApiReporter.prototype.reportRunnerResults = function(runner) {
+  this.finished = true;
+};
+
+//noinspection JSUnusedLocalSymbols
+jasmine.JsApiReporter.prototype.reportSuiteResults = function(suite) {
+};
+
+//noinspection JSUnusedLocalSymbols
+jasmine.JsApiReporter.prototype.reportSpecResults = function(spec) {
+  this.results_[spec.id] = {
+    messages: spec.results().getItems(),
+    result: spec.results().failedCount > 0 ? "failed" : "passed"
+  };
+};
+
+//noinspection JSUnusedLocalSymbols
+jasmine.JsApiReporter.prototype.log = function(str) {
+};
+
+jasmine.JsApiReporter.prototype.resultsForSpecs = function(specIds){
+  var results = {};
+  for (var i = 0; i < specIds.length; i++) {
+    var specId = specIds[i];
+    results[specId] = this.summarizeResult_(this.results_[specId]);
+  }
+  return results;
+};
+
+jasmine.JsApiReporter.prototype.summarizeResult_ = function(result){
+  var summaryMessages = [];
+  var messagesLength = result.messages.length;
+  for (var messageIndex = 0; messageIndex < messagesLength; messageIndex++) {
+    var resultMessage = result.messages[messageIndex];
+    summaryMessages.push({
+      text: resultMessage.type == 'log' ? resultMessage.toString() : jasmine.undefined,
+      passed: resultMessage.passed ? resultMessage.passed() : true,
+      type: resultMessage.type,
+      message: resultMessage.message,
+      trace: {
+        stack: resultMessage.passed && !resultMessage.passed() ? resultMessage.trace.stack : jasmine.undefined
+      }
+    });
+  }
+
+  return {
+    result : result.result,
+    messages : summaryMessages
+  };
+};
+
+/**
+ * @constructor
+ * @param {jasmine.Env} env
+ * @param actual
+ * @param {jasmine.Spec} spec
+ */
+jasmine.Matchers = function(env, actual, spec, opt_isNot) {
+  this.env = env;
+  this.actual = actual;
+  this.spec = spec;
+  this.isNot = opt_isNot || false;
+  this.reportWasCalled_ = false;
+};
+
+// todo: @deprecated as of Jasmine 0.11, remove soon [xw]
+jasmine.Matchers.pp = function(str) {
+  throw new Error("jasmine.Matchers.pp() is no longer supported, please use jasmine.pp() instead!");
+};
+
+// todo: @deprecated Deprecated as of Jasmine 0.10. Rewrite your custom matchers to return true or false. [xw]
+jasmine.Matchers.prototype.report = function(result, failing_message, details) {
+  throw new Error("As of jasmine 0.11, custom matchers must be implemented differently -- please see jasmine docs");
+};
+
+jasmine.Matchers.wrapInto_ = function(prototype, matchersClass) {
+  for (var methodName in prototype) {
+    if (methodName == 'report') continue;
+    var orig = prototype[methodName];
+    matchersClass.prototype[methodName] = jasmine.Matchers.matcherFn_(methodName, orig);
+  }
+};
+
+jasmine.Matchers.matcherFn_ = function(matcherName, matcherFunction) {
+  return function() {
+    var matcherArgs = jasmine.util.argsToArray(arguments);
+    var result = matcherFunction.apply(this, arguments);
+
+    if (this.isNot) {
+      result = !result;
+    }
+
+    if (this.reportWasCalled_) return result;
+
+    var message;
+    if (!result) {
+      if (this.message) {
+        message = this.message.apply(this, arguments);
+        if (jasmine.isArray_(message)) {
+          message = message[this.isNot ? 1 : 0];
+        }
+      } else {
+        var englishyPredicate = matcherName.replace(/[A-Z]/g, function(s) { return ' ' + s.toLowerCase(); });
+        message = "Expected " + jasmine.pp(this.actual) + (this.isNot ? " not " : " ") + englishyPredicate;
+        if (matcherArgs.length > 0) {
+          for (var i = 0; i < matcherArgs.length; i++) {
+            if (i > 0) message += ",";
+            message += " " + jasmine.pp(matcherArgs[i]);
+          }
+        }
+        message += ".";
+      }
+    }
+    var expectationResult = new jasmine.ExpectationResult({
+      matcherName: matcherName,
+      passed: result,
+      expected: matcherArgs.length > 1 ? matcherArgs : matcherArgs[0],
+      actual: this.actual,
+      message: message
+    });
+    this.spec.addMatcherResult(expectationResult);
+    return jasmine.undefined;
+  };
+};
+
+
+
+
+/**
+ * toBe: compares the actual to the expected using ===
+ * @param expected
+ */
+jasmine.Matchers.prototype.toBe = function(expected) {
+  return this.actual === expected;
+};
+
+/**
+ * toNotBe: compares the actual to the expected using !==
+ * @param expected
+ * @deprecated as of 1.0. Use not.toBe() instead.
+ */
+jasmine.Matchers.prototype.toNotBe = function(expected) {
+  return this.actual !== expected;
+};
+
+/**
+ * toEqual: compares the actual to the expected using common sense equality. Handles Objects, Arrays, etc.
+ *
+ * @param expected
+ */
+jasmine.Matchers.prototype.toEqual = function(expected) {
+  return this.env.equals_(this.actual, expected);
+};
+
+/**
+ * toNotEqual: compares the actual to the expected using the ! of jasmine.Matchers.toEqual
+ * @param expected
+ * @deprecated as of 1.0. Use not.toEqual() instead.
+ */
+jasmine.Matchers.prototype.toNotEqual = function(expected) {
+  return !this.env.equals_(this.actual, expected);
+};
+
+/**
+ * Matcher that compares the actual to the expected using a regular expression.  Constructs a RegExp, so takes
+ * a pattern or a String.
+ *
+ * @param expected
+ */
+jasmine.Matchers.prototype.toMatch = function(expected) {
+  return new RegExp(expected).test(this.actual);
+};
+
+/**
+ * Matcher that compares the actual to the expected using the boolean inverse of jasmine.Matchers.toMatch
+ * @param expected
+ * @deprecated as of 1.0. Use not.toMatch() instead.
+ */
+jasmine.Matchers.prototype.toNotMatch = function(expected) {
+  return !(new RegExp(expected).test(this.actual));
+};
+
+/**
+ * Matcher that compares the actual to jasmine.undefined.
+ */
+jasmine.Matchers.prototype.toBeDefined = function() {
+  return (this.actual !== jasmine.undefined);
+};
+
+/**
+ * Matcher that compares the actual to jasmine.undefined.
+ */
+jasmine.Matchers.prototype.toBeUndefined = function() {
+  return (this.actual === jasmine.undefined);
+};
+
+/**
+ * Matcher that compares the actual to null.
+ */
+jasmine.Matchers.prototype.toBeNull = function() {
+  return (this.actual === null);
+};
+
+/**
+ * Matcher that boolean not-nots the actual.
+ */
+jasmine.Matchers.prototype.toBeTruthy = function() {
+  return !!this.actual;
+};
+
+
+/**
+ * Matcher that boolean nots the actual.
+ */
+jasmine.Matchers.prototype.toBeFalsy = function() {
+  return !this.actual;
+};
+
+
+/**
+ * Matcher that checks to see if the actual, a Jasmine spy, was called.
+ */
+jasmine.Matchers.prototype.toHaveBeenCalled = function() {
+  if (arguments.length > 0) {
+    throw new Error('toHaveBeenCalled does not take arguments, use toHaveBeenCalledWith');
+  }
+
+  if (!jasmine.isSpy(this.actual)) {
+    throw new Error('Expected a spy, but got ' + jasmine.pp(this.actual) + '.');
+  }
+
+  this.message = function() {
+    return [
+      "Expected spy " + this.actual.identity + " to have been called.",
+      "Expected spy " + this.actual.identity + " not to have been called."
+    ];
+  };
+
+  return this.actual.wasCalled;
+};
+
+/** @deprecated Use expect(xxx).toHaveBeenCalled() instead */
+jasmine.Matchers.prototype.wasCalled = jasmine.Matchers.prototype.toHaveBeenCalled;
+
+/**
+ * Matcher that checks to see if the actual, a Jasmine spy, was not called.
+ *
+ * @deprecated Use expect(xxx).not.toHaveBeenCalled() instead
+ */
+jasmine.Matchers.prototype.wasNotCalled = function() {
+  if (arguments.length > 0) {
+    throw new Error('wasNotCalled does not take arguments');
+  }
+
+  if (!jasmine.isSpy(this.actual)) {
+    throw new Error('Expected a spy, but got ' + jasmine.pp(this.actual) + '.');
+  }
+
+  this.message = function() {
+    return [
+      "Expected spy " + this.actual.identity + " to not have been called.",
+      "Expected spy " + this.actual.identity + " to have been called."
+    ];
+  };
+
+  return !this.actual.wasCalled;
+};
+
+/**
+ * Matcher that checks to see if the actual, a Jasmine spy, was called with a set of parameters.
+ *
+ * @example
+ *
+ */
+jasmine.Matchers.prototype.toHaveBeenCalledWith = function() {
+  var expectedArgs = jasmine.util.argsToArray(arguments);
+  if (!jasmine.isSpy(this.actual)) {
+    throw new Error('Expected a spy, but got ' + jasmine.pp(this.actual) + '.');
+  }
+  this.message = function() {
+    if (this.actual.callCount === 0) {
+      // todo: what should the failure message for .not.toHaveBeenCalledWith() be? is this right? test better. [xw]
+      return [
+        "Expected spy " + this.actual.identity + " to have been called with " + jasmine.pp(expectedArgs) + " but it was never called.",
+        "Expected spy " + this.actual.identity + " not to have been called with " + jasmine.pp(expectedArgs) + " but it was."
+      ];
+    } else {
+      return [
+        "Expected spy " + this.actual.identity + " to have been called with " + jasmine.pp(expectedArgs) + " but was called with " + jasmine.pp(this.actual.argsForCall),
+        "Expected spy " + this.actual.identity + " not to have been called with " + jasmine.pp(expectedArgs) + " but was called with " + jasmine.pp(this.actual.argsForCall)
+      ];
+    }
+  };
+
+  return this.env.contains_(this.actual.argsForCall, expectedArgs);
+};
+
+/** @deprecated Use expect(xxx).toHaveBeenCalledWith() instead */
+jasmine.Matchers.prototype.wasCalledWith = jasmine.Matchers.prototype.toHaveBeenCalledWith;
+
+/** @deprecated Use expect(xxx).not.toHaveBeenCalledWith() instead */
+jasmine.Matchers.prototype.wasNotCalledWith = function() {
+  var expectedArgs = jasmine.util.argsToArray(arguments);
+  if (!jasmine.isSpy(this.actual)) {
+    throw new Error('Expected a spy, but got ' + jasmine.pp(this.actual) + '.');
+  }
+
+  this.message = function() {
+    return [
+      "Expected spy not to have been called with " + jasmine.pp(expectedArgs) + " but it was",
+      "Expected spy to have been called with " + jasmine.pp(expectedArgs) + " but it was"
+    ];
+  };
+
+  return !this.env.contains_(this.actual.argsForCall, expectedArgs);
+};
+
+/**
+ * Matcher that checks that the expected item is an element in the actual Array.
+ *
+ * @param {Object} expected
+ */
+jasmine.Matchers.prototype.toContain = function(expected) {
+  return this.env.contains_(this.actual, expected);
+};
+
+/**
+ * Matcher that checks that the expected item is NOT an element in the actual Array.
+ *
+ * @param {Object} expected
+ * @deprecated as of 1.0. Use not.toContain() instead.
+ */
+jasmine.Matchers.prototype.toNotContain = function(expected) {
+  return !this.env.contains_(this.actual, expected);
+};
+
+jasmine.Matchers.prototype.toBeLessThan = function(expected) {
+  return this.actual < expected;
+};
+
+jasmine.Matchers.prototype.toBeGreaterThan = function(expected) {
+  return this.actual > expected;
+};
+
+/**
+ * Matcher that checks that the expected item is equal to the actual item
+ * up to a given level of decimal precision (default 2).
+ *
+ * @param {Number} expected
+ * @param {Number} precision
+ */
+jasmine.Matchers.prototype.toBeCloseTo = function(expected, precision) {
+  if (!(precision === 0)) {
+    precision = precision || 2;
+  }
+  var multiplier = Math.pow(10, precision);
+  var actual = Math.round(this.actual * multiplier);
+  expected = Math.round(expected * multiplier);
+  return expected == actual;
+};
+
+/**
+ * Matcher that checks that the expected exception was thrown by the actual.
+ *
+ * @param {String} expected
+ */
+jasmine.Matchers.prototype.toThrow = function(expected) {
+  var result = false;
+  var exception;
+  if (typeof this.actual != 'function') {
+    throw new Error('Actual is not a function');
+  }
+  try {
+    this.actual();
+  } catch (e) {
+    exception = e;
+  }
+  if (exception) {
+    result = (expected === jasmine.undefined || this.env.equals_(exception.message || exception, expected.message || expected));
+  }
+
+  var not = this.isNot ? "not " : "";
+
+  this.message = function() {
+    if (exception && (expected === jasmine.undefined || !this.env.equals_(exception.message || exception, expected.message || expected))) {
+      return ["Expected function " + not + "to throw", expected ? expected.message || expected : "an exception", ", but it threw", exception.message || exception].join(' ');
+    } else {
+      return "Expected function to throw an exception.";
+    }
+  };
+
+  return result;
+};
+
+jasmine.Matchers.Any = function(expectedClass) {
+  this.expectedClass = expectedClass;
+};
+
+jasmine.Matchers.Any.prototype.jasmineMatches = function(other) {
+  if (this.expectedClass == String) {
+    return typeof other == 'string' || other instanceof String;
+  }
+
+  if (this.expectedClass == Number) {
+    return typeof other == 'number' || other instanceof Number;
+  }
+
+  if (this.expectedClass == Function) {
+    return typeof other == 'function' || other instanceof Function;
+  }
+
+  if (this.expectedClass == Object) {
+    return typeof other == 'object';
+  }
+
+  return other instanceof this.expectedClass;
+};
+
+jasmine.Matchers.Any.prototype.jasmineToString = function() {
+  return '<jasmine.any(' + this.expectedClass + ')>';
+};
+
+jasmine.Matchers.ObjectContaining = function (sample) {
+  this.sample = sample;
+};
+
+jasmine.Matchers.ObjectContaining.prototype.jasmineMatches = function(other, mismatchKeys, mismatchValues) {
+  mismatchKeys = mismatchKeys || [];
+  mismatchValues = mismatchValues || [];
+
+  var env = jasmine.getEnv();
+
+  var hasKey = function(obj, keyName) {
+    return obj != null && obj[keyName] !== jasmine.undefined;
+  };
+
+  for (var property in this.sample) {
+    if (!hasKey(other, property) && hasKey(this.sample, property)) {
+      mismatchKeys.push("expected has key '" + property + "', but missing from actual.");
+    }
+    else if (!env.equals_(this.sample[property], other[property], mismatchKeys, mismatchValues)) {
+      mismatchValues.push("'" + property + "' was '" + (other[property] ? jasmine.util.htmlEscape(other[property].toString()) : other[property]) + "' in expected, but was '" + (this.sample[property] ? jasmine.util.htmlEscape(this.sample[property].toString()) : this.sample[property]) + "' in actual.");
+    }
+  }
+
+  return (mismatchKeys.length === 0 && mismatchValues.length === 0);
+};
+
+jasmine.Matchers.ObjectContaining.prototype.jasmineToString = function () {
+  return "<jasmine.objectContaining(" + jasmine.pp(this.sample) + ")>";
+};
+// Mock setTimeout, clearTimeout
+// Contributed by Pivotal Computer Systems, www.pivotalsf.com
+
+jasmine.FakeTimer = function() {
+  this.reset();
+
+  var self = this;
+  self.setTimeout = function(funcToCall, millis) {
+    self.timeoutsMade++;
+    self.scheduleFunction(self.timeoutsMade, funcToCall, millis, false);
+    return self.timeoutsMade;
+  };
+
+  self.setInterval = function(funcToCall, millis) {
+    self.timeoutsMade++;
+    self.scheduleFunction(self.timeoutsMade, funcToCall, millis, true);
+    return self.timeoutsMade;
+  };
+
+  self.clearTimeout = function(timeoutKey) {
+    self.scheduledFunctions[timeoutKey] = jasmine.undefined;
+  };
+
+  self.clearInterval = function(timeoutKey) {
+    self.scheduledFunctions[timeoutKey] = jasmine.undefined;
+  };
+
+};
+
+jasmine.FakeTimer.prototype.reset = function() {
+  this.timeoutsMade = 0;
+  this.scheduledFunctions = {};
+  this.nowMillis = 0;
+};
+
+jasmine.FakeTimer.prototype.tick = function(millis) {
+  var oldMillis = this.nowMillis;
+  var newMillis = oldMillis + millis;
+  this.runFunctionsWithinRange(oldMillis, newMillis);
+  this.nowMillis = newMillis;
+};
+
+jasmine.FakeTimer.prototype.runFunctionsWithinRange = function(oldMillis, nowMillis) {
+  var scheduledFunc;
+  var funcsToRun = [];
+  for (var timeoutKey in this.scheduledFunctions) {
+    scheduledFunc = this.scheduledFunctions[timeoutKey];
+    if (scheduledFunc != jasmine.undefined &&
+        scheduledFunc.runAtMillis >= oldMillis &&
+        scheduledFunc.runAtMillis <= nowMillis) {
+      funcsToRun.push(scheduledFunc);
+      this.scheduledFunctions[timeoutKey] = jasmine.undefined;
+    }
+  }
+
+  if (funcsToRun.length > 0) {
+    funcsToRun.sort(function(a, b) {
+      return a.runAtMillis - b.runAtMillis;
+    });
+    for (var i = 0; i < funcsToRun.length; ++i) {
+      try {
+        var funcToRun = funcsToRun[i];
+        this.nowMillis = funcToRun.runAtMillis;
+        funcToRun.funcToCall();
+        if (funcToRun.recurring) {
+          this.scheduleFunction(funcToRun.timeoutKey,
+              funcToRun.funcToCall,
+              funcToRun.millis,
+              true);
+        }
+      } catch(e) {
+      }
+    }
+    this.runFunctionsWithinRange(oldMillis, nowMillis);
+  }
+};
+
+jasmine.FakeTimer.prototype.scheduleFunction = function(timeoutKey, funcToCall, millis, recurring) {
+  this.scheduledFunctions[timeoutKey] = {
+    runAtMillis: this.nowMillis + millis,
+    funcToCall: funcToCall,
+    recurring: recurring,
+    timeoutKey: timeoutKey,
+    millis: millis
+  };
+};
+
+/**
+ * @namespace
+ */
+jasmine.Clock = {
+  defaultFakeTimer: new jasmine.FakeTimer(),
+
+  reset: function() {
+    jasmine.Clock.assertInstalled();
+    jasmine.Clock.defaultFakeTimer.reset();
+  },
+
+  tick: function(millis) {
+    jasmine.Clock.assertInstalled();
+    jasmine.Clock.defaultFakeTimer.tick(millis);
+  },
+
+  runFunctionsWithinRange: function(oldMillis, nowMillis) {
+    jasmine.Clock.defaultFakeTimer.runFunctionsWithinRange(oldMillis, nowMillis);
+  },
+
+  scheduleFunction: function(timeoutKey, funcToCall, millis, recurring) {
+    jasmine.Clock.defaultFakeTimer.scheduleFunction(timeoutKey, funcToCall, millis, recurring);
+  },
+
+  useMock: function() {
+    if (!jasmine.Clock.isInstalled()) {
+      var spec = jasmine.getEnv().currentSpec;
+      spec.after(jasmine.Clock.uninstallMock);
+
+      jasmine.Clock.installMock();
+    }
+  },
+
+  installMock: function() {
+    jasmine.Clock.installed = jasmine.Clock.defaultFakeTimer;
+  },
+
+  uninstallMock: function() {
+    jasmine.Clock.assertInstalled();
+    jasmine.Clock.installed = jasmine.Clock.real;
+  },
+
+  real: {
+    setTimeout: jasmine.getGlobal().setTimeout,
+    clearTimeout: jasmine.getGlobal().clearTimeout,
+    setInterval: jasmine.getGlobal().setInterval,
+    clearInterval: jasmine.getGlobal().clearInterval
+  },
+
+  assertInstalled: function() {
+    if (!jasmine.Clock.isInstalled()) {
+      throw new Error("Mock clock is not installed, use jasmine.Clock.useMock()");
+    }
+  },
+
+  isInstalled: function() {
+    return jasmine.Clock.installed == jasmine.Clock.defaultFakeTimer;
+  },
+
+  installed: null
+};
+jasmine.Clock.installed = jasmine.Clock.real;
+
+//else for IE support
+jasmine.getGlobal().setTimeout = function(funcToCall, millis) {
+  if (jasmine.Clock.installed.setTimeout.apply) {
+    return jasmine.Clock.installed.setTimeout.apply(this, arguments);
+  } else {
+    return jasmine.Clock.installed.setTimeout(funcToCall, millis);
+  }
+};
+
+jasmine.getGlobal().setInterval = function(funcToCall, millis) {
+  if (jasmine.Clock.installed.setInterval.apply) {
+    return jasmine.Clock.installed.setInterval.apply(this, arguments);
+  } else {
+    return jasmine.Clock.installed.setInterval(funcToCall, millis);
+  }
+};
+
+jasmine.getGlobal().clearTimeout = function(timeoutKey) {
+  if (jasmine.Clock.installed.clearTimeout.apply) {
+    return jasmine.Clock.installed.clearTimeout.apply(this, arguments);
+  } else {
+    return jasmine.Clock.installed.clearTimeout(timeoutKey);
+  }
+};
+
+jasmine.getGlobal().clearInterval = function(timeoutKey) {
+  if (jasmine.Clock.installed.clearTimeout.apply) {
+    return jasmine.Clock.installed.clearInterval.apply(this, arguments);
+  } else {
+    return jasmine.Clock.installed.clearInterval(timeoutKey);
+  }
+};
+
+/**
+ * @constructor
+ */
+jasmine.MultiReporter = function() {
+  this.subReporters_ = [];
+};
+jasmine.util.inherit(jasmine.MultiReporter, jasmine.Reporter);
+
+jasmine.MultiReporter.prototype.addReporter = function(reporter) {
+  this.subReporters_.push(reporter);
+};
+
+(function() {
+  var functionNames = [
+    "reportRunnerStarting",
+    "reportRunnerResults",
+    "reportSuiteResults",
+    "reportSpecStarting",
+    "reportSpecResults",
+    "log"
+  ];
+  for (var i = 0; i < functionNames.length; i++) {
+    var functionName = functionNames[i];
+    jasmine.MultiReporter.prototype[functionName] = (function(functionName) {
+      return function() {
+        for (var j = 0; j < this.subReporters_.length; j++) {
+          var subReporter = this.subReporters_[j];
+          if (subReporter[functionName]) {
+            subReporter[functionName].apply(subReporter, arguments);
+          }
+        }
+      };
+    })(functionName);
+  }
+})();
+/**
+ * Holds results for a set of Jasmine spec. Allows for the results array to hold another jasmine.NestedResults
+ *
+ * @constructor
+ */
+jasmine.NestedResults = function() {
+  /**
+   * The total count of results
+   */
+  this.totalCount = 0;
+  /**
+   * Number of passed results
+   */
+  this.passedCount = 0;
+  /**
+   * Number of failed results
+   */
+  this.failedCount = 0;
+  /**
+   * Was this suite/spec skipped?
+   */
+  this.skipped = false;
+  /**
+   * @ignore
+   */
+  this.items_ = [];
+};
+
+/**
+ * Roll up the result counts.
+ *
+ * @param result
+ */
+jasmine.NestedResults.prototype.rollupCounts = function(result) {
+  this.totalCount += result.totalCount;
+  this.passedCount += result.passedCount;
+  this.failedCount += result.failedCount;
+};
+
+/**
+ * Adds a log message.
+ * @param values Array of message parts which will be concatenated later.
+ */
+jasmine.NestedResults.prototype.log = function(values) {
+  this.items_.push(new jasmine.MessageResult(values));
+};
+
+/**
+ * Getter for the results: message & results.
+ */
+jasmine.NestedResults.prototype.getItems = function() {
+  return this.items_;
+};
+
+/**
+ * Adds a result, tracking counts (total, passed, & failed)
+ * @param {jasmine.ExpectationResult|jasmine.NestedResults} result
+ */
+jasmine.NestedResults.prototype.addResult = function(result) {
+  if (result.type != 'log') {
+    if (result.items_) {
+      this.rollupCounts(result);
+    } else {
+      this.totalCount++;
+      if (result.passed()) {
+        this.passedCount++;
+      } else {
+        this.failedCount++;
+      }
+    }
+  }
+  this.items_.push(result);
+};
+
+/**
+ * @returns {Boolean} True if <b>everything</b> below passed
+ */
+jasmine.NestedResults.prototype.passed = function() {
+  return this.passedCount === this.totalCount;
+};
+/**
+ * Base class for pretty printing for expectation results.
+ */
+jasmine.PrettyPrinter = function() {
+  this.ppNestLevel_ = 0;
+};
+
+/**
+ * Formats a value in a nice, human-readable string.
+ *
+ * @param value
+ */
+jasmine.PrettyPrinter.prototype.format = function(value) {
+  if (this.ppNestLevel_ > 40) {
+    throw new Error('jasmine.PrettyPrinter: format() nested too deeply!');
+  }
+
+  this.ppNestLevel_++;
+  try {
+    if (value === jasmine.undefined) {
+      this.emitScalar('undefined');
+    } else if (value === null) {
+      this.emitScalar('null');
+    } else if (value === jasmine.getGlobal()) {
+      this.emitScalar('<global>');
+    } else if (value.jasmineToString) {
+      this.emitScalar(value.jasmineToString());
+    } else if (typeof value === 'string') {
+      this.emitString(value);
+    } else if (jasmine.isSpy(value)) {
+      this.emitScalar("spy on " + value.identity);
+    } else if (value instanceof RegExp) {
+      this.emitScalar(value.toString());
+    } else if (typeof value === 'function') {
+      this.emitScalar('Function');
+    } else if (typeof value.nodeType === 'number') {
+      this.emitScalar('HTMLNode');
+    } else if (value instanceof Date) {
+      this.emitScalar('Date(' + value + ')');
+    } else if (value.__Jasmine_been_here_before__) {
+      this.emitScalar('<circular reference: ' + (jasmine.isArray_(value) ? 'Array' : 'Object') + '>');
+    } else if (jasmine.isArray_(value) || typeof value == 'object') {
+      value.__Jasmine_been_here_before__ = true;
+      if (jasmine.isArray_(value)) {
+        this.emitArray(value);
+      } else {
+        this.emitObject(value);
+      }
+      delete value.__Jasmine_been_here_before__;
+    } else {
+      this.emitScalar(value.toString());
+    }
+  } finally {
+    this.ppNestLevel_--;
+  }
+};
+
+jasmine.PrettyPrinter.prototype.iterateObject = function(obj, fn) {
+  for (var property in obj) {
+    if (property == '__Jasmine_been_here_before__') continue;
+    fn(property, obj.__lookupGetter__ ? (obj.__lookupGetter__(property) !== jasmine.undefined &&
+                                         obj.__lookupGetter__(property) !== null) : false);
+  }
+};
+
+jasmine.PrettyPrinter.prototype.emitArray = jasmine.unimplementedMethod_;
+jasmine.PrettyPrinter.prototype.emitObject = jasmine.unimplementedMethod_;
+jasmine.PrettyPrinter.prototype.emitScalar = jasmine.unimplementedMethod_;
+jasmine.PrettyPrinter.prototype.emitString = jasmine.unimplementedMethod_;
+
+jasmine.StringPrettyPrinter = function() {
+  jasmine.PrettyPrinter.call(this);
+
+  this.string = '';
+};
+jasmine.util.inherit(jasmine.StringPrettyPrinter, jasmine.PrettyPrinter);
+
+jasmine.StringPrettyPrinter.prototype.emitScalar = function(value) {
+  this.append(value);
+};
+
+jasmine.StringPrettyPrinter.prototype.emitString = function(value) {
+  this.append("'" + value + "'");
+};
+
+jasmine.StringPrettyPrinter.prototype.emitArray = function(array) {
+  this.append('[ ');
+  for (var i = 0; i < array.length; i++) {
+    if (i > 0) {
+      this.append(', ');
+    }
+    this.format(array[i]);
+  }
+  this.append(' ]');
+};
+
+jasmine.StringPrettyPrinter.prototype.emitObject = function(obj) {
+  var self = this;
+  this.append('{ ');
+  var first = true;
+
+  this.iterateObject(obj, function(property, isGetter) {
+    if (first) {
+      first = false;
+    } else {
+      self.append(', ');
+    }
+
+    self.append(property);
+    self.append(' : ');
+    if (isGetter) {
+      self.append('<getter>');
+    } else {
+      self.format(obj[property]);
+    }
+  });
+
+  this.append(' }');
+};
+
+jasmine.StringPrettyPrinter.prototype.append = function(value) {
+  this.string += value;
+};
+jasmine.Queue = function(env) {
+  this.env = env;
+  this.blocks = [];
+  this.running = false;
+  this.index = 0;
+  this.offset = 0;
+  this.abort = false;
+};
+
+jasmine.Queue.prototype.addBefore = function(block) {
+  this.blocks.unshift(block);
+};
+
+jasmine.Queue.prototype.add = function(block) {
+  this.blocks.push(block);
+};
+
+jasmine.Queue.prototype.insertNext = function(block) {
+  this.blocks.splice((this.index + this.offset + 1), 0, block);
+  this.offset++;
+};
+
+jasmine.Queue.prototype.start = function(onComplete) {
+  this.running = true;
+  this.onComplete = onComplete;
+  this.next_();
+};
+
+jasmine.Queue.prototype.isRunning = function() {
+  return this.running;
+};
+
+jasmine.Queue.LOOP_DONT_RECURSE = true;
+
+jasmine.Queue.prototype.next_ = function() {
+  var self = this;
+  var goAgain = true;
+
+  while (goAgain) {
+    goAgain = false;
+
+    if (self.index < self.blocks.length && !this.abort) {
+      var calledSynchronously = true;
+      var completedSynchronously = false;
+
+      var onComplete = function () {
+        if (jasmine.Queue.LOOP_DONT_RECURSE && calledSynchronously) {
+          completedSynchronously = true;
+          return;
+        }
+
+        if (self.blocks[self.index].abort) {
+          self.abort = true;
+        }
+
+        self.offset = 0;
+        self.index++;
+
+        var now = new Date().getTime();
+        if (self.env.updateInterval && now - self.env.lastUpdate > self.env.updateInterval) {
+          self.env.lastUpdate = now;
+          self.env.setTimeout(function() {
+            self.next_();
+          }, 0);
+        } else {
+          if (jasmine.Queue.LOOP_DONT_RECURSE && completedSynchronously) {
+            goAgain = true;
+          } else {
+            self.next_();
+          }
+        }
+      };
+      self.blocks[self.index].execute(onComplete);
+
+      calledSynchronously = false;
+      if (completedSynchronously) {
+        onComplete();
+      }
+
+    } else {
+      self.running = false;
+      if (self.onComplete) {
+        self.onComplete();
+      }
+    }
+  }
+};
+
+jasmine.Queue.prototype.results = function() {
+  var results = new jasmine.NestedResults();
+  for (var i = 0; i < this.blocks.length; i++) {
+    if (this.blocks[i].results) {
+      results.addResult(this.blocks[i].results());
+    }
+  }
+  return results;
+};
+
+
+/**
+ * Runner
+ *
+ * @constructor
+ * @param {jasmine.Env} env
+ */
+jasmine.Runner = function(env) {
+  var self = this;
+  self.env = env;
+  self.queue = new jasmine.Queue(env);
+  self.before_ = [];
+  self.after_ = [];
+  self.suites_ = [];
+};
+
+jasmine.Runner.prototype.execute = function() {
+  var self = this;
+  if (self.env.reporter.reportRunnerStarting) {
+    self.env.reporter.reportRunnerStarting(this);
+  }
+  self.queue.start(function () {
+    self.finishCallback();
+  });
+};
+
+jasmine.Runner.prototype.beforeEach = function(beforeEachFunction) {
+  beforeEachFunction.typeName = 'beforeEach';
+  this.before_.splice(0,0,beforeEachFunction);
+};
+
+jasmine.Runner.prototype.afterEach = function(afterEachFunction) {
+  afterEachFunction.typeName = 'afterEach';
+  this.after_.splice(0,0,afterEachFunction);
+};
+
+
+jasmine.Runner.prototype.finishCallback = function() {
+  this.env.reporter.reportRunnerResults(this);
+};
+
+jasmine.Runner.prototype.addSuite = function(suite) {
+  this.suites_.push(suite);
+};
+
+jasmine.Runner.prototype.add = function(block) {
+  if (block instanceof jasmine.Suite) {
+    this.addSuite(block);
+  }
+  this.queue.add(block);
+};
+
+jasmine.Runner.prototype.specs = function () {
+  var suites = this.suites();
+  var specs = [];
+  for (var i = 0; i < suites.length; i++) {
+    specs = specs.concat(suites[i].specs());
+  }
+  return specs;
+};
+
+jasmine.Runner.prototype.suites = function() {
+  return this.suites_;
+};
+
+jasmine.Runner.prototype.topLevelSuites = function() {
+  var topLevelSuites = [];
+  for (var i = 0; i < this.suites_.length; i++) {
+    if (!this.suites_[i].parentSuite) {
+      topLevelSuites.push(this.suites_[i]);
+    }
+  }
+  return topLevelSuites;
+};
+
+jasmine.Runner.prototype.results = function() {
+  return this.queue.results();
+};
+/**
+ * Internal representation of a Jasmine specification, or test.
+ *
+ * @constructor
+ * @param {jasmine.Env} env
+ * @param {jasmine.Suite} suite
+ * @param {String} description
+ */
+jasmine.Spec = function(env, suite, description) {
+  if (!env) {
+    throw new Error('jasmine.Env() required');
+  }
+  if (!suite) {
+    throw new Error('jasmine.Suite() required');
+  }
+  var spec = this;
+  spec.id = env.nextSpecId ? env.nextSpecId() : null;
+  spec.env = env;
+  spec.suite = suite;
+  spec.description = description;
+  spec.queue = new jasmine.Queue(env);
+
+  spec.afterCallbacks = [];
+  spec.spies_ = [];
+
+  spec.results_ = new jasmine.NestedResults();
+  spec.results_.description = description;
+  spec.matchersClass = null;
+};
+
+jasmine.Spec.prototype.getFullName = function() {
+  return this.suite.getFullName() + ' ' + this.description + '.';
+};
+
+
+jasmine.Spec.prototype.results = function() {
+  return this.results_;
+};
+
+/**
+ * All parameters are pretty-printed and concatenated together, then written to the spec's output.
+ *
+ * Be careful not to leave calls to <code>jasmine.log</code> in production code.
+ */
+jasmine.Spec.prototype.log = function() {
+  return this.results_.log(arguments);
+};
+
+jasmine.Spec.prototype.runs = function (func) {
+  var block = new jasmine.Block(this.env, func, this);
+  this.addToQueue(block);
+  return this;
+};
+
+jasmine.Spec.prototype.addToQueue = function (block) {
+  if (this.queue.isRunning()) {
+    this.queue.insertNext(block);
+  } else {
+    this.queue.add(block);
+  }
+};
+
+/**
+ * @param {jasmine.ExpectationResult} result
+ */
+jasmine.Spec.prototype.addMatcherResult = function(result) {
+  this.results_.addResult(result);
+};
+
+jasmine.Spec.prototype.expect = function(actual) {
+  var positive = new (this.getMatchersClass_())(this.env, actual, this);
+  positive.not = new (this.getMatchersClass_())(this.env, actual, this, true);
+  return positive;
+};
+
+/**
+ * Waits a fixed time period before moving to the next block.
+ *
+ * @deprecated Use waitsFor() instead
+ * @param {Number} timeout milliseconds to wait
+ */
+jasmine.Spec.prototype.waits = function(timeout) {
+  var waitsFunc = new jasmine.WaitsBlock(this.env, timeout, this);
+  this.addToQueue(waitsFunc);
+  return this;
+};
+
+/**
+ * Waits for the latchFunction to return true before proceeding to the next block.
+ *
+ * @param {Function} latchFunction
+ * @param {String} optional_timeoutMessage
+ * @param {Number} optional_timeout
+ */
+jasmine.Spec.prototype.waitsFor = function(latchFunction, optional_timeoutMessage, optional_timeout) {
+  var latchFunction_ = null;
+  var optional_timeoutMessage_ = null;
+  var optional_timeout_ = null;
+
+  for (var i = 0; i < arguments.length; i++) {
+    var arg = arguments[i];
+    switch (typeof arg) {
+      case 'function':
+        latchFunction_ = arg;
+        break;
+      case 'string':
+        optional_timeoutMessage_ = arg;
+        break;
+      case 'number':
+        optional_timeout_ = arg;
+        break;
+    }
+  }
+
+  var waitsForFunc = new jasmine.WaitsForBlock(this.env, optional_timeout_, latchFunction_, optional_timeoutMessage_, this);
+  this.addToQueue(waitsForFunc);
+  return this;
+};
+
+jasmine.Spec.prototype.fail = function (e) {
+  var expectationResult = new jasmine.ExpectationResult({
+    passed: false,
+    message: e ? jasmine.util.formatException(e) : 'Exception',
+    trace: { stack: e.stack }
+  });
+  this.results_.addResult(expectationResult);
+};
+
+jasmine.Spec.prototype.getMatchersClass_ = function() {
+  return this.matchersClass || this.env.matchersClass;
+};
+
+jasmine.Spec.prototype.addMatchers = function(matchersPrototype) {
+  var parent = this.getMatchersClass_();
+  var newMatchersClass = function() {
+    parent.apply(this, arguments);
+  };
+  jasmine.util.inherit(newMatchersClass, parent);
+  jasmine.Matchers.wrapInto_(matchersPrototype, newMatchersClass);
+  this.matchersClass = newMatchersClass;
+};
+
+jasmine.Spec.prototype.finishCallback = function() {
+  this.env.reporter.reportSpecResults(this);
+};
+
+jasmine.Spec.prototype.finish = function(onComplete) {
+  this.removeAllSpies();
+  this.finishCallback();
+  if (onComplete) {
+    onComplete();
+  }
+};
+
+jasmine.Spec.prototype.after = function(doAfter) {
+  if (this.queue.isRunning()) {
+    this.queue.add(new jasmine.Block(this.env, doAfter, this));
+  } else {
+    this.afterCallbacks.unshift(doAfter);
+  }
+};
+
+jasmine.Spec.prototype.execute = function(onComplete) {
+  var spec = this;
+  if (!spec.env.specFilter(spec)) {
+    spec.results_.skipped = true;
+    spec.finish(onComplete);
+    return;
+  }
+
+  this.env.reporter.reportSpecStarting(this);
+
+  spec.env.currentSpec = spec;
+
+  spec.addBeforesAndAftersToQueue();
+
+  spec.queue.start(function () {
+    spec.finish(onComplete);
+  });
+};
+
+jasmine.Spec.prototype.addBeforesAndAftersToQueue = function() {
+  var runner = this.env.currentRunner();
+  var i;
+
+  for (var suite = this.suite; suite; suite = suite.parentSuite) {
+    for (i = 0; i < suite.before_.length; i++) {
+      this.queue.addBefore(new jasmine.Block(this.env, suite.before_[i], this));
+    }
+  }
+  for (i = 0; i < runner.before_.length; i++) {
+    this.queue.addBefore(new jasmine.Block(this.env, runner.before_[i], this));
+  }
+  for (i = 0; i < this.afterCallbacks.length; i++) {
+    this.queue.add(new jasmine.Block(this.env, this.afterCallbacks[i], this));
+  }
+  for (suite = this.suite; suite; suite = suite.parentSuite) {
+    for (i = 0; i < suite.after_.length; i++) {
+      this.queue.add(new jasmine.Block(this.env, suite.after_[i], this));
+    }
+  }
+  for (i = 0; i < runner.after_.length; i++) {
+    this.queue.add(new jasmine.Block(this.env, runner.after_[i], this));
+  }
+};
+
+jasmine.Spec.prototype.explodes = function() {
+  throw 'explodes function should not have been called';
+};
+
+jasmine.Spec.prototype.spyOn = function(obj, methodName, ignoreMethodDoesntExist) {
+  if (obj == jasmine.undefined) {
+    throw "spyOn could not find an object to spy upon for " + methodName + "()";
+  }
+
+  if (!ignoreMethodDoesntExist && obj[methodName] === jasmine.undefined) {
+    throw methodName + '() method does not exist';
+  }
+
+  if (!ignoreMethodDoesntExist && obj[methodName] && obj[methodName].isSpy) {
+    throw new Error(methodName + ' has already been spied upon');
+  }
+
+  var spyObj = jasmine.createSpy(methodName);
+
+  this.spies_.push(spyObj);
+  spyObj.baseObj = obj;
+  spyObj.methodName = methodName;
+  spyObj.originalValue = obj[methodName];
+
+  obj[methodName] = spyObj;
+
+  return spyObj;
+};
+
+jasmine.Spec.prototype.removeAllSpies = function() {
+  for (var i = 0; i < this.spies_.length; i++) {
+    var spy = this.spies_[i];
+    spy.baseObj[spy.methodName] = spy.originalValue;
+  }
+  this.spies_ = [];
+};
+
+/**
+ * Internal representation of a Jasmine suite.
+ *
+ * @constructor
+ * @param {jasmine.Env} env
+ * @param {String} description
+ * @param {Function} specDefinitions
+ * @param {jasmine.Suite} parentSuite
+ */
+jasmine.Suite = function(env, description, specDefinitions, parentSuite) {
+  var self = this;
+  self.id = env.nextSuiteId ? env.nextSuiteId() : null;
+  self.description = description;
+  self.queue = new jasmine.Queue(env);
+  self.parentSuite = parentSuite;
+  self.env = env;
+  self.before_ = [];
+  self.after_ = [];
+  self.children_ = [];
+  self.suites_ = [];
+  self.specs_ = [];
+};
+
+jasmine.Suite.prototype.getFullName = function() {
+  var fullName = this.description;
+  for (var parentSuite = this.parentSuite; parentSuite; parentSuite = parentSuite.parentSuite) {
+    fullName = parentSuite.description + ' ' + fullName;
+  }
+  return fullName;
+};
+
+jasmine.Suite.prototype.finish = function(onComplete) {
+  this.env.reporter.reportSuiteResults(this);
+  this.finished = true;
+  if (typeof(onComplete) == 'function') {
+    onComplete();
+  }
+};
+
+jasmine.Suite.prototype.beforeEach = function(beforeEachFunction) {
+  beforeEachFunction.typeName = 'beforeEach';
+  this.before_.unshift(beforeEachFunction);
+};
+
+jasmine.Suite.prototype.afterEach = function(afterEachFunction) {
+  afterEachFunction.typeName = 'afterEach';
+  this.after_.unshift(afterEachFunction);
+};
+
+jasmine.Suite.prototype.results = function() {
+  return this.queue.results();
+};
+
+jasmine.Suite.prototype.add = function(suiteOrSpec) {
+  this.children_.push(suiteOrSpec);
+  if (suiteOrSpec instanceof jasmine.Suite) {
+    this.suites_.push(suiteOrSpec);
+    this.env.currentRunner().addSuite(suiteOrSpec);
+  } else {
+    this.specs_.push(suiteOrSpec);
+  }
+  this.queue.add(suiteOrSpec);
+};
+
+jasmine.Suite.prototype.specs = function() {
+  return this.specs_;
+};
+
+jasmine.Suite.prototype.suites = function() {
+  return this.suites_;
+};
+
+jasmine.Suite.prototype.children = function() {
+  return this.children_;
+};
+
+jasmine.Suite.prototype.execute = function(onComplete) {
+  var self = this;
+  this.queue.start(function () {
+    self.finish(onComplete);
+  });
+};
+jasmine.WaitsBlock = function(env, timeout, spec) {
+  this.timeout = timeout;
+  jasmine.Block.call(this, env, null, spec);
+};
+
+jasmine.util.inherit(jasmine.WaitsBlock, jasmine.Block);
+
+jasmine.WaitsBlock.prototype.execute = function (onComplete) {
+  if (jasmine.VERBOSE) {
+    this.env.reporter.log('>> Jasmine waiting for ' + this.timeout + ' ms...');
+  }
+  this.env.setTimeout(function () {
+    onComplete();
+  }, this.timeout);
+};
+/**
+ * A block which waits for some condition to become true, with timeout.
+ *
+ * @constructor
+ * @extends jasmine.Block
+ * @param {jasmine.Env} env The Jasmine environment.
+ * @param {Number} timeout The maximum time in milliseconds to wait for the condition to become true.
+ * @param {Function} latchFunction A function which returns true when the desired condition has been met.
+ * @param {String} message The message to display if the desired condition hasn't been met within the given time period.
+ * @param {jasmine.Spec} spec The Jasmine spec.
+ */
+jasmine.WaitsForBlock = function(env, timeout, latchFunction, message, spec) {
+  this.timeout = timeout || env.defaultTimeoutInterval;
+  this.latchFunction = latchFunction;
+  this.message = message;
+  this.totalTimeSpentWaitingForLatch = 0;
+  jasmine.Block.call(this, env, null, spec);
+};
+jasmine.util.inherit(jasmine.WaitsForBlock, jasmine.Block);
+
+jasmine.WaitsForBlock.TIMEOUT_INCREMENT = 10;
+
+jasmine.WaitsForBlock.prototype.execute = function(onComplete) {
+  if (jasmine.VERBOSE) {
+    this.env.reporter.log('>> Jasmine waiting for ' + (this.message || 'something to happen'));
+  }
+  var latchFunctionResult;
+  try {
+    latchFunctionResult = this.latchFunction.apply(this.spec);
+  } catch (e) {
+    this.spec.fail(e);
+    onComplete();
+    return;
+  }
+
+  if (latchFunctionResult) {
+    onComplete();
+  } else if (this.totalTimeSpentWaitingForLatch >= this.timeout) {
+    var message = 'timed out after ' + this.timeout + ' msec waiting for ' + (this.message || 'something to happen');
+    this.spec.fail({
+      name: 'timeout',
+      message: message
+    });
+
+    this.abort = true;
+    onComplete();
+  } else {
+    this.totalTimeSpentWaitingForLatch += jasmine.WaitsForBlock.TIMEOUT_INCREMENT;
+    var self = this;
+    this.env.setTimeout(function() {
+      self.execute(onComplete);
+    }, jasmine.WaitsForBlock.TIMEOUT_INCREMENT);
+  }
+};
+
+jasmine.version_= {
+  "major": 1,
+  "minor": 2,
+  "build": 0,
+  "revision": 1337005947
+};
+jasmine.HtmlReporterHelpers = {};
+
+jasmine.HtmlReporterHelpers.createDom = function(type, attrs, childrenVarArgs) {
+  var el = document.createElement(type);
+
+  for (var i = 2; i < arguments.length; i++) {
+    var child = arguments[i];
+
+    if (typeof child === 'string') {
+      el.appendChild(document.createTextNode(child));
+    } else {
+      if (child) {
+        el.appendChild(child);
+      }
+    }
+  }
+
+  for (var attr in attrs) {
+    if (attr == "className") {
+      el[attr] = attrs[attr];
+    } else {
+      el.setAttribute(attr, attrs[attr]);
+    }
+  }
+
+  return el;
+};
+
+jasmine.HtmlReporterHelpers.getSpecStatus = function(child) {
+  var results = child.results();
+  var status = results.passed() ? 'passed' : 'failed';
+  if (results.skipped) {
+    status = 'skipped';
+  }
+
+  return status;
+};
+
+jasmine.HtmlReporterHelpers.appendToSummary = function(child, childElement) {
+  var parentDiv = this.dom.summary;
+  var parentSuite = (typeof child.parentSuite == 'undefined') ? 'suite' : 'parentSuite';
+  var parent = child[parentSuite];
+
+  if (parent) {
+    if (typeof this.views.suites[parent.id] == 'undefined') {
+      this.views.suites[parent.id] = new jasmine.HtmlReporter.SuiteView(parent, this.dom, this.views);
+    }
+    parentDiv = this.views.suites[parent.id].element;
+  }
+
+  parentDiv.appendChild(childElement);
+};
+
+
+jasmine.HtmlReporterHelpers.addHelpers = function(ctor) {
+  for(var fn in jasmine.HtmlReporterHelpers) {
+    ctor.prototype[fn] = jasmine.HtmlReporterHelpers[fn];
+  }
+};
+
+jasmine.HtmlReporter = function(_doc) {
+  var self = this;
+  var doc = _doc || window.document;
+
+  var reporterView;
+
+  var dom = {};
+
+  // Jasmine Reporter Public Interface
+  self.logRunningSpecs = false;
+
+  self.reportRunnerStarting = function(runner) {
+    var specs = runner.specs() || [];
+
+    if (specs.length == 0) {
+      return;
+    }
+
+    createReporterDom(runner.env.versionString());
+    doc.body.appendChild(dom.reporter);
+
+    reporterView = new jasmine.HtmlReporter.ReporterView(dom);
+    reporterView.addSpecs(specs, self.specFilter);
+  };
+
+  self.reportRunnerResults = function(runner) {
+    reporterView && reporterView.complete();
+  };
+
+  self.reportSuiteResults = function(suite) {
+    reporterView.suiteComplete(suite);
+  };
+
+  self.reportSpecStarting = function(spec) {
+    if (self.logRunningSpecs) {
+      self.log('>> Jasmine Running ' + spec.suite.description + ' ' + spec.description + '...');
+    }
+  };
+
+  self.reportSpecResults = function(spec) {
+    reporterView.specComplete(spec);
+  };
+
+  self.log = function() {
+    var console = jasmine.getGlobal().console;
+    if (console && console.log) {
+      if (console.log.apply) {
+        console.log.apply(console, arguments);
+      } else {
+        console.log(arguments); // ie fix: console.log.apply doesn't exist on ie
+      }
+    }
+  };
+
+  self.specFilter = function(spec) {
+    if (!focusedSpecName()) {
+      return true;
+    }
+
+    return spec.getFullName().indexOf(focusedSpecName()) === 0;
+  };
+
+  return self;
+
+  function focusedSpecName() {
+    var specName;
+
+    (function memoizeFocusedSpec() {
+      if (specName) {
+        return;
+      }
+
+      var paramMap = [];
+      var params = doc.location.search.substring(1).split('&');
+
+      for (var i = 0; i < params.length; i++) {
+        var p = params[i].split('=');
+        paramMap[decodeURIComponent(p[0])] = decodeURIComponent(p[1]);
+      }
+
+      specName = paramMap.spec;
+    })();
+
+    return specName;
+  }
+
+  function createReporterDom(version) {
+    dom.reporter = self.createDom('div', { id: 'HTMLReporter', className: 'jasmine_reporter' },
+      dom.banner = self.createDom('div', { className: 'banner' },
+        self.createDom('span', { className: 'title' }, "Jasmine "),
+        self.createDom('span', { className: 'version' }, version)),
+
+      dom.symbolSummary = self.createDom('ul', {className: 'symbolSummary'}),
+      dom.alert = self.createDom('div', {className: 'alert'}),
+      dom.results = self.createDom('div', {className: 'results'},
+        dom.summary = self.createDom('div', { className: 'summary' }),
+        dom.details = self.createDom('div', { id: 'details' }))
+    );
+  }
+};
+jasmine.HtmlReporterHelpers.addHelpers(jasmine.HtmlReporter);jasmine.HtmlReporter.ReporterView = function(dom) {
+  this.startedAt = new Date();
+  this.runningSpecCount = 0;
+  this.completeSpecCount = 0;
+  this.passedCount = 0;
+  this.failedCount = 0;
+  this.skippedCount = 0;
+
+  this.createResultsMenu = function() {
+    this.resultsMenu = this.createDom('span', {className: 'resultsMenu bar'},
+      this.summaryMenuItem = this.createDom('a', {className: 'summaryMenuItem', href: "#"}, '0 specs'),
+      ' | ',
+      this.detailsMenuItem = this.createDom('a', {className: 'detailsMenuItem', href: "#"}, '0 failing'));
+
+    this.summaryMenuItem.onclick = function() {
+      dom.reporter.className = dom.reporter.className.replace(/ showDetails/g, '');
+    };
+
+    this.detailsMenuItem.onclick = function() {
+      showDetails();
+    };
+  };
+
+  this.addSpecs = function(specs, specFilter) {
+    this.totalSpecCount = specs.length;
+
+    this.views = {
+      specs: {},
+      suites: {}
+    };
+
+    for (var i = 0; i < specs.length; i++) {
+      var spec = specs[i];
+      this.views.specs[spec.id] = new jasmine.HtmlReporter.SpecView(spec, dom, this.views);
+      if (specFilter(spec)) {
+        this.runningSpecCount++;
+      }
+    }
+  };
+
+  this.specComplete = function(spec) {
+    this.completeSpecCount++;
+
+    if (isUndefined(this.views.specs[spec.id])) {
+      this.views.specs[spec.id] = new jasmine.HtmlReporter.SpecView(spec, dom);
+    }
+
+    var specView = this.views.specs[spec.id];
+
+    switch (specView.status()) {
+      case 'passed':
+        this.passedCount++;
+        break;
+
+      case 'failed':
+        this.failedCount++;
+        break;
+
+      case 'skipped':
+        this.skippedCount++;
+        break;
+    }
+
+    specView.refresh();
+    this.refresh();
+  };
+
+  this.suiteComplete = function(suite) {
+    var suiteView = this.views.suites[suite.id];
+    if (isUndefined(suiteView)) {
+      return;
+    }
+    suiteView.refresh();
+  };
+
+  this.refresh = function() {
+
+    if (isUndefined(this.resultsMenu)) {
+      this.createResultsMenu();
+    }
+
+    // currently running UI
+    if (isUndefined(this.runningAlert)) {
+      this.runningAlert = this.createDom('a', {href: "?", className: "runningAlert bar"});
+      dom.alert.appendChild(this.runningAlert);
+    }
+    this.runningAlert.innerHTML = "Running " + this.completeSpecCount + " of " + specPluralizedFor(this.totalSpecCount);
+
+    // skipped specs UI
+    if (isUndefined(this.skippedAlert)) {
+      this.skippedAlert = this.createDom('a', {href: "?", className: "skippedAlert bar"});
+    }
+
+    this.skippedAlert.innerHTML = "Skipping " + this.skippedCount + " of " + specPluralizedFor(this.totalSpecCount) + " - run all";
+
+    if (this.skippedCount === 1 && isDefined(dom.alert)) {
+      dom.alert.appendChild(this.skippedAlert);
+    }
+
+    // passing specs UI
+    if (isUndefined(this.passedAlert)) {
+      this.passedAlert = this.createDom('span', {href: "?", className: "passingAlert bar"});
+    }
+    this.passedAlert.innerHTML = "Passing " + specPluralizedFor(this.passedCount);
+
+    // failing specs UI
+    if (isUndefined(this.failedAlert)) {
+      this.failedAlert = this.createDom('span', {href: "?", className: "failingAlert bar"});
+    }
+    this.failedAlert.innerHTML = "Failing " + specPluralizedFor(this.failedCount);
+
+    if (this.failedCount === 1 && isDefined(dom.alert)) {
+      dom.alert.appendChild(this.failedAlert);
+      dom.alert.appendChild(this.resultsMenu);
+    }
+
+    // summary info
+    this.summaryMenuItem.innerHTML = "" + specPluralizedFor(this.runningSpecCount);
+    this.detailsMenuItem.innerHTML = "" + this.failedCount + " failing";
+  };
+
+  this.complete = function() {
+    dom.alert.removeChild(this.runningAlert);
+
+    this.skippedAlert.innerHTML = "Ran " + this.runningSpecCount + " of " + specPluralizedFor(this.totalSpecCount) + " - run all";
+
+    if (this.failedCount === 0) {
+      dom.alert.appendChild(this.createDom('span', {className: 'passingAlert bar'}, "Passing " + specPluralizedFor(this.passedCount)));
+    } else {
+      showDetails();
+    }
+
+    dom.banner.appendChild(this.createDom('span', {className: 'duration'}, "finished in " + ((new Date().getTime() - this.startedAt.getTime()) / 1000) + "s"));
+  };
+
+  return this;
+
+  function showDetails() {
+    if (dom.reporter.className.search(/showDetails/) === -1) {
+      dom.reporter.className += " showDetails";
+    }
+  }
+
+  function isUndefined(obj) {
+    return typeof obj === 'undefined';
+  }
+
+  function isDefined(obj) {
+    return !isUndefined(obj);
+  }
+
+  function specPluralizedFor(count) {
+    var str = count + " spec";
+    if (count > 1) {
+      str += "s"
+    }
+    return str;
+  }
+
+};
+
+jasmine.HtmlReporterHelpers.addHelpers(jasmine.HtmlReporter.ReporterView);
+
+
+jasmine.HtmlReporter.SpecView = function(spec, dom, views) {
+  this.spec = spec;
+  this.dom = dom;
+  this.views = views;
+
+  this.symbol = this.createDom('li', { className: 'pending' });
+  this.dom.symbolSummary.appendChild(this.symbol);
+
+  this.summary = this.createDom('div', { className: 'specSummary' },
+      this.createDom('a', {
+        className: 'description',
+        href: '?spec=' + encodeURIComponent(this.spec.getFullName()),
+        title: this.spec.getFullName()
+      }, this.spec.description)
+  );
+
+  this.detail = this.createDom('div', { className: 'specDetail' },
+      this.createDom('a', {
+        className: 'description',
+        href: '?spec=' + encodeURIComponent(this.spec.getFullName()),
+        title: this.spec.getFullName()
+      }, this.spec.getFullName())
+  );
+};
+
+jasmine.HtmlReporter.SpecView.prototype.status = function() {
+  return this.getSpecStatus(this.spec);
+};
+
+jasmine.HtmlReporter.SpecView.prototype.refresh = function() {
+  this.symbol.className = this.status();
+
+  switch (this.status()) {
+    case 'skipped':
+      break;
+
+    case 'passed':
+      this.appendSummaryToSuiteDiv();
+      break;
+
+    case 'failed':
+      this.appendSummaryToSuiteDiv();
+      this.appendFailureDetail();
+      break;
+  }
+};
+
+jasmine.HtmlReporter.SpecView.prototype.appendSummaryToSuiteDiv = function() {
+  this.summary.className += ' ' + this.status();
+  this.appendToSummary(this.spec, this.summary);
+};
+
+jasmine.HtmlReporter.SpecView.prototype.appendFailureDetail = function() {
+  this.detail.className += ' ' + this.status();
+
+  var resultItems = this.spec.results().getItems();
+  var messagesDiv = this.createDom('div', { className: 'messages' });
+
+  for (var i = 0; i < resultItems.length; i++) {
+    var result = resultItems[i];
+
+    if (result.type == 'log') {
+      messagesDiv.appendChild(this.createDom('div', {className: 'resultMessage log'}, result.toString()));
+    } else if (result.type == 'expect' && result.passed && !result.passed()) {
+      messagesDiv.appendChild(this.createDom('div', {className: 'resultMessage fail'}, result.message));
+
+      if (result.trace.stack) {
+        messagesDiv.appendChild(this.createDom('div', {className: 'stackTrace'}, result.trace.stack));
+      }
+    }
+  }
+
+  if (messagesDiv.childNodes.length > 0) {
+    this.detail.appendChild(messagesDiv);
+    this.dom.details.appendChild(this.detail);
+  }
+};
+
+jasmine.HtmlReporterHelpers.addHelpers(jasmine.HtmlReporter.SpecView);jasmine.HtmlReporter.SuiteView = function(suite, dom, views) {
+  this.suite = suite;
+  this.dom = dom;
+  this.views = views;
+
+  this.element = this.createDom('div', { className: 'suite' },
+      this.createDom('a', { className: 'description', href: '?spec=' + encodeURIComponent(this.suite.getFullName()) }, this.suite.description)
+  );
+
+  this.appendToSummary(this.suite, this.element);
+};
+
+jasmine.HtmlReporter.SuiteView.prototype.status = function() {
+  return this.getSpecStatus(this.suite);
+};
+
+jasmine.HtmlReporter.SuiteView.prototype.refresh = function() {
+  this.element.className += " " + this.status();
+};
+
+jasmine.HtmlReporterHelpers.addHelpers(jasmine.HtmlReporter.SuiteView);
+
+/* @deprecated Use jasmine.HtmlReporter instead
+ */
+jasmine.TrivialReporter = function(doc) {
+  this.document = doc || document;
+  this.suiteDivs = {};
+  this.logRunningSpecs = false;
+};
+
+jasmine.TrivialReporter.prototype.createDom = function(type, attrs, childrenVarArgs) {
+  var el = document.createElement(type);
+
+  for (var i = 2; i < arguments.length; i++) {
+    var child = arguments[i];
+
+    if (typeof child === 'string') {
+      el.appendChild(document.createTextNode(child));
+    } else {
+      if (child) { el.appendChild(child); }
+    }
+  }
+
+  for (var attr in attrs) {
+    if (attr == "className") {
+      el[attr] = attrs[attr];
+    } else {
+      el.setAttribute(attr, attrs[attr]);
+    }
+  }
+
+  return el;
+};
+
+jasmine.TrivialReporter.prototype.reportRunnerStarting = function(runner) {
+  var showPassed, showSkipped;
+
+  this.outerDiv = this.createDom('div', { id: 'TrivialReporter', className: 'jasmine_reporter' },
+      this.createDom('div', { className: 'banner' },
+        this.createDom('div', { className: 'logo' },
+            this.createDom('span', { className: 'title' }, "Jasmine"),
+            this.createDom('span', { className: 'version' }, runner.env.versionString())),
+        this.createDom('div', { className: 'options' },
+            "Show ",
+            showPassed = this.createDom('input', { id: "__jasmine_TrivialReporter_showPassed__", type: 'checkbox' }),
+            this.createDom('label', { "for": "__jasmine_TrivialReporter_showPassed__" }, " passed "),
+            showSkipped = this.createDom('input', { id: "__jasmine_TrivialReporter_showSkipped__", type: 'checkbox' }),
+            this.createDom('label', { "for": "__jasmine_TrivialReporter_showSkipped__" }, " skipped")
+            )
+          ),
+
+      this.runnerDiv = this.createDom('div', { className: 'runner running' },
+          this.createDom('a', { className: 'run_spec', href: '?' }, "run all"),
+          this.runnerMessageSpan = this.createDom('span', {}, "Running..."),
+          this.finishedAtSpan = this.createDom('span', { className: 'finished-at' }, ""))
+      );
+
+  this.document.body.appendChild(this.outerDiv);
+
+  var suites = runner.suites();
+  for (var i = 0; i < suites.length; i++) {
+    var suite = suites[i];
+    var suiteDiv = this.createDom('div', { className: 'suite' },
+        this.createDom('a', { className: 'run_spec', href: '?spec=' + encodeURIComponent(suite.getFullName()) }, "run"),
+        this.createDom('a', { className: 'description', href: '?spec=' + encodeURIComponent(suite.getFullName()) }, suite.description));
+    this.suiteDivs[suite.id] = suiteDiv;
+    var parentDiv = this.outerDiv;
+    if (suite.parentSuite) {
+      parentDiv = this.suiteDivs[suite.parentSuite.id];
+    }
+    parentDiv.appendChild(suiteDiv);
+  }
+
+  this.startedAt = new Date();
+
+  var self = this;
+  showPassed.onclick = function(evt) {
+    if (showPassed.checked) {
+      self.outerDiv.className += ' show-passed';
+    } else {
+      self.outerDiv.className = self.outerDiv.className.replace(/ show-passed/, '');
+    }
+  };
+
+  showSkipped.onclick = function(evt) {
+    if (showSkipped.checked) {
+      self.outerDiv.className += ' show-skipped';
+    } else {
+      self.outerDiv.className = self.outerDiv.className.replace(/ show-skipped/, '');
+    }
+  };
+};
+
+jasmine.TrivialReporter.prototype.reportRunnerResults = function(runner) {
+  var results = runner.results();
+  var className = (results.failedCount > 0) ? "runner failed" : "runner passed";
+  this.runnerDiv.setAttribute("class", className);
+  //do it twice for IE
+  this.runnerDiv.setAttribute("className", className);
+  var specs = runner.specs();
+  var specCount = 0;
+  for (var i = 0; i < specs.length; i++) {
+    if (this.specFilter(specs[i])) {
+      specCount++;
+    }
+  }
+  var message = "" + specCount + " spec" + (specCount == 1 ? "" : "s" ) + ", " + results.failedCount + " failure" + ((results.failedCount == 1) ? "" : "s");
+  message += " in " + ((new Date().getTime() - this.startedAt.getTime()) / 1000) + "s";
+  this.runnerMessageSpan.replaceChild(this.createDom('a', { className: 'description', href: '?'}, message), this.runnerMessageSpan.firstChild);
+
+  this.finishedAtSpan.appendChild(document.createTextNode("Finished at " + new Date().toString()));
+};
+
+jasmine.TrivialReporter.prototype.reportSuiteResults = function(suite) {
+  var results = suite.results();
+  var status = results.passed() ? 'passed' : 'failed';
+  if (results.totalCount === 0) { // todo: change this to check results.skipped
+    status = 'skipped';
+  }
+  this.suiteDivs[suite.id].className += " " + status;
+};
+
+jasmine.TrivialReporter.prototype.reportSpecStarting = function(spec) {
+  if (this.logRunningSpecs) {
+    this.log('>> Jasmine Running ' + spec.suite.description + ' ' + spec.description + '...');
+  }
+};
+
+jasmine.TrivialReporter.prototype.reportSpecResults = function(spec) {
+  var results = spec.results();
+  var status = results.passed() ? 'passed' : 'failed';
+  if (results.skipped) {
+    status = 'skipped';
+  }
+  var specDiv = this.createDom('div', { className: 'spec '  + status },
+      this.createDom('a', { className: 'run_spec', href: '?spec=' + encodeURIComponent(spec.getFullName()) }, "run"),
+      this.createDom('a', {
+        className: 'description',
+        href: '?spec=' + encodeURIComponent(spec.getFullName()),
+        title: spec.getFullName()
+      }, spec.description));
+
+
+  var resultItems = results.getItems();
+  var messagesDiv = this.createDom('div', { className: 'messages' });
+  for (var i = 0; i < resultItems.length; i++) {
+    var result = resultItems[i];
+
+    if (result.type == 'log') {
+      messagesDiv.appendChild(this.createDom('div', {className: 'resultMessage log'}, result.toString()));
+    } else if (result.type == 'expect' && result.passed && !result.passed()) {
+      messagesDiv.appendChild(this.createDom('div', {className: 'resultMessage fail'}, result.message));
+
+      if (result.trace.stack) {
+        messagesDiv.appendChild(this.createDom('div', {className: 'stackTrace'}, result.trace.stack));
+      }
+    }
+  }
+
+  if (messagesDiv.childNodes.length > 0) {
+    specDiv.appendChild(messagesDiv);
+  }
+
+  this.suiteDivs[spec.suite.id].appendChild(specDiv);
+};
+
+jasmine.TrivialReporter.prototype.log = function() {
+  var console = jasmine.getGlobal().console;
+  if (console && console.log) {
+    if (console.log.apply) {
+      console.log.apply(console, arguments);
+    } else {
+      console.log(arguments); // ie fix: console.log.apply doesn't exist on ie
+    }
+  }
+};
+
+jasmine.TrivialReporter.prototype.getLocation = function() {
+  return this.document.location;
+};
+
+jasmine.TrivialReporter.prototype.specFilter = function(spec) {
+  var paramMap = {};
+  var params = this.getLocation().search.substring(1).split('&');
+  for (var i = 0; i < params.length; i++) {
+    var p = params[i].split('=');
+    paramMap[decodeURIComponent(p[0])] = decodeURIComponent(p[1]);
+  }
+
+  if (!paramMap.spec) {
+    return true;
+  }
+  return spec.getFullName().indexOf(paramMap.spec) === 0;
+};
+/**
+ Jasmine Reporter that outputs test results to the browser console. 
+ Useful for running in a headless environment such as PhantomJs, ZombieJs etc.
+
+ Usage:
+ // From your html file that loads jasmine:  
+ jasmine.getEnv().addReporter(new jasmine.ConsoleReporter());
+ jasmine.getEnv().execute();
+*/
+
+(function(jasmine, console) {
+  if (!jasmine) {
+    throw "jasmine library isn't loaded!";
+  }
+
+  var ANSI = {}
+  ANSI.color_map = {
+      "green" : 32,
+      "red"   : 31
+  }
+
+  ANSI.colorize_text = function(text, color) {
+    var color_code = this.color_map[color];
+    return "\033[" + color_code + "m" + text + "\033[0m";
+  }
+  
+  var ConsoleReporter = function() {
+    if (!console || !console.log) { throw "console isn't present!"; }
+    this.status = this.statuses.stopped;
+  };
+
+  var proto = ConsoleReporter.prototype;
+  proto.statuses = {
+    stopped : "stopped",
+    running : "running",
+    fail    : "fail",
+    success : "success"
+  };
+
+  proto.reportRunnerStarting = function(runner) {
+    this.status = this.statuses.running;
+    this.start_time = (new Date()).getTime();
+    this.executed_specs = 0;
+    this.passed_specs = 0;
+    this.log("Starting...");
+  };
+
+  proto.reportRunnerResults = function(runner) {
+    var failed = this.executed_specs - this.passed_specs;
+    var spec_str = this.executed_specs + (this.executed_specs === 1 ? " spec, " : " specs, ");
+    var fail_str = failed + (failed === 1 ? " failure in " : " failures in ");
+    var color = (failed > 0)? "red" : "green";
+    var dur = (new Date()).getTime() - this.start_time;
+
+    this.log("");
+    this.log("Finished");
+    this.log("-----------------");
+    this.log(spec_str + fail_str + (dur/1000) + "s.", color);
+
+    this.status = (failed > 0)? this.statuses.fail : this.statuses.success;
+
+    /* Print something that signals that testing is over so that headless browsers
+       like PhantomJs know when to terminate. */
+    this.log("");
+    this.log("ConsoleReporter finished");
+  };
+
+
+  proto.reportSpecStarting = function(spec) {
+    this.executed_specs++;
+  };
+
+  proto.reportSpecResults = function(spec) {
+    if (spec.results().passed()) {
+      this.passed_specs++;
+      return;
+    }
+
+    var resultText = spec.suite.description + " : " + spec.description;
+    this.log(resultText, "red");
+
+    var items = spec.results().getItems()
+    for (var i = 0; i < items.length; i++) {
+      var text = items[i].trace;
+      this.log(text, "red");
+    }
+  };
+
+  proto.reportSuiteResults = function(suite) {
+    if (!suite.parentSuite) { return; }
+    var results = suite.results();
+    var failed = results.totalCount - results.passedCount;
+    var color = (failed > 0)? "red" : "green";
+    this.log(suite.description + ": " + results.passedCount + " of " + results.totalCount + " passed.", color);
+  };
+
+  proto.log = function(str, color) {
+    var text = (color != undefined)? ANSI.colorize_text(str, color) : str;
+    console.log(text)
+  };
+
+  jasmine.ConsoleReporter = ConsoleReporter;
+})(jasmine, console);
+
+(function (global, module) {
+
+  if ('undefined' == typeof module) {
+    var module = { exports: {} }
+      , exports = module.exports
+  }
+
+  /**
+   * Exports.
+   */
+
+  module.exports = expect;
+  expect.Assertion = Assertion;
+
+  /**
+   * Exports version.
+   */
+
+  expect.version = '0.1.2';
+
+  /**
+   * Possible assertion flags.
+   */
+
+  var flags = {
+      not: ['to', 'be', 'have', 'include', 'only']
+    , to: ['be', 'have', 'include', 'only', 'not']
+    , only: ['have']
+    , have: ['own']
+    , be: ['an']
+  };
+
+  function expect (obj) {
+    return new Assertion(obj);
+  }
+
+  /**
+   * Constructor
+   *
+   * @api private
+   */
+
+  function Assertion (obj, flag, parent) {
+    this.obj = obj;
+    this.flags = {};
+
+    if (undefined != parent) {
+      this.flags[flag] = true;
+
+      for (var i in parent.flags) {
+        if (parent.flags.hasOwnProperty(i)) {
+          this.flags[i] = true;
+        }
+      }
+    }
+
+    var $flags = flag ? flags[flag] : keys(flags)
+      , self = this
+
+    if ($flags) {
+      for (var i = 0, l = $flags.length; i < l; i++) {
+        // avoid recursion
+        if (this.flags[$flags[i]]) continue;
+
+        var name = $flags[i]
+          , assertion = new Assertion(this.obj, name, this)
+
+        if ('function' == typeof Assertion.prototype[name]) {
+          // clone the function, make sure we dont touch the prot reference
+          var old = this[name];
+          this[name] = function () {
+            return old.apply(self, arguments);
+          }
+
+          for (var fn in Assertion.prototype) {
+            if (Assertion.prototype.hasOwnProperty(fn) && fn != name) {
+              this[name][fn] = bind(assertion[fn], assertion);
+            }
+          }
+        } else {
+          this[name] = assertion;
+        }
+      }
+    }
+  };
+
+  /**
+   * Performs an assertion
+   *
+   * @api private
+   */
+
+  Assertion.prototype.assert = function (truth, msg, error) {
+    var msg = this.flags.not ? error : msg
+      , ok = this.flags.not ? !truth : truth;
+
+    if (!ok) {
+      throw new Error(msg);
+    }
+
+    this.and = new Assertion(this.obj);
+  };
+
+  /**
+   * Check if the value is truthy
+   *
+   * @api public
+   */
+
+  Assertion.prototype.ok = function () {
+    this.assert(
+        !!this.obj
+      , 'expected ' + i(this.obj) + ' to be truthy'
+      , 'expected ' + i(this.obj) + ' to be falsy');
+  };
+
+  /**
+   * Assert that the function throws.
+   *
+   * @param {Function|RegExp} callback, or regexp to match error string against
+   * @api public
+   */
+
+  Assertion.prototype.throwError =
+  Assertion.prototype.throwException = function (fn) {
+    expect(this.obj).to.be.a('function');
+
+    var thrown = false
+      , not = this.flags.not
+
+    try {
+      this.obj();
+    } catch (e) {
+      if ('function' == typeof fn) {
+        fn(e);
+      } else if ('object' == typeof fn) {
+        var subject = 'string' == typeof e ? e : e.message;
+        if (not) {
+          expect(subject).to.not.match(fn);
+        } else {
+          expect(subject).to.match(fn);
+        }
+      }
+      thrown = true;
+    }
+
+    if ('object' == typeof fn && not) {
+      // in the presence of a matcher, ensure the `not` only applies to
+      // the matching.
+      this.flags.not = false;
+    }
+
+    var name = this.obj.name || 'fn';
+    this.assert(
+        thrown
+      , 'expected ' + name + ' to throw an exception'
+      , 'expected ' + name + ' not to throw an exception');
+  };
+
+  /**
+   * Checks if the array is empty.
+   *
+   * @api public
+   */
+
+  Assertion.prototype.empty = function () {
+    var expectation;
+
+    if ('object' == typeof this.obj && null !== this.obj && !isArray(this.obj)) {
+      if ('number' == typeof this.obj.length) {
+        expectation = !this.obj.length;
+      } else {
+        expectation = !keys(this.obj).length;
+      }
+    } else {
+      if ('string' != typeof this.obj) {
+        expect(this.obj).to.be.an('object');
+      }
+
+      expect(this.obj).to.have.property('length');
+      expectation = !this.obj.length;
+    }
+
+    this.assert(
+        expectation
+      , 'expected ' + i(this.obj) + ' to be empty'
+      , 'expected ' + i(this.obj) + ' to not be empty');
+    return this;
+  };
+
+  /**
+   * Checks if the obj exactly equals another.
+   *
+   * @api public
+   */
+
+  Assertion.prototype.be =
+  Assertion.prototype.equal = function (obj) {
+    this.assert(
+        obj === this.obj
+      , 'expected ' + i(this.obj) + ' to equal ' + i(obj)
+      , 'expected ' + i(this.obj) + ' to not equal ' + i(obj));
+    return this;
+  };
+
+  /**
+   * Checks if the obj sortof equals another.
+   *
+   * @api public
+   */
+
+  Assertion.prototype.eql = function (obj) {
+    this.assert(
+        expect.eql(obj, this.obj)
+      , 'expected ' + i(this.obj) + ' to sort of equal ' + i(obj)
+      , 'expected ' + i(this.obj) + ' to sort of not equal ' + i(obj));
+    return this;
+  };
+
+  /**
+   * Assert within start to finish (inclusive).
+   *
+   * @param {Number} start
+   * @param {Number} finish
+   * @api public
+   */
+
+  Assertion.prototype.within = function (start, finish) {
+    var range = start + '..' + finish;
+    this.assert(
+        this.obj >= start && this.obj <= finish
+      , 'expected ' + i(this.obj) + ' to be within ' + range
+      , 'expected ' + i(this.obj) + ' to not be within ' + range);
+    return this;
+  };
+
+  /**
+   * Assert typeof / instance of
+   *
+   * @api public
+   */
+
+  Assertion.prototype.a =
+  Assertion.prototype.an = function (type) {
+    if ('string' == typeof type) {
+      // proper english in error msg
+      var n = /^[aeiou]/.test(type) ? 'n' : '';
+
+      // typeof with support for 'array'
+      this.assert(
+          'array' == type ? isArray(this.obj) :
+            'object' == type
+              ? 'object' == typeof this.obj && null !== this.obj
+              : type == typeof this.obj
+        , 'expected ' + i(this.obj) + ' to be a' + n + ' ' + type
+        , 'expected ' + i(this.obj) + ' not to be a' + n + ' ' + type);
+    } else {
+      // instanceof
+      var name = type.name || 'supplied constructor';
+      this.assert(
+          this.obj instanceof type
+        , 'expected ' + i(this.obj) + ' to be an instance of ' + name
+        , 'expected ' + i(this.obj) + ' not to be an instance of ' + name);
+    }
+
+    return this;
+  };
+
+  /**
+   * Assert numeric value above _n_.
+   *
+   * @param {Number} n
+   * @api public
+   */
+
+  Assertion.prototype.greaterThan =
+  Assertion.prototype.above = function (n) {
+    this.assert(
+        this.obj > n
+      , 'expected ' + i(this.obj) + ' to be above ' + n
+      , 'expected ' + i(this.obj) + ' to be below ' + n);
+    return this;
+  };
+
+  /**
+   * Assert numeric value below _n_.
+   *
+   * @param {Number} n
+   * @api public
+   */
+
+  Assertion.prototype.lessThan =
+  Assertion.prototype.below = function (n) {
+    this.assert(
+        this.obj < n
+      , 'expected ' + i(this.obj) + ' to be below ' + n
+      , 'expected ' + i(this.obj) + ' to be above ' + n);
+    return this;
+  };
+
+  /**
+   * Assert string value matches _regexp_.
+   *
+   * @param {RegExp} regexp
+   * @api public
+   */
+
+  Assertion.prototype.match = function (regexp) {
+    this.assert(
+        regexp.exec(this.obj)
+      , 'expected ' + i(this.obj) + ' to match ' + regexp
+      , 'expected ' + i(this.obj) + ' not to match ' + regexp);
+    return this;
+  };
+
+  /**
+   * Assert property "length" exists and has value of _n_.
+   *
+   * @param {Number} n
+   * @api public
+   */
+
+  Assertion.prototype.length = function (n) {
+    expect(this.obj).to.have.property('length');
+    var len = this.obj.length;
+    this.assert(
+        n == len
+      , 'expected ' + i(this.obj) + ' to have a length of ' + n + ' but got ' + len
+      , 'expected ' + i(this.obj) + ' to not have a length of ' + len);
+    return this;
+  };
+
+  /**
+   * Assert property _name_ exists, with optional _val_.
+   *
+   * @param {String} name
+   * @param {Mixed} val
+   * @api public
+   */
+
+  Assertion.prototype.property = function (name, val) {
+    if (this.flags.own) {
+      this.assert(
+          Object.prototype.hasOwnProperty.call(this.obj, name)
+        , 'expected ' + i(this.obj) + ' to have own property ' + i(name)
+        , 'expected ' + i(this.obj) + ' to not have own property ' + i(name));
+      return this;
+    }
+
+    if (this.flags.not && undefined !== val) {
+      if (undefined === this.obj[name]) {
+        throw new Error(i(this.obj) + ' has no property ' + i(name));
+      }
+    } else {
+      var hasProp;
+      try {
+        hasProp = name in this.obj
+      } catch (e) {
+        hasProp = undefined !== this.obj[name]
+      }
+
+      this.assert(
+          hasProp
+        , 'expected ' + i(this.obj) + ' to have a property ' + i(name)
+        , 'expected ' + i(this.obj) + ' to not have a property ' + i(name));
+    }
+
+    if (undefined !== val) {
+      this.assert(
+          val === this.obj[name]
+        , 'expected ' + i(this.obj) + ' to have a property ' + i(name)
+          + ' of ' + i(val) + ', but got ' + i(this.obj[name])
+        , 'expected ' + i(this.obj) + ' to not have a property ' + i(name)
+          + ' of ' + i(val));
+    }
+
+    this.obj = this.obj[name];
+    return this;
+  };
+
+  /**
+   * Assert that the array contains _obj_ or string contains _obj_.
+   *
+   * @param {Mixed} obj|string
+   * @api public
+   */
+
+  Assertion.prototype.string =
+  Assertion.prototype.contain = function (obj) {
+    if ('string' == typeof this.obj) {
+      this.assert(
+          ~this.obj.indexOf(obj)
+        , 'expected ' + i(this.obj) + ' to contain ' + i(obj)
+        , 'expected ' + i(this.obj) + ' to not contain ' + i(obj));
+    } else {
+      this.assert(
+          ~indexOf(this.obj, obj)
+        , 'expected ' + i(this.obj) + ' to contain ' + i(obj)
+        , 'expected ' + i(this.obj) + ' to not contain ' + i(obj));
+    }
+    return this;
+  };
+
+  /**
+   * Assert exact keys or inclusion of keys by using
+   * the `.own` modifier.
+   *
+   * @param {Array|String ...} keys
+   * @api public
+   */
+
+  Assertion.prototype.key =
+  Assertion.prototype.keys = function ($keys) {
+    var str
+      , ok = true;
+
+    $keys = isArray($keys)
+      ? $keys
+      : Array.prototype.slice.call(arguments);
+
+    if (!$keys.length) throw new Error('keys required');
+
+    var actual = keys(this.obj)
+      , len = $keys.length;
+
+    // Inclusion
+    ok = every($keys, function (key) {
+      return ~indexOf(actual, key);
+    });
+
+    // Strict
+    if (!this.flags.not && this.flags.only) {
+      ok = ok && $keys.length == actual.length;
+    }
+
+    // Key string
+    if (len > 1) {
+      $keys = map($keys, function (key) {
+        return i(key);
+      });
+      var last = $keys.pop();
+      str = $keys.join(', ') + ', and ' + last;
+    } else {
+      str = i($keys[0]);
+    }
+
+    // Form
+    str = (len > 1 ? 'keys ' : 'key ') + str;
+
+    // Have / include
+    str = (!this.flags.only ? 'include ' : 'only have ') + str;
+
+    // Assertion
+    this.assert(
+        ok
+      , 'expected ' + i(this.obj) + ' to ' + str
+      , 'expected ' + i(this.obj) + ' to not ' + str);
+
+    return this;
+  };
+
+  /**
+   * Function bind implementation.
+   */
+
+  function bind (fn, scope) {
+    return function () {
+      return fn.apply(scope, arguments);
+    }
+  }
+
+  /**
+   * Array every compatibility
+   *
+   * @see bit.ly/5Fq1N2
+   * @api public
+   */
+
+  function every (arr, fn, thisObj) {
+    var scope = thisObj || global;
+    for (var i = 0, j = arr.length; i < j; ++i) {
+      if (!fn.call(scope, arr[i], i, arr)) {
+        return false;
+      }
+    }
+    return true;
+  };
+
+  /**
+   * Array indexOf compatibility.
+   *
+   * @see bit.ly/a5Dxa2
+   * @api public
+   */
+
+  function indexOf (arr, o, i) {
+    if (Array.prototype.indexOf) {
+      return Array.prototype.indexOf.call(arr, o, i);
+    }
+
+    if (arr.length === undefined) {
+      return -1;
+    }
+
+    for (var j = arr.length, i = i < 0 ? i + j < 0 ? 0 : i + j : i || 0
+        ; i < j && arr[i] !== o; i++);
+
+    return j <= i ? -1 : i;
+  };
+
+  /**
+   * Inspects an object.
+   *
+   * @see taken from node.js `util` module (copyright Joyent, MIT license)
+   * @api private
+   */
+
+  function i (obj, showHidden, depth) {
+    var seen = [];
+
+    function stylize (str) {
+      return str;
+    };
+
+    function format (value, recurseTimes) {
+      // Provide a hook for user-specified inspect functions.
+      // Check that value is an object with an inspect function on it
+      if (value && typeof value.inspect === 'function' &&
+          // Filter out the util module, it's inspect function is special
+          value !== exports &&
+          // Also filter out any prototype objects using the circular check.
+          !(value.constructor && value.constructor.prototype === value)) {
+        return value.inspect(recurseTimes);
+      }
+
+      // Primitive types cannot have properties
+      switch (typeof value) {
+        case 'undefined':
+          return stylize('undefined', 'undefined');
+
+        case 'string':
+          var simple = '\'' + json.stringify(value).replace(/^"|"$/g, '')
+                                                   .replace(/'/g, "\\'")
+                                                   .replace(/\\"/g, '"') + '\'';
+          return stylize(simple, 'string');
+
+        case 'number':
+          return stylize('' + value, 'number');
+
+        case 'boolean':
+          return stylize('' + value, 'boolean');
+      }
+      // For some reason typeof null is "object", so special case here.
+      if (value === null) {
+        return stylize('null', 'null');
+      }
+
+      // Look up the keys of the object.
+      var visible_keys = keys(value);
+      var $keys = showHidden ? Object.getOwnPropertyNames(value) : visible_keys;
+
+      // Functions without properties can be shortcutted.
+      if (typeof value === 'function' && $keys.length === 0) {
+        if (isRegExp(value)) {
+          return stylize('' + value, 'regexp');
+        } else {
+          var name = value.name ? ': ' + value.name : '';
+          return stylize('[Function' + name + ']', 'special');
+        }
+      }
+
+      // Dates without properties can be shortcutted
+      if (isDate(value) && $keys.length === 0) {
+        return stylize(value.toUTCString(), 'date');
+      }
+
+      var base, type, braces;
+      // Determine the object type
+      if (isArray(value)) {
+        type = 'Array';
+        braces = ['[', ']'];
+      } else {
+        type = 'Object';
+        braces = ['{', '}'];
+      }
+
+      // Make functions say that they are functions
+      if (typeof value === 'function') {
+        var n = value.name ? ': ' + value.name : '';
+        base = (isRegExp(value)) ? ' ' + value : ' [Function' + n + ']';
+      } else {
+        base = '';
+      }
+
+      // Make dates with properties first say the date
+      if (isDate(value)) {
+        base = ' ' + value.toUTCString();
+      }
+
+      if ($keys.length === 0) {
+        return braces[0] + base + braces[1];
+      }
+
+      if (recurseTimes < 0) {
+        if (isRegExp(value)) {
+          return stylize('' + value, 'regexp');
+        } else {
+          return stylize('[Object]', 'special');
+        }
+      }
+
+      seen.push(value);
+
+      var output = map($keys, function (key) {
+        var name, str;
+        if (value.__lookupGetter__) {
+          if (value.__lookupGetter__(key)) {
+            if (value.__lookupSetter__(key)) {
+              str = stylize('[Getter/Setter]', 'special');
+            } else {
+              str = stylize('[Getter]', 'special');
+            }
+          } else {
+            if (value.__lookupSetter__(key)) {
+              str = stylize('[Setter]', 'special');
+            }
+          }
+        }
+        if (indexOf(visible_keys, key) < 0) {
+          name = '[' + key + ']';
+        }
+        if (!str) {
+          if (indexOf(seen, value[key]) < 0) {
+            if (recurseTimes === null) {
+              str = format(value[key]);
+            } else {
+              str = format(value[key], recurseTimes - 1);
+            }
+            if (str.indexOf('\n') > -1) {
+              if (isArray(value)) {
+                str = map(str.split('\n'), function (line) {
+                  return '  ' + line;
+                }).join('\n').substr(2);
+              } else {
+                str = '\n' + map(str.split('\n'), function (line) {
+                  return '   ' + line;
+                }).join('\n');
+              }
+            }
+          } else {
+            str = stylize('[Circular]', 'special');
+          }
+        }
+        if (typeof name === 'undefined') {
+          if (type === 'Array' && key.match(/^\d+$/)) {
+            return str;
+          }
+          name = json.stringify('' + key);
+          if (name.match(/^"([a-zA-Z_][a-zA-Z_0-9]*)"$/)) {
+            name = name.substr(1, name.length - 2);
+            name = stylize(name, 'name');
+          } else {
+            name = name.replace(/'/g, "\\'")
+                       .replace(/\\"/g, '"')
+                       .replace(/(^"|"$)/g, "'");
+            name = stylize(name, 'string');
+          }
+        }
+
+        return name + ': ' + str;
+      });
+
+      seen.pop();
+
+      var numLinesEst = 0;
+      var length = reduce(output, function (prev, cur) {
+        numLinesEst++;
+        if (indexOf(cur, '\n') >= 0) numLinesEst++;
+        return prev + cur.length + 1;
+      }, 0);
+
+      if (length > 50) {
+        output = braces[0] +
+                 (base === '' ? '' : base + '\n ') +
+                 ' ' +
+                 output.join(',\n  ') +
+                 ' ' +
+                 braces[1];
+
+      } else {
+        output = braces[0] + base + ' ' + output.join(', ') + ' ' + braces[1];
+      }
+
+      return output;
+    }
+    return format(obj, (typeof depth === 'undefined' ? 2 : depth));
+  };
+
+  function isArray (ar) {
+    return Object.prototype.toString.call(ar) == '[object Array]';
+  };
+
+  function isRegExp(re) {
+    var s = '' + re;
+    return re instanceof RegExp || // easy case
+           // duck-type for context-switching evalcx case
+           typeof(re) === 'function' &&
+           re.constructor.name === 'RegExp' &&
+           re.compile &&
+           re.test &&
+           re.exec &&
+           s.match(/^\/.*\/[gim]{0,3}$/);
+  };
+
+  function isDate(d) {
+    if (d instanceof Date) return true;
+    return false;
+  };
+
+  function keys (obj) {
+    if (Object.keys) {
+      return Object.keys(obj);
+    }
+
+    var keys = [];
+
+    for (var i in obj) {
+      if (Object.prototype.hasOwnProperty.call(obj, i)) {
+        keys.push(i);
+      }
+    }
+
+    return keys;
+  }
+
+  function map (arr, mapper, that) {
+    if (Array.prototype.map) {
+      return Array.prototype.map.call(arr, mapper, that);
+    }
+
+    var other= new Array(arr.length);
+
+    for (var i= 0, n = arr.length; i<n; i++)
+      if (i in arr)
+        other[i] = mapper.call(that, arr[i], i, arr);
+
+    return other;
+  };
+
+  function reduce (arr, fun) {
+    if (Array.prototype.reduce) {
+      return Array.prototype.reduce.apply(
+          arr
+        , Array.prototype.slice.call(arguments, 1)
+      );
+    }
+
+    var len = +this.length;
+
+    if (typeof fun !== "function")
+      throw new TypeError();
+
+    // no value to return if no initial value and an empty array
+    if (len === 0 && arguments.length === 1)
+      throw new TypeError();
+
+    var i = 0;
+    if (arguments.length >= 2) {
+      var rv = arguments[1];
+    } else {
+      do {
+        if (i in this) {
+          rv = this[i++];
+          break;
+        }
+
+        // if array contains no values, no initial value to return
+        if (++i >= len)
+          throw new TypeError();
+      } while (true);
+    }
+
+    for (; i < len; i++) {
+      if (i in this)
+        rv = fun.call(null, rv, this[i], i, this);
+    }
+
+    return rv;
+  };
+
+  /**
+   * Asserts deep equality
+   *
+   * @see taken from node.js `assert` module (copyright Joyent, MIT license)
+   * @api private
+   */
+
+  expect.eql = function eql (actual, expected) {
+    // 7.1. All identical values are equivalent, as determined by ===.
+    if (actual === expected) {
+      return true;
+    } else if ('undefined' != typeof Buffer
+        && Buffer.isBuffer(actual) && Buffer.isBuffer(expected)) {
+      if (actual.length != expected.length) return false;
+
+      for (var i = 0; i < actual.length; i++) {
+        if (actual[i] !== expected[i]) return false;
+      }
+
+      return true;
+
+    // 7.2. If the expected value is a Date object, the actual value is
+    // equivalent if it is also a Date object that refers to the same time.
+    } else if (actual instanceof Date && expected instanceof Date) {
+      return actual.getTime() === expected.getTime();
+
+    // 7.3. Other pairs that do not both pass typeof value == "object",
+    // equivalence is determined by ==.
+    } else if (typeof actual != 'object' && typeof expected != 'object') {
+      return actual == expected;
+
+    // 7.4. For all other Object pairs, including Array objects, equivalence is
+    // determined by having the same number of owned properties (as verified
+    // with Object.prototype.hasOwnProperty.call), the same set of keys
+    // (although not necessarily the same order), equivalent values for every
+    // corresponding key, and an identical "prototype" property. Note: this
+    // accounts for both named and indexed properties on Arrays.
+    } else {
+      return objEquiv(actual, expected);
+    }
+  }
+
+  function isUndefinedOrNull (value) {
+    return value === null || value === undefined;
+  }
+
+  function isArguments (object) {
+    return Object.prototype.toString.call(object) == '[object Arguments]';
+  }
+
+  function objEquiv (a, b) {
+    if (isUndefinedOrNull(a) || isUndefinedOrNull(b))
+      return false;
+    // an identical "prototype" property.
+    if (a.prototype !== b.prototype) return false;
+    //~~~I've managed to break Object.keys through screwy arguments passing.
+    //   Converting to array solves the problem.
+    if (isArguments(a)) {
+      if (!isArguments(b)) {
+        return false;
+      }
+      a = pSlice.call(a);
+      b = pSlice.call(b);
+      return expect.eql(a, b);
+    }
+    try{
+      var ka = keys(a),
+        kb = keys(b),
+        key, i;
+    } catch (e) {//happens when one is a string literal and the other isn't
+      return false;
+    }
+    // having the same number of owned properties (keys incorporates hasOwnProperty)
+    if (ka.length != kb.length)
+      return false;
+    //the same set of keys (although not necessarily the same order),
+    ka.sort();
+    kb.sort();
+    //~~~cheap key test
+    for (i = ka.length - 1; i >= 0; i--) {
+      if (ka[i] != kb[i])
+        return false;
+    }
+    //equivalent values for every corresponding key, and
+    //~~~possibly expensive deep test
+    for (i = ka.length - 1; i >= 0; i--) {
+      key = ka[i];
+      if (!expect.eql(a[key], b[key]))
+         return false;
+    }
+    return true;
+  }
+
+  var json = (function () {
+    "use strict";
+
+    if ('object' == typeof JSON && JSON.parse && JSON.stringify) {
+      return {
+          parse: nativeJSON.parse
+        , stringify: nativeJSON.stringify
+      }
+    }
+
+    var JSON = {};
+
+    function f(n) {
+        // Format integers to have at least two digits.
+        return n < 10 ? '0' + n : n;
+    }
+
+    function date(d, key) {
+      return isFinite(d.valueOf()) ?
+          d.getUTCFullYear()     + '-' +
+          f(d.getUTCMonth() + 1) + '-' +
+          f(d.getUTCDate())      + 'T' +
+          f(d.getUTCHours())     + ':' +
+          f(d.getUTCMinutes())   + ':' +
+          f(d.getUTCSeconds())   + 'Z' : null;
+    };
+
+    var cx = /[\u0000\u00ad\u0600-\u0604\u070f\u17b4\u17b5\u200c-\u200f\u2028-\u202f\u2060-\u206f\ufeff\ufff0-\uffff]/g,
+        escapable = /[\\\"\x00-\x1f\x7f-\x9f\u00ad\u0600-\u0604\u070f\u17b4\u17b5\u200c-\u200f\u2028-\u202f\u2060-\u206f\ufeff\ufff0-\uffff]/g,
+        gap,
+        indent,
+        meta = {    // table of character substitutions
+            '\b': '\\b',
+            '\t': '\\t',
+            '\n': '\\n',
+            '\f': '\\f',
+            '\r': '\\r',
+            '"' : '\\"',
+            '\\': '\\\\'
+        },
+        rep;
+
+
+    function quote(string) {
+
+  // If the string contains no control characters, no quote characters, and no
+  // backslash characters, then we can safely slap some quotes around it.
+  // Otherwise we must also replace the offending characters with safe escape
+  // sequences.
+
+        escapable.lastIndex = 0;
+        return escapable.test(string) ? '"' + string.replace(escapable, function (a) {
+            var c = meta[a];
+            return typeof c === 'string' ? c :
+                '\\u' + ('0000' + a.charCodeAt(0).toString(16)).slice(-4);
+        }) + '"' : '"' + string + '"';
+    }
+
+
+    function str(key, holder) {
+
+  // Produce a string from holder[key].
+
+        var i,          // The loop counter.
+            k,          // The member key.
+            v,          // The member value.
+            length,
+            mind = gap,
+            partial,
+            value = holder[key];
+
+  // If the value has a toJSON method, call it to obtain a replacement value.
+
+        if (value instanceof Date) {
+            value = date(key);
+        }
+
+  // If we were called with a replacer function, then call the replacer to
+  // obtain a replacement value.
+
+        if (typeof rep === 'function') {
+            value = rep.call(holder, key, value);
+        }
+
+  // What happens next depends on the value's type.
+
+        switch (typeof value) {
+        case 'string':
+            return quote(value);
+
+        case 'number':
+
+  // JSON numbers must be finite. Encode non-finite numbers as null.
+
+            return isFinite(value) ? String(value) : 'null';
+
+        case 'boolean':
+        case 'null':
+
+  // If the value is a boolean or null, convert it to a string. Note:
+  // typeof null does not produce 'null'. The case is included here in
+  // the remote chance that this gets fixed someday.
+
+            return String(value);
+
+  // If the type is 'object', we might be dealing with an object or an array or
+  // null.
+
+        case 'object':
+
+  // Due to a specification blunder in ECMAScript, typeof null is 'object',
+  // so watch out for that case.
+
+            if (!value) {
+                return 'null';
+            }
+
+  // Make an array to hold the partial results of stringifying this object value.
+
+            gap += indent;
+            partial = [];
+
+  // Is the value an array?
+
+            if (Object.prototype.toString.apply(value) === '[object Array]') {
+
+  // The value is an array. Stringify every element. Use null as a placeholder
+  // for non-JSON values.
+
+                length = value.length;
+                for (i = 0; i < length; i += 1) {
+                    partial[i] = str(i, value) || 'null';
+                }
+
+  // Join all of the elements together, separated with commas, and wrap them in
+  // brackets.
+
+                v = partial.length === 0 ? '[]' : gap ?
+                    '[\n' + gap + partial.join(',\n' + gap) + '\n' + mind + ']' :
+                    '[' + partial.join(',') + ']';
+                gap = mind;
+                return v;
+            }
+
+  // If the replacer is an array, use it to select the members to be stringified.
+
+            if (rep && typeof rep === 'object') {
+                length = rep.length;
+                for (i = 0; i < length; i += 1) {
+                    if (typeof rep[i] === 'string') {
+                        k = rep[i];
+                        v = str(k, value);
+                        if (v) {
+                            partial.push(quote(k) + (gap ? ': ' : ':') + v);
+                        }
+                    }
+                }
+            } else {
+
+  // Otherwise, iterate through all of the keys in the object.
+
+                for (k in value) {
+                    if (Object.prototype.hasOwnProperty.call(value, k)) {
+                        v = str(k, value);
+                        if (v) {
+                            partial.push(quote(k) + (gap ? ': ' : ':') + v);
+                        }
+                    }
+                }
+            }
+
+  // Join all of the member texts together, separated with commas,
+  // and wrap them in braces.
+
+            v = partial.length === 0 ? '{}' : gap ?
+                '{\n' + gap + partial.join(',\n' + gap) + '\n' + mind + '}' :
+                '{' + partial.join(',') + '}';
+            gap = mind;
+            return v;
+        }
+    }
+
+  // If the JSON object does not yet have a stringify method, give it one.
+
+    JSON.stringify = function (value, replacer, space) {
+
+  // The stringify method takes a value and an optional replacer, and an optional
+  // space parameter, and returns a JSON text. The replacer can be a function
+  // that can replace values, or an array of strings that will select the keys.
+  // A default replacer method can be provided. Use of the space parameter can
+  // produce text that is more easily readable.
+
+        var i;
+        gap = '';
+        indent = '';
+
+  // If the space parameter is a number, make an indent string containing that
+  // many spaces.
+
+        if (typeof space === 'number') {
+            for (i = 0; i < space; i += 1) {
+                indent += ' ';
+            }
+
+  // If the space parameter is a string, it will be used as the indent string.
+
+        } else if (typeof space === 'string') {
+            indent = space;
+        }
+
+  // If there is a replacer, it must be a function or an array.
+  // Otherwise, throw an error.
+
+        rep = replacer;
+        if (replacer && typeof replacer !== 'function' &&
+                (typeof replacer !== 'object' ||
+                typeof replacer.length !== 'number')) {
+            throw new Error('JSON.stringify');
+        }
+
+  // Make a fake root object containing our value under the key of ''.
+  // Return the result of stringifying the value.
+
+        return str('', {'': value});
+    };
+
+  // If the JSON object does not yet have a parse method, give it one.
+
+    JSON.parse = function (text, reviver) {
+    // The parse method takes a text and an optional reviver function, and returns
+    // a JavaScript value if the text is a valid JSON text.
+
+        var j;
+
+        function walk(holder, key) {
+
+    // The walk method is used to recursively walk the resulting structure so
+    // that modifications can be made.
+
+            var k, v, value = holder[key];
+            if (value && typeof value === 'object') {
+                for (k in value) {
+                    if (Object.prototype.hasOwnProperty.call(value, k)) {
+                        v = walk(value, k);
+                        if (v !== undefined) {
+                            value[k] = v;
+                        } else {
+                            delete value[k];
+                        }
+                    }
+                }
+            }
+            return reviver.call(holder, key, value);
+        }
+
+
+    // Parsing happens in four stages. In the first stage, we replace certain
+    // Unicode characters with escape sequences. JavaScript handles many characters
+    // incorrectly, either silently deleting them, or treating them as line endings.
+
+        text = String(text);
+        cx.lastIndex = 0;
+        if (cx.test(text)) {
+            text = text.replace(cx, function (a) {
+                return '\\u' +
+                    ('0000' + a.charCodeAt(0).toString(16)).slice(-4);
+            });
+        }
+
+    // In the second stage, we run the text against regular expressions that look
+    // for non-JSON patterns. We are especially concerned with '()' and 'new'
+    // because they can cause invocation, and '=' because it can cause mutation.
+    // But just to be safe, we want to reject all unexpected forms.
+
+    // We split the second stage into 4 regexp operations in order to work around
+    // crippling inefficiencies in IE's and Safari's regexp engines. First we
+    // replace the JSON backslash pairs with '@' (a non-JSON character). Second, we
+    // replace all simple value tokens with ']' characters. Third, we delete all
+    // open brackets that follow a colon or comma or that begin the text. Finally,
+    // we look to see that the remaining characters are only whitespace or ']' or
+    // ',' or ':' or '{' or '}'. If that is so, then the text is safe for eval.
+
+        if (/^[\],:{}\s]*$/
+                .test(text.replace(/\\(?:["\\\/bfnrt]|u[0-9a-fA-F]{4})/g, '@')
+                    .replace(/"[^"\\\n\r]*"|true|false|null|-?\d+(?:\.\d*)?(?:[eE][+\-]?\d+)?/g, ']')
+                    .replace(/(?:^|:|,)(?:\s*\[)+/g, ''))) {
+
+    // In the third stage we use the eval function to compile the text into a
+    // JavaScript structure. The '{' operator is subject to a syntactic ambiguity
+    // in JavaScript: it can begin a block or an object literal. We wrap the text
+    // in parens to eliminate the ambiguity.
+
+            j = eval('(' + text + ')');
+
+    // In the optional fourth stage, we recursively walk the new structure, passing
+    // each name/value pair to a reviver function for possible transformation.
+
+            return typeof reviver === 'function' ?
+                walk({'': j}, '') : j;
+        }
+
+    // If the text is not JSON parseable, then a SyntaxError is thrown.
+
+        throw new SyntaxError('JSON.parse');
+    };
+
+    return JSON;
+  })();
+
+  if ('undefined' != typeof window) {
+    window.expect = module.exports;
+  }
+
+})(
+    this
+  , 'undefined' != typeof module ? module : {}
+  , 'undefined' != typeof exports ? exports : {}
+);
+/**
+ * Sinon.JS 1.3.4, 2012/04/16
+ *
+ * @author Christian Johansen (christian@cjohansen.no)
+ *
+ * (The BSD License)
+ *
+ * Copyright (c) 2010-2011, Christian Johansen, christian@cjohansen.no
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ *
+ *     * Redistributions of source code must retain the above copyright notice,
+ *       this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright notice,
+ *       this list of conditions and the following disclaimer in the documentation
+ *       and/or other materials provided with the distribution.
+ *     * Neither the name of Christian Johansen nor the names of his contributors
+ *       may be used to endorse or promote products derived from this software
+ *       without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+"use strict";
+var sinon = (function () {
+var buster = (function (buster, setTimeout) {
+    function extend(target) {
+        if (!target) {
+            return;
+        }
+
+        for (var i = 1, l = arguments.length, prop; i < l; ++i) {
+            for (prop in arguments[i]) {
+                target[prop] = arguments[i][prop];
+            }
+        }
+
+        return target;
+    }
+
+    var div = typeof document != "undefined" && document.createElement("div");
+
+    return extend(buster, {
+        bind: function (obj, methOrProp) {
+            var method = typeof methOrProp == "string" ? obj[methOrProp] : methOrProp;
+            var args = Array.prototype.slice.call(arguments, 2);
+
+            return function () {
+                var allArgs = args.concat(Array.prototype.slice.call(arguments));
+                return method.apply(obj, allArgs);
+            };
+        },
+
+        create: (function () {
+            function F() {}
+
+            return function create(object) {
+                F.prototype = object;
+                return new F();
+            }
+        }()),
+
+        extend: extend,
+
+        nextTick: function (callback) {
+            if (typeof process != "undefined" && process.nextTick) {
+                return process.nextTick(callback);
+            }
+
+            setTimeout(callback, 0);
+        },
+
+        functionName: function (func) {
+            if (!func) return "";
+            if (func.displayName) return func.displayName;
+            if (func.name) return func.name;
+
+            var matches = func.toString().match(/function\s+([^\(]+)/m);
+            return matches && matches[1] || "";
+        },
+
+        isNode: function (obj) {
+            if (!div) return false;
+
+            try {
+                obj.appendChild(div);
+                obj.removeChild(div);
+            } catch (e) {
+                return false;
+            }
+
+            return true;
+        },
+
+        isElement: function (obj) {
+            return obj && buster.isNode(obj) && obj.nodeType === 1;
+        }
+    });
+}(buster || {}, setTimeout));
+
+if (typeof module == "object" && typeof require == "function") {
+    module.exports = buster;
+    buster.eventEmitter = require("./buster-event-emitter");
+
+    Object.defineProperty(buster, "defineVersionGetter", {
+        get: function () {
+            return require("./define-version-getter");
+        }
+    });
+}
+if (typeof buster === "undefined") {
+    var buster = {};
+}
+
+if (typeof module === "object" && typeof require === "function") {
+    buster = require("buster-core");
+}
+
+buster.format = buster.format || {};
+buster.format.excludeConstructors = ["Object", /^.$/];
+buster.format.quoteStrings = true;
+
+buster.format.ascii = (function () {
+
+    function keys(object) {
+        var k = Object.keys && Object.keys(object) || [];
+
+        if (k.length == 0) {
+            for (var prop in object) {
+                if (object.hasOwnProperty(prop)) {
+                    k.push(prop);
+                }
+            }
+        }
+
+        return k.sort();
+    }
+
+    function isCircular(object, objects) {
+        if (typeof object != "object") {
+            return false;
+        }
+
+        for (var i = 0, l = objects.length; i < l; ++i) {
+            if (objects[i] === object) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    function ascii(object, processed, indent) {
+        if (typeof object == "string") {
+            var quote = typeof this.quoteStrings != "boolean" || this.quoteStrings;
+            return processed || quote ? '"' + object + '"' : object;
+        }
+
+        if (typeof object == "function" && !(object instanceof RegExp)) {
+            return ascii.func(object);
+        }
+
+        processed = processed || [];
+
+        if (isCircular(object, processed)) {
+            return "[Circular]";
+        }
+
+        if (Object.prototype.toString.call(object) == "[object Array]") {
+            return ascii.array.call(this, object);
+        }
+
+        if (!object) {
+            return "" + object;
+        }
+
+        if (buster.isElement(object)) {
+            return ascii.element(object);
+        }
+
+        if (typeof object.toString == "function" &&
+            object.toString !== Object.prototype.toString) {
+            return object.toString();
+        }
+
+        return ascii.object.call(this, object, processed, indent);
+    }
+
+    ascii.func = function (func) {
+        return "function " + buster.functionName(func) + "() {}";
+    };
+
+    ascii.array = function (array, processed) {
+        processed = processed || [];
+        processed.push(array);
+        var pieces = [];
+
+        for (var i = 0, l = array.length; i < l; ++i) {
+            pieces.push(ascii.call(this, array[i], processed));
+        }
+
+        return "[" + pieces.join(", ") + "]";
+    };
+
+    ascii.object = function (object, processed, indent) {
+        processed = processed || [];
+        processed.push(object);
+        indent = indent || 0;
+        var pieces = [], properties = keys(object), prop, str, obj;
+        var is = "";
+        var length = 3;
+
+        for (var i = 0, l = indent; i < l; ++i) {
+            is += " ";
+        }
+
+        for (i = 0, l = properties.length; i < l; ++i) {
+            prop = properties[i];
+            obj = object[prop];
+
+            if (isCircular(obj, processed)) {
+                str = "[Circular]";
+            } else {
+                str = ascii.call(this, obj, processed, indent + 2);
+            }
+
+            str = (/\s/.test(prop) ? '"' + prop + '"' : prop) + ": " + str;
+            length += str.length;
+            pieces.push(str);
+        }
+
+        var cons = ascii.constructorName.call(this, object);
+        var prefix = cons ? "[" + cons + "] " : ""
+
+        return (length + indent) > 80 ?
+            prefix + "{\n  " + is + pieces.join(",\n  " + is) + "\n" + is + "}" :
+            prefix + "{ " + pieces.join(", ") + " }";
+    };
+
+    ascii.element = function (element) {
+        var tagName = element.tagName.toLowerCase();
+        var attrs = element.attributes, attribute, pairs = [], attrName;
+
+        for (var i = 0, l = attrs.length; i < l; ++i) {
+            attribute = attrs.item(i);
+            attrName = attribute.nodeName.toLowerCase().replace("html:", "");
+
+            if (attrName == "contenteditable" && attribute.nodeValue == "inherit") {
+                continue;
+            }
+
+            if (!!attribute.nodeValue) {
+                pairs.push(attrName + "=\"" + attribute.nodeValue + "\"");
+            }
+        }
+
+        var formatted = "<" + tagName + (pairs.length > 0 ? " " : "");
+        var content = element.innerHTML;
+
+        if (content.length > 20) {
+            content = content.substr(0, 20) + "[...]";
+        }
+
+        var res = formatted + pairs.join(" ") + ">" + content + "</" + tagName + ">";
+
+        return res.replace(/ contentEditable="inherit"/, "");
+    };
+
+    ascii.constructorName = function (object) {
+        var name = buster.functionName(object && object.constructor);
+        var excludes = this.excludeConstructors || buster.format.excludeConstructors || [];
+
+        for (var i = 0, l = excludes.length; i < l; ++i) {
+            if (typeof excludes[i] == "string" && excludes[i] == name) {
+                return "";
+            } else if (excludes[i].test && excludes[i].test(name)) {
+                return "";
+            }
+        }
+
+        return name;
+    };
+
+    return ascii;
+}());
+
+if (typeof module != "undefined") {
+    module.exports = buster.format;
+}
+/*jslint eqeqeq: false, onevar: false, forin: true, nomen: false, regexp: false, plusplus: false*/
+/*global module, require, __dirname, document*/
+/**
+ * Sinon core utilities. For internal use only.
+ *
+ * @author Christian Johansen (christian@cjohansen.no)
+ * @license BSD
+ *
+ * Copyright (c) 2010-2011 Christian Johansen
+ */
+
+var sinon = (function (buster) {
+    var div = typeof document != "undefined" && document.createElement("div");
+    var hasOwn = Object.prototype.hasOwnProperty;
+
+    function isDOMNode(obj) {
+        var success = false;
+
+        try {
+            obj.appendChild(div);
+            success = div.parentNode == obj;
+        } catch (e) {
+            return false;
+        } finally {
+            try {
+                obj.removeChild(div);
+            } catch (e) {
+                // Remove failed, not much we can do about that
+            }
+        }
+
+        return success;
+    }
+
+    function isElement(obj) {
+        return div && obj && obj.nodeType === 1 && isDOMNode(obj);
+    }
+
+    function isFunction(obj) {
+        return !!(obj && obj.constructor && obj.call && obj.apply);
+    }
+
+    function mirrorProperties(target, source) {
+        for (var prop in source) {
+            if (!hasOwn.call(target, prop)) {
+                target[prop] = source[prop];
+            }
+        }
+    }
+
+    var sinon = {
+        wrapMethod: function wrapMethod(object, property, method) {
+            if (!object) {
+                throw new TypeError("Should wrap property of object");
+            }
+
+            if (typeof method != "function") {
+                throw new TypeError("Method wrapper should be function");
+            }
+
+            var wrappedMethod = object[property];
+
+            if (!isFunction(wrappedMethod)) {
+                throw new TypeError("Attempted to wrap " + (typeof wrappedMethod) + " property " +
+                                    property + " as function");
+            }
+
+            if (wrappedMethod.restore && wrappedMethod.restore.sinon) {
+                throw new TypeError("Attempted to wrap " + property + " which is already wrapped");
+            }
+
+            if (wrappedMethod.calledBefore) {
+                var verb = !!wrappedMethod.returns ? "stubbed" : "spied on";
+                throw new TypeError("Attempted to wrap " + property + " which is already " + verb);
+            }
+
+            // IE 8 does not support hasOwnProperty on the window object.
+            var owned = hasOwn.call(object, property);
+            object[property] = method;
+            method.displayName = property;
+
+            method.restore = function () {
+                if(owned) {
+                    object[property] = wrappedMethod;
+                } else {
+                    delete object[property];
+                }
+            };
+
+            method.restore.sinon = true;
+            mirrorProperties(method, wrappedMethod);
+
+            return method;
+        },
+
+        extend: function extend(target) {
+            for (var i = 1, l = arguments.length; i < l; i += 1) {
+                for (var prop in arguments[i]) {
+                    if (arguments[i].hasOwnProperty(prop)) {
+                        target[prop] = arguments[i][prop];
+                    }
+
+                    // DONT ENUM bug, only care about toString
+                    if (arguments[i].hasOwnProperty("toString") &&
+                        arguments[i].toString != target.toString) {
+                        target.toString = arguments[i].toString;
+                    }
+                }
+            }
+
+            return target;
+        },
+
+        create: function create(proto) {
+            var F = function () {};
+            F.prototype = proto;
+            return new F();
+        },
+
+        deepEqual: function deepEqual(a, b) {
+            if (typeof a != "object" || typeof b != "object") {
+                return a === b;
+            }
+
+            if (isElement(a) || isElement(b)) {
+                return a === b;
+            }
+
+            if (a === b) {
+                return true;
+            }
+
+            var aString = Object.prototype.toString.call(a);
+            if (aString != Object.prototype.toString.call(b)) {
+                return false;
+            }
+
+            if (aString == "[object Array]") {
+                if (a.length !== b.length) {
+                    return false;
+                }
+
+                for (var i = 0, l = a.length; i < l; i += 1) {
+                    if (!deepEqual(a[i], b[i])) {
+                        return false;
+                    }
+                }
+
+                return true;
+            }
+
+            var prop, aLength = 0, bLength = 0;
+
+            for (prop in a) {
+                aLength += 1;
+
+                if (!deepEqual(a[prop], b[prop])) {
+                    return false;
+                }
+            }
+
+            for (prop in b) {
+                bLength += 1;
+            }
+
+            if (aLength != bLength) {
+                return false;
+            }
+
+            return true;
+        },
+
+        functionName: function functionName(func) {
+            var name = func.displayName || func.name;
+
+            // Use function decomposition as a last resort to get function
+            // name. Does not rely on function decomposition to work - if it
+            // doesn't debugging will be slightly less informative
+            // (i.e. toString will say 'spy' rather than 'myFunc').
+            if (!name) {
+                var matches = func.toString().match(/function ([^\s\(]+)/);
+                name = matches && matches[1];
+            }
+
+            return name;
+        },
+
+        functionToString: function toString() {
+            if (this.getCall && this.callCount) {
+                var thisValue, prop, i = this.callCount;
+
+                while (i--) {
+                    thisValue = this.getCall(i).thisValue;
+
+                    for (prop in thisValue) {
+                        if (thisValue[prop] === this) {
+                            return prop;
+                        }
+                    }
+                }
+            }
+
+            return this.displayName || "sinon fake";
+        },
+
+        getConfig: function (custom) {
+            var config = {};
+            custom = custom || {};
+            var defaults = sinon.defaultConfig;
+
+            for (var prop in defaults) {
+                if (defaults.hasOwnProperty(prop)) {
+                    config[prop] = custom.hasOwnProperty(prop) ? custom[prop] : defaults[prop];
+                }
+            }
+
+            return config;
+        },
+
+        format: function (val) {
+            return "" + val;
+        },
+
+        defaultConfig: {
+            injectIntoThis: true,
+            injectInto: null,
+            properties: ["spy", "stub", "mock", "clock", "server", "requests"],
+            useFakeTimers: true,
+            useFakeServer: true
+        },
+
+        timesInWords: function timesInWords(count) {
+            return count == 1 && "once" ||
+                count == 2 && "twice" ||
+                count == 3 && "thrice" ||
+                (count || 0) + " times";
+        },
+
+        calledInOrder: function (spies) {
+            for (var i = 1, l = spies.length; i < l; i++) {
+                if (!spies[i - 1].calledBefore(spies[i])) {
+                    return false;
+                }
+            }
+
+            return true;
+        },
+
+        orderByFirstCall: function (spies) {
+            return spies.sort(function (a, b) {
+                // uuid, won't ever be equal
+                var aCall = a.getCall(0);
+                var bCall = b.getCall(0);
+                var aId = aCall && aCall.callId || -1;
+                var bId = bCall && bCall.callId || -1;
+
+                return aId < bId ? -1 : 1;
+            });
+        },
+
+        log: function () {},
+
+        logError: function (label, err) {
+            var msg = label + " threw exception: "
+            sinon.log(msg + "[" + err.name + "] " + err.message);
+            if (err.stack) { sinon.log(err.stack); }
+
+            setTimeout(function () {
+                err.message = msg + err.message;
+                throw err;
+            }, 0);
+        }
+    };
+
+    var isNode = typeof module == "object" && typeof require == "function";
+
+    if (isNode) {
+        try {
+            buster = { format: require("buster-format") };
+        } catch (e) {}
+        module.exports = sinon;
+        module.exports.spy = require("./sinon/spy");
+        module.exports.stub = require("./sinon/stub");
+        module.exports.mock = require("./sinon/mock");
+        module.exports.collection = require("./sinon/collection");
+        module.exports.assert = require("./sinon/assert");
+        module.exports.sandbox = require("./sinon/sandbox");
+        module.exports.test = require("./sinon/test");
+        module.exports.testCase = require("./sinon/test_case");
+        module.exports.assert = require("./sinon/assert");
+    }
+
+    if (buster) {
+        var formatter = sinon.create(buster.format);
+        formatter.quoteStrings = false;
+        sinon.format = function () {
+            return formatter.ascii.apply(formatter, arguments);
+        };
+    } else if (isNode) {
+        try {
+            var util = require("util");
+            sinon.format = function (value) {
+                return typeof value == "object" ? util.inspect(value) : value;
+            };
+        } catch (e) {
+            /* Node, but no util module - would be very old, but better safe than
+             sorry */
+        }
+    }
+
+    return sinon;
+}(typeof buster == "object" && buster));
+
+/* @depend ../sinon.js */
+/*jslint eqeqeq: false, onevar: false, plusplus: false*/
+/*global module, require, sinon*/
+/**
+ * Spy functions
+ *
+ * @author Christian Johansen (christian@cjohansen.no)
+ * @license BSD
+ *
+ * Copyright (c) 2010-2011 Christian Johansen
+ */
+
+(function (sinon) {
+    var commonJSModule = typeof module == "object" && typeof require == "function";
+    var spyCall;
+    var callId = 0;
+    var push = [].push;
+    var slice = Array.prototype.slice;
+
+    if (!sinon && commonJSModule) {
+        sinon = require("../sinon");
+    }
+
+    if (!sinon) {
+        return;
+    }
+
+    function spy(object, property) {
+        if (!property && typeof object == "function") {
+            return spy.create(object);
+        }
+
+        if (!object || !property) {
+            return spy.create(function () {});
+        }
+
+        var method = object[property];
+        return sinon.wrapMethod(object, property, spy.create(method));
+    }
+
+    sinon.extend(spy, (function () {
+
+        function delegateToCalls(api, method, matchAny, actual, notCalled) {
+            api[method] = function () {
+                if (!this.called) {
+                    if (notCalled) {
+                        return notCalled.apply(this, arguments);
+                    }
+                    return false;
+                }
+
+                var currentCall;
+                var matches = 0;
+
+                for (var i = 0, l = this.callCount; i < l; i += 1) {
+                    currentCall = this.getCall(i);
+
+                    if (currentCall[actual || method].apply(currentCall, arguments)) {
+                        matches += 1;
+
+                        if (matchAny) {
+                            return true;
+                        }
+                    }
+                }
+
+                return matches === this.callCount;
+            };
+        }
+
+        function matchingFake(fakes, args, strict) {
+            if (!fakes) {
+                return;
+            }
+
+            var alen = args.length;
+
+            for (var i = 0, l = fakes.length; i < l; i++) {
+                if (fakes[i].matches(args, strict)) {
+                    return fakes[i];
+                }
+            }
+        }
+
+        function incrementCallCount() {
+            this.called = true;
+            this.callCount += 1;
+            this.calledOnce = this.callCount == 1;
+            this.calledTwice = this.callCount == 2;
+            this.calledThrice = this.callCount == 3;
+        }
+
+        function createCallProperties() {
+            this.firstCall = this.getCall(0);
+            this.secondCall = this.getCall(1);
+            this.thirdCall = this.getCall(2);
+            this.lastCall = this.getCall(this.callCount - 1);
+        }
+
+        var uuid = 0;
+
+        // Public API
+        var spyApi = {
+            reset: function () {
+                this.called = false;
+                this.calledOnce = false;
+                this.calledTwice = false;
+                this.calledThrice = false;
+                this.callCount = 0;
+                this.firstCall = null;
+                this.secondCall = null;
+                this.thirdCall = null;
+                this.lastCall = null;
+                this.args = [];
+                this.returnValues = [];
+                this.thisValues = [];
+                this.exceptions = [];
+                this.callIds = [];
+            },
+
+            create: function create(func) {
+                var name;
+
+                if (typeof func != "function") {
+                    func = function () {};
+                } else {
+                    name = sinon.functionName(func);
+                }
+
+                function proxy() {
+                    return proxy.invoke(func, this, slice.call(arguments));
+                }
+
+                sinon.extend(proxy, spy);
+                delete proxy.create;
+                sinon.extend(proxy, func);
+
+                proxy.reset();
+                proxy.prototype = func.prototype;
+                proxy.displayName = name || "spy";
+                proxy.toString = sinon.functionToString;
+                proxy._create = sinon.spy.create;
+                proxy.id = "spy#" + uuid++;
+
+                return proxy;
+            },
+
+            invoke: function invoke(func, thisValue, args) {
+                var matching = matchingFake(this.fakes, args);
+                var exception, returnValue;
+
+                incrementCallCount.call(this);
+                push.call(this.thisValues, thisValue);
+                push.call(this.args, args);
+                push.call(this.callIds, callId++);
+
+                try {
+                    if (matching) {
+                        returnValue = matching.invoke(func, thisValue, args);
+                    } else {
+                        returnValue = (this.func || func).apply(thisValue, args);
+                    }
+                } catch (e) {
+                    push.call(this.returnValues, undefined);
+                    exception = e;
+                    throw e;
+                } finally {
+                    push.call(this.exceptions, exception);
+                }
+
+                push.call(this.returnValues, returnValue);
+
+                createCallProperties.call(this);
+
+                return returnValue;
+            },
+
+            getCall: function getCall(i) {
+                if (i < 0 || i >= this.callCount) {
+                    return null;
+                }
+
+                return spyCall.create(this, this.thisValues[i], this.args[i],
+                                      this.returnValues[i], this.exceptions[i],
+                                      this.callIds[i]);
+            },
+
+            calledBefore: function calledBefore(spyFn) {
+                if (!this.called) {
+                    return false;
+                }
+
+                if (!spyFn.called) {
+                    return true;
+                }
+
+                return this.callIds[0] < spyFn.callIds[spyFn.callIds.length - 1];
+            },
+
+            calledAfter: function calledAfter(spyFn) {
+                if (!this.called || !spyFn.called) {
+                    return false;
+                }
+
+                return this.callIds[this.callCount - 1] > spyFn.callIds[spyFn.callCount - 1];
+            },
+
+            withArgs: function () {
+                var args = slice.call(arguments);
+
+                if (this.fakes) {
+                    var match = matchingFake(this.fakes, args, true);
+
+                    if (match) {
+                        return match;
+                    }
+                } else {
+                    this.fakes = [];
+                }
+
+                var original = this;
+                var fake = this._create();
+                fake.matchingAguments = args;
+                push.call(this.fakes, fake);
+
+                fake.withArgs = function () {
+                    return original.withArgs.apply(original, arguments);
+                };
+
+                for (var i = 0; i < this.args.length; i++) {
+                    if (fake.matches(this.args[i])) {
+                        incrementCallCount.call(fake);
+                        push.call(fake.thisValues, this.thisValues[i]);
+                        push.call(fake.args, this.args[i]);
+                        push.call(fake.returnValues, this.returnValues[i]);
+                        push.call(fake.exceptions, this.exceptions[i]);
+                        push.call(fake.callIds, this.callIds[i]);
+                    }
+                }
+                createCallProperties.call(fake);
+
+                return fake;
+            },
+
+            matches: function (args, strict) {
+                var margs = this.matchingAguments;
+
+                if (margs.length <= args.length &&
+                    sinon.deepEqual(margs, args.slice(0, margs.length))) {
+                    return !strict || margs.length == args.length;
+                }
+            },
+
+            printf: function (format) {
+                var spy = this;
+                var args = slice.call(arguments, 1);
+                var formatter;
+
+                return (format || "").replace(/%(.)/g, function (match, specifyer) {
+                    formatter = spyApi.formatters[specifyer];
+
+                    if (typeof formatter == "function") {
+                        return formatter.call(null, spy, args);
+                    } else if (!isNaN(parseInt(specifyer), 10)) {
+                        return sinon.format(args[specifyer - 1]);
+                    }
+
+                    return "%" + specifyer;
+                });
+            }
+        };
+
+        delegateToCalls(spyApi, "calledOn", true);
+        delegateToCalls(spyApi, "alwaysCalledOn", false, "calledOn");
+        delegateToCalls(spyApi, "calledWith", true);
+        delegateToCalls(spyApi, "alwaysCalledWith", false, "calledWith");
+        delegateToCalls(spyApi, "calledWithExactly", true);
+        delegateToCalls(spyApi, "alwaysCalledWithExactly", false, "calledWithExactly");
+        delegateToCalls(spyApi, "neverCalledWith", false, "notCalledWith",
+            function () { return true; });
+        delegateToCalls(spyApi, "threw", true);
+        delegateToCalls(spyApi, "alwaysThrew", false, "threw");
+        delegateToCalls(spyApi, "returned", true);
+        delegateToCalls(spyApi, "alwaysReturned", false, "returned");
+        delegateToCalls(spyApi, "calledWithNew", true);
+        delegateToCalls(spyApi, "alwaysCalledWithNew", false, "calledWithNew");
+        delegateToCalls(spyApi, "callArg", false, "callArgWith", function () {
+            throw new Error(this.toString() + " cannot call arg since it was not yet invoked.");
+        });
+        spyApi.callArgWith = spyApi.callArg;
+        delegateToCalls(spyApi, "yield", false, "yield", function () {
+            throw new Error(this.toString() + " cannot yield since it was not yet invoked.");
+        });
+        // "invokeCallback" is an alias for "yield" since "yield" is invalid in strict mode.
+        spyApi.invokeCallback = spyApi.yield;
+        delegateToCalls(spyApi, "yieldTo", false, "yieldTo", function (property) {
+            throw new Error(this.toString() + " cannot yield to '" + property +
+                "' since it was not yet invoked.");
+        });
+
+        spyApi.formatters = {
+            "c": function (spy) {
+                return sinon.timesInWords(spy.callCount);
+            },
+
+            "n": function (spy) {
+                return spy.toString();
+            },
+
+            "C": function (spy) {
+                var calls = [];
+
+                for (var i = 0, l = spy.callCount; i < l; ++i) {
+                    push.call(calls, "    " + spy.getCall(i).toString());
+                }
+
+                return calls.length > 0 ? "\n" + calls.join("\n") : "";
+            },
+
+            "t": function (spy) {
+                var objects = [];
+
+                for (var i = 0, l = spy.callCount; i < l; ++i) {
+                    push.call(objects, sinon.format(spy.thisValues[i]));
+                }
+
+                return objects.join(", ");
+            },
+
+            "*": function (spy, args) {
+                return args.join(", ");
+            }
+        };
+
+        return spyApi;
+    }()));
+
+    spyCall = (function () {
+
+        function throwYieldError(proxy, text, args) {
+            var msg = sinon.functionName(proxy) + text;
+            if (args.length) {
+                msg += " Received [" + slice.call(args).join(", ") + "]";
+            }
+            throw new Error(msg);
+        }
+
+        return {
+            create: function create(spy, thisValue, args, returnValue, exception, id) {
+                var proxyCall = sinon.create(spyCall);
+                delete proxyCall.create;
+                proxyCall.proxy = spy;
+                proxyCall.thisValue = thisValue;
+                proxyCall.args = args;
+                proxyCall.returnValue = returnValue;
+                proxyCall.exception = exception;
+                proxyCall.callId = typeof id == "number" && id || callId++;
+
+                return proxyCall;
+            },
+
+            calledOn: function calledOn(thisValue) {
+                return this.thisValue === thisValue;
+            },
+
+            calledWith: function calledWith() {
+                for (var i = 0, l = arguments.length; i < l; i += 1) {
+                    if (!sinon.deepEqual(arguments[i], this.args[i])) {
+                        return false;
+                    }
+                }
+
+                return true;
+            },
+
+            calledWithExactly: function calledWithExactly() {
+                return arguments.length == this.args.length &&
+                    this.calledWith.apply(this, arguments);
+            },
+
+            notCalledWith: function notCalledWith() {
+                for (var i = 0, l = arguments.length; i < l; i += 1) {
+                    if (!sinon.deepEqual(arguments[i], this.args[i])) {
+                        return true;
+                    }
+                }
+                return false;
+            },
+
+            returned: function returned(value) {
+                return this.returnValue === value;
+            },
+
+            threw: function threw(error) {
+                if (typeof error == "undefined" || !this.exception) {
+                    return !!this.exception;
+                }
+
+                if (typeof error == "string") {
+                    return this.exception.name == error;
+                }
+
+                return this.exception === error;
+            },
+
+            calledWithNew: function calledWithNew(thisValue) {
+                return this.thisValue instanceof this.proxy;
+            },
+
+            calledBefore: function (other) {
+                return this.callId < other.callId;
+            },
+
+            calledAfter: function (other) {
+                return this.callId > other.callId;
+            },
+
+            callArg: function (pos) {
+                this.args[pos]();
+            },
+
+            callArgWith: function (pos) {
+                var args = slice.call(arguments, 1);
+                this.args[pos].apply(null, args);
+            },
+
+            "yield": function () {
+                var args = this.args;
+                for (var i = 0, l = args.length; i < l; ++i) {
+                    if (typeof args[i] === "function") {
+                        args[i].apply(null, slice.call(arguments));
+                        return;
+                    }
+                }
+                throwYieldError(this.proxy, " cannot yield since no callback was passed.", args);
+            },
+
+            yieldTo: function (prop) {
+                var args = this.args;
+                for (var i = 0, l = args.length; i < l; ++i) {
+                    if (args[i] && typeof args[i][prop] === "function") {
+                        args[i][prop].apply(null, slice.call(arguments, 1));
+                        return;
+                    }
+                }
+                throwYieldError(this.proxy, " cannot yield to '" + prop +
+                    "' since no callback was passed.", args);
+            },
+
+            toString: function () {
+                var callStr = this.proxy.toString() + "(";
+                var args = [];
+
+                for (var i = 0, l = this.args.length; i < l; ++i) {
+                    push.call(args, sinon.format(this.args[i]));
+                }
+
+                callStr = callStr + args.join(", ") + ")";
+
+                if (typeof this.returnValue != "undefined") {
+                    callStr += " => " + sinon.format(this.returnValue);
+                }
+
+                if (this.exception) {
+                    callStr += " !" + this.exception.name;
+
+                    if (this.exception.message) {
+                        callStr += "(" + this.exception.message + ")";
+                    }
+                }
+
+                return callStr;
+            }
+        };
+    }());
+
+    spy.spyCall = spyCall;
+
+    // This steps outside the module sandbox and will be removed
+    sinon.spyCall = spyCall;
+
+    if (commonJSModule) {
+        module.exports = spy;
+    } else {
+        sinon.spy = spy;
+    }
+}(typeof sinon == "object" && sinon || null));
+
+/**
+ * @depend ../sinon.js
+ * @depend spy.js
+ */
+/*jslint eqeqeq: false, onevar: false*/
+/*global module, require, sinon*/
+/**
+ * Stub functions
+ *
+ * @author Christian Johansen (christian@cjohansen.no)
+ * @license BSD
+ *
+ * Copyright (c) 2010-2011 Christian Johansen
+ */
+
+(function (sinon) {
+    var commonJSModule = typeof module == "object" && typeof require == "function";
+
+    if (!sinon && commonJSModule) {
+        sinon = require("../sinon");
+    }
+
+    if (!sinon) {
+        return;
+    }
+
+    function stub(object, property, func) {
+        if (!!func && typeof func != "function") {
+            throw new TypeError("Custom stub should be function");
+        }
+
+        var wrapper;
+
+        if (func) {
+            wrapper = sinon.spy && sinon.spy.create ? sinon.spy.create(func) : func;
+        } else {
+            wrapper = stub.create();
+        }
+
+        if (!object && !property) {
+            return sinon.stub.create();
+        }
+
+        if (!property && !!object && typeof object == "object") {
+            for (var prop in object) {
+                if (typeof object[prop] === "function") {
+                    stub(object, prop);
+                }
+            }
+
+            return object;
+        }
+
+        return sinon.wrapMethod(object, property, wrapper);
+    }
+
+    function getCallback(stub, args) {
+        if (stub.callArgAt < 0) {
+            for (var i = 0, l = args.length; i < l; ++i) {
+                if (!stub.callArgProp && typeof args[i] == "function") {
+                    return args[i];
+                }
+
+                if (stub.callArgProp && args[i] &&
+                    typeof args[i][stub.callArgProp] == "function") {
+                    return args[i][stub.callArgProp];
+                }
+            }
+
+            return null;
+        }
+
+        return args[stub.callArgAt];
+    }
+
+    var join = Array.prototype.join;
+
+    function getCallbackError(stub, func, args) {
+        if (stub.callArgAt < 0) {
+            var msg;
+
+            if (stub.callArgProp) {
+                msg = sinon.functionName(stub) +
+                    " expected to yield to '" + stub.callArgProp +
+                    "', but no object with such a property was passed."
+            } else {
+                msg = sinon.functionName(stub) +
+                            " expected to yield, but no callback was passed."
+            }
+
+            if (args.length > 0) {
+                msg += " Received [" + join.call(args, ", ") + "]";
+            }
+
+            return msg;
+        }
+
+        return "argument at index " + stub.callArgAt + " is not a function: " + func;
+    }
+
+    function callCallback(stub, args) {
+        if (typeof stub.callArgAt == "number") {
+            var func = getCallback(stub, args);
+
+            if (typeof func != "function") {
+                throw new TypeError(getCallbackError(stub, func, args));
+            }
+
+            func.apply(stub.callbackContext, stub.callbackArguments);
+        }
+    }
+
+    var uuid = 0;
+
+    sinon.extend(stub, (function () {
+        var slice = Array.prototype.slice;
+
+        function throwsException(error, message) {
+            if (typeof error == "string") {
+                this.exception = new Error(message || "");
+                this.exception.name = error;
+            } else if (!error) {
+                this.exception = new Error("Error");
+            } else {
+                this.exception = error;
+            }
+
+            return this;
+        }
+
+        return {
+            create: function create() {
+                var functionStub = function () {
+                    if (functionStub.exception) {
+                        throw functionStub.exception;
+                    } else if (typeof functionStub.returnArgAt == 'number') {
+                        return arguments[functionStub.returnArgAt];
+                    }
+
+                    callCallback(functionStub, arguments);
+
+                    return functionStub.returnValue;
+                };
+
+                functionStub.id = "stub#" + uuid++;
+                var orig = functionStub;
+                functionStub = sinon.spy.create(functionStub);
+                functionStub.func = orig;
+
+                sinon.extend(functionStub, stub);
+                functionStub._create = sinon.stub.create;
+                functionStub.displayName = "stub";
+                functionStub.toString = sinon.functionToString;
+
+                return functionStub;
+            },
+
+            returns: function returns(value) {
+                this.returnValue = value;
+
+                return this;
+            },
+
+            returnsArg: function returnsArg(pos) {
+                if (typeof pos != "number") {
+                    throw new TypeError("argument index is not number");
+                }
+
+                this.returnArgAt = pos;
+
+                return this;
+            },
+
+            "throws": throwsException,
+            throwsException: throwsException,
+
+            callsArg: function callsArg(pos) {
+                if (typeof pos != "number") {
+                    throw new TypeError("argument index is not number");
+                }
+
+                this.callArgAt = pos;
+                this.callbackArguments = [];
+
+                return this;
+            },
+
+            callsArgOn: function callsArgOn(pos, context) {
+                if (typeof pos != "number") {
+                    throw new TypeError("argument index is not number");
+                }
+                if (typeof context != "object") {
+                    throw new TypeError("argument context is not an object");
+                }
+
+                this.callArgAt = pos;
+                this.callbackArguments = [];
+                this.callbackContext = context;
+
+                return this;
+            },
+
+            callsArgWith: function callsArgWith(pos) {
+                if (typeof pos != "number") {
+                    throw new TypeError("argument index is not number");
+                }
+
+                this.callArgAt = pos;
+                this.callbackArguments = slice.call(arguments, 1);
+
+                return this;
+            },
+
+            callsArgOnWith: function callsArgWith(pos, context) {
+                if (typeof pos != "number") {
+                    throw new TypeError("argument index is not number");
+                }
+                if (typeof context != "object") {
+                    throw new TypeError("argument context is not an object");
+                }
+
+                this.callArgAt = pos;
+                this.callbackArguments = slice.call(arguments, 2);
+                this.callbackContext = context;
+
+                return this;
+            },
+
+            yields: function () {
+                this.callArgAt = -1;
+                this.callbackArguments = slice.call(arguments, 0);
+
+                return this;
+            },
+
+            yieldsOn: function (context) {
+                if (typeof context != "object") {
+                    throw new TypeError("argument context is not an object");
+                }
+
+                this.callArgAt = -1;
+                this.callbackArguments = slice.call(arguments, 1);
+                this.callbackContext = context;
+
+                return this;
+            },
+
+            yieldsTo: function (prop) {
+                this.callArgAt = -1;
+                this.callArgProp = prop;
+                this.callbackArguments = slice.call(arguments, 1);
+
+                return this;
+            },
+
+            yieldsToOn: function (prop, context) {
+                if (typeof context != "object") {
+                    throw new TypeError("argument context is not an object");
+                }
+
+                this.callArgAt = -1;
+                this.callArgProp = prop;
+                this.callbackArguments = slice.call(arguments, 2);
+                this.callbackContext = context;
+
+                return this;
+            }
+        };
+    }()));
+
+    if (commonJSModule) {
+        module.exports = stub;
+    } else {
+        sinon.stub = stub;
+    }
+}(typeof sinon == "object" && sinon || null));
+
+/**
+ * @depend ../sinon.js
+ * @depend stub.js
+ */
+/*jslint eqeqeq: false, onevar: false, nomen: false*/
+/*global module, require, sinon*/
+/**
+ * Mock functions.
+ *
+ * @author Christian Johansen (christian@cjohansen.no)
+ * @license BSD
+ *
+ * Copyright (c) 2010-2011 Christian Johansen
+ */
+
+(function (sinon) {
+    var commonJSModule = typeof module == "object" && typeof require == "function";
+    var push = [].push;
+
+    if (!sinon && commonJSModule) {
+        sinon = require("../sinon");
+    }
+
+    if (!sinon) {
+        return;
+    }
+
+    function mock(object) {
+        if (!object) {
+            return sinon.expectation.create("Anonymous mock");
+        }
+
+        return mock.create(object);
+    }
+
+    sinon.mock = mock;
+
+    sinon.extend(mock, (function () {
+        function each(collection, callback) {
+            if (!collection) {
+                return;
+            }
+
+            for (var i = 0, l = collection.length; i < l; i += 1) {
+                callback(collection[i]);
+            }
+        }
+
+        return {
+            create: function create(object) {
+                if (!object) {
+                    throw new TypeError("object is null");
+                }
+
+                var mockObject = sinon.extend({}, mock);
+                mockObject.object = object;
+                delete mockObject.create;
+
+                return mockObject;
+            },
+
+            expects: function expects(method) {
+                if (!method) {
+                    throw new TypeError("method is falsy");
+                }
+
+                if (!this.expectations) {
+                    this.expectations = {};
+                    this.proxies = [];
+                }
+
+                if (!this.expectations[method]) {
+                    this.expectations[method] = [];
+                    var mockObject = this;
+
+                    sinon.wrapMethod(this.object, method, function () {
+                        return mockObject.invokeMethod(method, this, arguments);
+                    });
+
+                    push.call(this.proxies, method);
+                }
+
+                var expectation = sinon.expectation.create(method);
+                push.call(this.expectations[method], expectation);
+
+                return expectation;
+            },
+
+            restore: function restore() {
+                var object = this.object;
+
+                each(this.proxies, function (proxy) {
+                    if (typeof object[proxy].restore == "function") {
+                        object[proxy].restore();
+                    }
+                });
+            },
+
+            verify: function verify() {
+                var expectations = this.expectations || {};
+                var messages = [], met = [];
+
+                each(this.proxies, function (proxy) {
+                    each(expectations[proxy], function (expectation) {
+                        if (!expectation.met()) {
+                            push.call(messages, expectation.toString());
+                        } else {
+                            push.call(met, expectation.toString());
+                        }
+                    });
+                });
+
+                this.restore();
+
+                if (messages.length > 0) {
+                    sinon.expectation.fail(messages.concat(met).join("\n"));
+                }
+
+                return true;
+            },
+
+            invokeMethod: function invokeMethod(method, thisValue, args) {
+                var expectations = this.expectations && this.expectations[method];
+                var length = expectations && expectations.length || 0;
+
+                for (var i = 0; i < length; i += 1) {
+                    if (!expectations[i].met() &&
+                        expectations[i].allowsCall(thisValue, args)) {
+                        return expectations[i].apply(thisValue, args);
+                    }
+                }
+
+                var messages = [];
+
+                for (i = 0; i < length; i += 1) {
+                    push.call(messages, "    " + expectations[i].toString());
+                }
+
+                messages.unshift("Unexpected call: " + sinon.spyCall.toString.call({
+                    proxy: method,
+                    args: args
+                }));
+
+                sinon.expectation.fail(messages.join("\n"));
+            }
+        };
+    }()));
+
+    var times = sinon.timesInWords;
+
+    sinon.expectation = (function () {
+        var slice = Array.prototype.slice;
+        var _invoke = sinon.spy.invoke;
+
+        function callCountInWords(callCount) {
+            if (callCount == 0) {
+                return "never called";
+            } else {
+                return "called " + times(callCount);
+            }
+        }
+
+        function expectedCallCountInWords(expectation) {
+            var min = expectation.minCalls;
+            var max = expectation.maxCalls;
+
+            if (typeof min == "number" && typeof max == "number") {
+                var str = times(min);
+
+                if (min != max) {
+                    str = "at least " + str + " and at most " + times(max);
+                }
+
+                return str;
+            }
+
+            if (typeof min == "number") {
+                return "at least " + times(min);
+            }
+
+            return "at most " + times(max);
+        }
+
+        function receivedMinCalls(expectation) {
+            var hasMinLimit = typeof expectation.minCalls == "number";
+            return !hasMinLimit || expectation.callCount >= expectation.minCalls;
+        }
+
+        function receivedMaxCalls(expectation) {
+            if (typeof expectation.maxCalls != "number") {
+                return false;
+            }
+
+            return expectation.callCount == expectation.maxCalls;
+        }
+
+        return {
+            minCalls: 1,
+            maxCalls: 1,
+
+            create: function create(methodName) {
+                var expectation = sinon.extend(sinon.stub.create(), sinon.expectation);
+                delete expectation.create;
+                expectation.method = methodName;
+
+                return expectation;
+            },
+
+            invoke: function invoke(func, thisValue, args) {
+                this.verifyCallAllowed(thisValue, args);
+
+                return _invoke.apply(this, arguments);
+            },
+
+            atLeast: function atLeast(num) {
+                if (typeof num != "number") {
+                    throw new TypeError("'" + num + "' is not number");
+                }
+
+                if (!this.limitsSet) {
+                    this.maxCalls = null;
+                    this.limitsSet = true;
+                }
+
+                this.minCalls = num;
+
+                return this;
+            },
+
+            atMost: function atMost(num) {
+                if (typeof num != "number") {
+                    throw new TypeError("'" + num + "' is not number");
+                }
+
+                if (!this.limitsSet) {
+                    this.minCalls = null;
+                    this.limitsSet = true;
+                }
+
+                this.maxCalls = num;
+
+                return this;
+            },
+
+            never: function never() {
+                return this.exactly(0);
+            },
+
+            once: function once() {
+                return this.exactly(1);
+            },
+
+            twice: function twice() {
+                return this.exactly(2);
+            },
+
+            thrice: function thrice() {
+                return this.exactly(3);
+            },
+
+            exactly: function exactly(num) {
+                if (typeof num != "number") {
+                    throw new TypeError("'" + num + "' is not a number");
+                }
+
+                this.atLeast(num);
+                return this.atMost(num);
+            },
+
+            met: function met() {
+                return !this.failed && receivedMinCalls(this);
+            },
+
+            verifyCallAllowed: function verifyCallAllowed(thisValue, args) {
+                if (receivedMaxCalls(this)) {
+                    this.failed = true;
+                    sinon.expectation.fail(this.method + " already called " + times(this.maxCalls));
+                }
+
+                if ("expectedThis" in this && this.expectedThis !== thisValue) {
+                    sinon.expectation.fail(this.method + " called with " + thisValue + " as thisValue, expected " +
+                        this.expectedThis);
+                }
+
+                if (!("expectedArguments" in this)) {
+                    return;
+                }
+
+                if (!args || args.length === 0) {
+                    sinon.expectation.fail(this.method + " received no arguments, expected " +
+                        this.expectedArguments.join());
+                }
+
+                if (args.length < this.expectedArguments.length) {
+                    sinon.expectation.fail(this.method + " received too few arguments (" + args.join() +
+                        "), expected " + this.expectedArguments.join());
+                }
+
+                if (this.expectsExactArgCount &&
+                    args.length != this.expectedArguments.length) {
+                    sinon.expectation.fail(this.method + " received too many arguments (" + args.join() +
+                        "), expected " + this.expectedArguments.join());
+                }
+
+                for (var i = 0, l = this.expectedArguments.length; i < l; i += 1) {
+                    if (!sinon.deepEqual(this.expectedArguments[i], args[i])) {
+                        sinon.expectation.fail(this.method + " received wrong arguments (" + args.join() +
+                            "), expected " + this.expectedArguments.join());
+                    }
+                }
+            },
+
+            allowsCall: function allowsCall(thisValue, args) {
+                if (this.met()) {
+                    return false;
+                }
+
+                if ("expectedThis" in this && this.expectedThis !== thisValue) {
+                    return false;
+                }
+
+                if (!("expectedArguments" in this)) {
+                    return true;
+                }
+
+                args = args || [];
+
+                if (args.length < this.expectedArguments.length) {
+                    return false;
+                }
+
+                if (this.expectsExactArgCount &&
+                    args.length != this.expectedArguments.length) {
+                    return false;
+                }
+
+                for (var i = 0, l = this.expectedArguments.length; i < l; i += 1) {
+                    if (!sinon.deepEqual(this.expectedArguments[i], args[i])) {
+                        return false;
+                    }
+                }
+
+                return true;
+            },
+
+            withArgs: function withArgs() {
+                this.expectedArguments = slice.call(arguments);
+                return this;
+            },
+
+            withExactArgs: function withExactArgs() {
+                this.withArgs.apply(this, arguments);
+                this.expectsExactArgCount = true;
+                return this;
+            },
+
+            on: function on(thisValue) {
+                this.expectedThis = thisValue;
+                return this;
+            },
+
+            toString: function () {
+                var args = (this.expectedArguments || []).slice();
+
+                if (!this.expectsExactArgCount) {
+                    push.call(args, "[...]");
+                }
+
+                var callStr = sinon.spyCall.toString.call({
+                    proxy: this.method, args: args
+                });
+
+                var message = callStr.replace(", [...", "[, ...") + " " +
+                    expectedCallCountInWords(this);
+
+                if (this.met()) {
+                    return "Expectation met: " + message;
+                }
+
+                return "Expected " + message + " (" +
+                    callCountInWords(this.callCount) + ")";
+            },
+
+            verify: function verify() {
+                if (!this.met()) {
+                    sinon.expectation.fail(this.toString());
+                }
+
+                return true;
+            },
+
+            fail: function (message) {
+                var exception = new Error(message);
+                exception.name = "ExpectationError";
+
+                throw exception;
+            }
+        };
+    }());
+
+    if (commonJSModule) {
+        module.exports = mock;
+    } else {
+        sinon.mock = mock;
+    }
+}(typeof sinon == "object" && sinon || null));
+
+/**
+ * @depend ../sinon.js
+ * @depend stub.js
+ * @depend mock.js
+ */
+/*jslint eqeqeq: false, onevar: false, forin: true*/
+/*global module, require, sinon*/
+/**
+ * Collections of stubs, spies and mocks.
+ *
+ * @author Christian Johansen (christian@cjohansen.no)
+ * @license BSD
+ *
+ * Copyright (c) 2010-2011 Christian Johansen
+ */
+
+(function (sinon) {
+    var commonJSModule = typeof module == "object" && typeof require == "function";
+    var push = [].push;
+
+    if (!sinon && commonJSModule) {
+        sinon = require("../sinon");
+    }
+
+    if (!sinon) {
+        return;
+    }
+
+    function getFakes(fakeCollection) {
+        if (!fakeCollection.fakes) {
+            fakeCollection.fakes = [];
+        }
+
+        return fakeCollection.fakes;
+    }
+
+    function each(fakeCollection, method) {
+        var fakes = getFakes(fakeCollection);
+
+        for (var i = 0, l = fakes.length; i < l; i += 1) {
+            if (typeof fakes[i][method] == "function") {
+                fakes[i][method]();
+            }
+        }
+    }
+
+    function compact(fakeCollection) {
+        var fakes = getFakes(fakeCollection);
+        var i = 0;
+        while (i < fakes.length) {
+          fakes.splice(i, 1);
+        }
+    }
+
+    var collection = {
+        verify: function resolve() {
+            each(this, "verify");
+        },
+
+        restore: function restore() {
+            each(this, "restore");
+            compact(this);
+        },
+
+        verifyAndRestore: function verifyAndRestore() {
+            var exception;
+
+            try {
+                this.verify();
+            } catch (e) {
+                exception = e;
+            }
+
+            this.restore();
+
+            if (exception) {
+                throw exception;
+            }
+        },
+
+        add: function add(fake) {
+            push.call(getFakes(this), fake);
+            return fake;
+        },
+
+        spy: function spy() {
+            return this.add(sinon.spy.apply(sinon, arguments));
+        },
+
+        stub: function stub(object, property, value) {
+            if (property) {
+                var original = object[property];
+
+                if (typeof original != "function") {
+                    if (!object.hasOwnProperty(property)) {
+                        throw new TypeError("Cannot stub non-existent own property " + property);
+                    }
+
+                    object[property] = value;
+
+                    return this.add({
+                        restore: function () {
+                            object[property] = original;
+                        }
+                    });
+                }
+            }
+
+            return this.add(sinon.stub.apply(sinon, arguments));
+        },
+
+        mock: function mock() {
+            return this.add(sinon.mock.apply(sinon, arguments));
+        },
+
+        inject: function inject(obj) {
+            var col = this;
+
+            obj.spy = function () {
+                return col.spy.apply(col, arguments);
+            };
+
+            obj.stub = function () {
+                return col.stub.apply(col, arguments);
+            };
+
+            obj.mock = function () {
+                return col.mock.apply(col, arguments);
+            };
+
+            return obj;
+        }
+    };
+
+    if (commonJSModule) {
+        module.exports = collection;
+    } else {
+        sinon.collection = collection;
+    }
+}(typeof sinon == "object" && sinon || null));
+
+/*jslint eqeqeq: false, plusplus: false, evil: true, onevar: false, browser: true, forin: false*/
+/*global module, require, window*/
+/**
+ * Fake timer API
+ * setTimeout
+ * setInterval
+ * clearTimeout
+ * clearInterval
+ * tick
+ * reset
+ * Date
+ *
+ * Inspired by jsUnitMockTimeOut from JsUnit
+ *
+ * @author Christian Johansen (christian@cjohansen.no)
+ * @license BSD
+ *
+ * Copyright (c) 2010-2011 Christian Johansen
+ */
+
+if (typeof sinon == "undefined") {
+    var sinon = {};
+}
+
+(function (global) {
+    var id = 1;
+
+    function addTimer(args, recurring) {
+        if (args.length === 0) {
+            throw new Error("Function requires at least 1 parameter");
+        }
+
+        var toId = id++;
+        var delay = args[1] || 0;
+
+        if (!this.timeouts) {
+            this.timeouts = {};
+        }
+
+        this.timeouts[toId] = {
+            id: toId,
+            func: args[0],
+            callAt: this.now + delay
+        };
+
+        if (recurring === true) {
+            this.timeouts[toId].interval = delay;
+        }
+
+        return toId;
+    }
+
+    function parseTime(str) {
+        if (!str) {
+            return 0;
+        }
+
+        var strings = str.split(":");
+        var l = strings.length, i = l;
+        var ms = 0, parsed;
+
+        if (l > 3 || !/^(\d\d:){0,2}\d\d?$/.test(str)) {
+            throw new Error("tick only understands numbers and 'h:m:s'");
+        }
+
+        while (i--) {
+            parsed = parseInt(strings[i], 10);
+
+            if (parsed >= 60) {
+                throw new Error("Invalid time " + str);
+            }
+
+            ms += parsed * Math.pow(60, (l - i - 1));
+        }
+
+        return ms * 1000;
+    }
+
+    function createObject(object) {
+        var newObject;
+
+        if (Object.create) {
+            newObject = Object.create(object);
+        } else {
+            var F = function () {};
+            F.prototype = object;
+            newObject = new F();
+        }
+
+        newObject.Date.clock = newObject;
+        return newObject;
+    }
+
+    sinon.clock = {
+        now: 0,
+
+        create: function create(now) {
+            var clock = createObject(this);
+
+            if (typeof now == "number") {
+                clock.now = now;
+            }
+
+            if (!!now && typeof now == "object") {
+                throw new TypeError("now should be milliseconds since UNIX epoch");
+            }
+
+            return clock;
+        },
+
+        setTimeout: function setTimeout(callback, timeout) {
+            return addTimer.call(this, arguments, false);
+        },
+
+        clearTimeout: function clearTimeout(timerId) {
+            if (!this.timeouts) {
+                this.timeouts = [];
+            }
+
+            if (timerId in this.timeouts) {
+                delete this.timeouts[timerId];
+            }
+        },
+
+        setInterval: function setInterval(callback, timeout) {
+            return addTimer.call(this, arguments, true);
+        },
+
+        clearInterval: function clearInterval(timerId) {
+            this.clearTimeout(timerId);
+        },
+
+        tick: function tick(ms) {
+            ms = typeof ms == "number" ? ms : parseTime(ms);
+            var tickFrom = this.now, tickTo = this.now + ms, previous = this.now;
+            var timer = this.firstTimerInRange(tickFrom, tickTo);
+
+            var firstException;
+            while (timer && tickFrom <= tickTo) {
+                if (this.timeouts[timer.id]) {
+                    tickFrom = this.now = timer.callAt;
+                    try {
+                      this.callTimer(timer);
+                    } catch (e) {
+                      firstException = firstException || e;
+                    }
+                }
+
+                timer = this.firstTimerInRange(previous, tickTo);
+                previous = tickFrom;
+            }
+
+            this.now = tickTo;
+
+            if (firstException) {
+              throw firstException;
+            }
+        },
+
+        firstTimerInRange: function (from, to) {
+            var timer, smallest, originalTimer;
+
+            for (var id in this.timeouts) {
+                if (this.timeouts.hasOwnProperty(id)) {
+                    if (this.timeouts[id].callAt < from || this.timeouts[id].callAt > to) {
+                        continue;
+                    }
+
+                    if (!smallest || this.timeouts[id].callAt < smallest) {
+                        originalTimer = this.timeouts[id];
+                        smallest = this.timeouts[id].callAt;
+
+                        timer = {
+                            func: this.timeouts[id].func,
+                            callAt: this.timeouts[id].callAt,
+                            interval: this.timeouts[id].interval,
+                            id: this.timeouts[id].id
+                        };
+                    }
+                }
+            }
+
+            return timer || null;
+        },
+
+        callTimer: function (timer) {
+            try {
+                if (typeof timer.func == "function") {
+                    timer.func.call(null);
+                } else {
+                    eval(timer.func);
+                }
+            } catch (e) {
+              var exception = e;
+            }
+
+            if (!this.timeouts[timer.id]) {
+                if (exception) {
+                  throw exception;
+                }
+                return;
+            }
+
+            if (typeof timer.interval == "number") {
+                this.timeouts[timer.id].callAt += timer.interval;
+            } else {
+                delete this.timeouts[timer.id];
+            }
+
+            if (exception) {
+              throw exception;
+            }
+        },
+
+        reset: function reset() {
+            this.timeouts = {};
+        },
+
+        Date: (function () {
+            var NativeDate = Date;
+
+            function ClockDate(year, month, date, hour, minute, second, ms) {
+                // Defensive and verbose to avoid potential harm in passing
+                // explicit undefined when user does not pass argument
+                switch (arguments.length) {
+                case 0:
+                    return new NativeDate(ClockDate.clock.now);
+                case 1:
+                    return new NativeDate(year);
+                case 2:
+                    return new NativeDate(year, month);
+                case 3:
+                    return new NativeDate(year, month, date);
+                case 4:
+                    return new NativeDate(year, month, date, hour);
+                case 5:
+                    return new NativeDate(year, month, date, hour, minute);
+                case 6:
+                    return new NativeDate(year, month, date, hour, minute, second);
+                default:
+                    return new NativeDate(year, month, date, hour, minute, second, ms);
+                }
+            }
+
+            return mirrorDateProperties(ClockDate, NativeDate);
+        }())
+    };
+
+    function mirrorDateProperties(target, source) {
+        if (source.now) {
+            target.now = function now() {
+                return target.clock.now;
+            };
+        } else {
+            delete target.now;
+        }
+
+        if (source.toSource) {
+            target.toSource = function toSource() {
+                return source.toSource();
+            };
+        } else {
+            delete target.toSource;
+        }
+
+        target.toString = function toString() {
+            return source.toString();
+        };
+
+        target.prototype = source.prototype;
+        target.parse = source.parse;
+        target.UTC = source.UTC;
+        target.prototype.toUTCString = source.prototype.toUTCString;
+        return target;
+    }
+
+    var methods = ["Date", "setTimeout", "setInterval",
+                   "clearTimeout", "clearInterval"];
+
+    function restore() {
+        var method;
+
+        for (var i = 0, l = this.methods.length; i < l; i++) {
+            method = this.methods[i];
+            global[method] = this["_" + method];
+        }
+    }
+
+    function stubGlobal(method, clock) {
+        clock["_" + method] = global[method];
+
+        if (method == "Date") {
+            var date = mirrorDateProperties(clock[method], global[method]);
+            global[method] = date;
+        } else {
+            global[method] = function () {
+                return clock[method].apply(clock, arguments);
+            };
+
+            for (var prop in clock[method]) {
+                if (clock[method].hasOwnProperty(prop)) {
+                    global[method][prop] = clock[method][prop];
+                }
+            }
+        }
+
+        global[method].clock = clock;
+    }
+
+    sinon.useFakeTimers = function useFakeTimers(now) {
+        var clock = sinon.clock.create(now);
+        clock.restore = restore;
+        clock.methods = Array.prototype.slice.call(arguments,
+                                                   typeof now == "number" ? 1 : 0);
+
+        if (clock.methods.length === 0) {
+            clock.methods = methods;
+        }
+
+        for (var i = 0, l = clock.methods.length; i < l; i++) {
+            stubGlobal(clock.methods[i], clock);
+        }
+
+        return clock;
+    };
+}(typeof global != "undefined" && typeof global !== "function" ? global : this));
+
+sinon.timers = {
+    setTimeout: setTimeout,
+    clearTimeout: clearTimeout,
+    setInterval: setInterval,
+    clearInterval: clearInterval,
+    Date: Date
+};
+
+if (typeof module == "object" && typeof require == "function") {
+    module.exports = sinon;
+}
+
+/*jslint eqeqeq: false, onevar: false*/
+/*global sinon, module, require, ActiveXObject, XMLHttpRequest, DOMParser*/
+/**
+ * Minimal Event interface implementation
+ *
+ * Original implementation by Sven Fuchs: https://gist.github.com/995028
+ * Modifications and tests by Christian Johansen.
+ *
+ * @author Sven Fuchs (svenfuchs@artweb-design.de)
+ * @author Christian Johansen (christian@cjohansen.no)
+ * @license BSD
+ *
+ * Copyright (c) 2011 Sven Fuchs, Christian Johansen
+ */
+
+if (typeof sinon == "undefined") {
+    this.sinon = {};
+}
+
+(function () {
+    var push = [].push;
+
+    sinon.Event = function Event(type, bubbles, cancelable) {
+        this.initEvent(type, bubbles, cancelable);
+    };
+
+    sinon.Event.prototype = {
+        initEvent: function(type, bubbles, cancelable) {
+            this.type = type;
+            this.bubbles = bubbles;
+            this.cancelable = cancelable;
+        },
+
+        stopPropagation: function () {},
+
+        preventDefault: function () {
+            this.defaultPrevented = true;
+        }
+    };
+
+    sinon.EventTarget = {
+        addEventListener: function addEventListener(event, listener, useCapture) {
+            this.eventListeners = this.eventListeners || {};
+            this.eventListeners[event] = this.eventListeners[event] || [];
+            push.call(this.eventListeners[event], listener);
+        },
+
+        removeEventListener: function removeEventListener(event, listener, useCapture) {
+            var listeners = this.eventListeners && this.eventListeners[event] || [];
+
+            for (var i = 0, l = listeners.length; i < l; ++i) {
+                if (listeners[i] == listener) {
+                    return listeners.splice(i, 1);
+                }
+            }
+        },
+
+        dispatchEvent: function dispatchEvent(event) {
+            var type = event.type;
+            var listeners = this.eventListeners && this.eventListeners[type] || [];
+
+            for (var i = 0; i < listeners.length; i++) {
+                if (typeof listeners[i] == "function") {
+                    listeners[i].call(this, event);
+                } else {
+                    listeners[i].handleEvent(event);
+                }
+            }
+
+            return !!event.defaultPrevented;
+        }
+    };
+}());
+
+/**
+ * @depend event.js
+ */
+/*jslint eqeqeq: false, onevar: false*/
+/*global sinon, module, require, ActiveXObject, XMLHttpRequest, DOMParser*/
+/**
+ * Fake XMLHttpRequest object
+ *
+ * @author Christian Johansen (christian@cjohansen.no)
+ * @license BSD
+ *
+ * Copyright (c) 2010-2011 Christian Johansen
+ */
+
+if (typeof sinon == "undefined") {
+    this.sinon = {};
+}
+sinon.xhr = { XMLHttpRequest: this.XMLHttpRequest };
+
+// wrapper for global
+(function(global) {
+    var xhr = sinon.xhr;
+    xhr.GlobalXMLHttpRequest = global.XMLHttpRequest;
+    xhr.GlobalActiveXObject = global.ActiveXObject;
+    xhr.supportsActiveX = typeof xhr.GlobalActiveXObject != "undefined";
+    xhr.supportsXHR = typeof xhr.GlobalXMLHttpRequest != "undefined";
+    xhr.workingXHR = xhr.supportsXHR ? xhr.GlobalXMLHttpRequest : xhr.supportsActiveX
+                                     ? function() { return new xhr.GlobalActiveXObject("MSXML2.XMLHTTP.3.0") } : false;
+
+    /*jsl:ignore*/
+    var unsafeHeaders = {
+        "Accept-Charset": true,
+        "Accept-Encoding": true,
+        "Connection": true,
+        "Content-Length": true,
+        "Cookie": true,
+        "Cookie2": true,
+        "Content-Transfer-Encoding": true,
+        "Date": true,
+        "Expect": true,
+        "Host": true,
+        "Keep-Alive": true,
+        "Referer": true,
+        "TE": true,
+        "Trailer": true,
+        "Transfer-Encoding": true,
+        "Upgrade": true,
+        "User-Agent": true,
+        "Via": true
+    };
+    /*jsl:end*/
+
+    function FakeXMLHttpRequest() {
+        this.readyState = FakeXMLHttpRequest.UNSENT;
+        this.requestHeaders = {};
+        this.requestBody = null;
+        this.status = 0;
+        this.statusText = "";
+
+        if (typeof FakeXMLHttpRequest.onCreate == "function") {
+            FakeXMLHttpRequest.onCreate(this);
+        }
+    }
+
+    function verifyState(xhr) {
+        if (xhr.readyState !== FakeXMLHttpRequest.OPENED) {
+            throw new Error("INVALID_STATE_ERR");
+        }
+
+        if (xhr.sendFlag) {
+            throw new Error("INVALID_STATE_ERR");
+        }
+    }
+
+    // filtering to enable a white-list version of Sinon FakeXhr,
+    // where whitelisted requests are passed through to real XHR
+    function each(collection, callback) {
+        if (!collection) return;
+        for (var i = 0, l = collection.length; i < l; i += 1) {
+            callback(collection[i]);
+        }
+    }
+    function some(collection, callback) {
+        for (var index = 0; index < collection.length; index++) {
+            if(callback(collection[index]) === true) return true;
+        };
+        return false;
+    }
+    // largest arity in XHR is 5 - XHR#open
+    var apply = function(obj,method,args) {
+        switch(args.length) {
+        case 0: return obj[method]();
+        case 1: return obj[method](args[0]);
+        case 2: return obj[method](args[0],args[1]);
+        case 3: return obj[method](args[0],args[1],args[2]);
+        case 4: return obj[method](args[0],args[1],args[2],args[3]);
+        case 5: return obj[method](args[0],args[1],args[2],args[3],args[4]);
+        };
+    };
+
+    FakeXMLHttpRequest.filters = [];
+    FakeXMLHttpRequest.addFilter = function(fn) {
+        this.filters.push(fn)
+    };
+    var IE6Re = /MSIE 6/;
+    FakeXMLHttpRequest.defake = function(fakeXhr,xhrArgs) {
+        var xhr = new sinon.xhr.workingXHR();
+        each(["open","setRequestHeader","send","abort","getResponseHeader",
+              "getAllResponseHeaders","addEventListener","overrideMimeType","removeEventListener"],
+             function(method) {
+                 fakeXhr[method] = function() {
+                   return apply(xhr,method,arguments);
+                 };
+             });
+
+        var copyAttrs = function(args) {
+            each(args, function(attr) {
+              try {
+                fakeXhr[attr] = xhr[attr]
+              } catch(e) {
+                if(!IE6Re.test(navigator.userAgent)) throw e;
+              }
+            });
+        };
+
+        var stateChange = function() {
+            fakeXhr.readyState = xhr.readyState;
+            if(xhr.readyState >= FakeXMLHttpRequest.HEADERS_RECEIVED) {
+                copyAttrs(["status","statusText"]);
+            }
+            if(xhr.readyState >= FakeXMLHttpRequest.LOADING) {
+                copyAttrs(["responseText"]);
+            }
+            if(xhr.readyState === FakeXMLHttpRequest.DONE) {
+                copyAttrs(["responseXML"]);
+            }
+            if(fakeXhr.onreadystatechange) fakeXhr.onreadystatechange.call(fakeXhr);
+        };
+        if(xhr.addEventListener) {
+          for(var event in fakeXhr.eventListeners) {
+              if(fakeXhr.eventListeners.hasOwnProperty(event)) {
+                  each(fakeXhr.eventListeners[event],function(handler) {
+                      xhr.addEventListener(event, handler);
+                  });
+              }
+          }
+          xhr.addEventListener("readystatechange",stateChange);
+        } else {
+          xhr.onreadystatechange = stateChange;
+        }
+        apply(xhr,"open",xhrArgs);
+    };
+    FakeXMLHttpRequest.useFilters = false;
+
+    function verifyRequestSent(xhr) {
+        if (xhr.readyState == FakeXMLHttpRequest.DONE) {
+            throw new Error("Request done");
+        }
+    }
+
+    function verifyHeadersReceived(xhr) {
+        if (xhr.async && xhr.readyState != FakeXMLHttpRequest.HEADERS_RECEIVED) {
+            throw new Error("No headers received");
+        }
+    }
+
+    function verifyResponseBodyType(body) {
+        if (typeof body != "string") {
+            var error = new Error("Attempted to respond to fake XMLHttpRequest with " +
+                                 body + ", which is not a string.");
+            error.name = "InvalidBodyException";
+            throw error;
+        }
+    }
+
+    sinon.extend(FakeXMLHttpRequest.prototype, sinon.EventTarget, {
+        async: true,
+
+        open: function open(method, url, async, username, password) {
+            this.method = method;
+            this.url = url;
+            this.async = typeof async == "boolean" ? async : true;
+            this.username = username;
+            this.password = password;
+            this.responseText = null;
+            this.responseXML = null;
+            this.requestHeaders = {};
+            this.sendFlag = false;
+            if(sinon.FakeXMLHttpRequest.useFilters === true) {
+                var xhrArgs = arguments;
+                var defake = some(FakeXMLHttpRequest.filters,function(filter) {
+                    return filter.apply(this,xhrArgs)
+                });
+                if (defake) {
+                  return sinon.FakeXMLHttpRequest.defake(this,arguments);
+                }
+            }
+            this.readyStateChange(FakeXMLHttpRequest.OPENED);
+        },
+
+        readyStateChange: function readyStateChange(state) {
+            this.readyState = state;
+
+            if (typeof this.onreadystatechange == "function") {
+                try {
+                    this.onreadystatechange();
+                } catch (e) {
+                    sinon.logError("Fake XHR onreadystatechange handler", e);
+                }
+            }
+
+            this.dispatchEvent(new sinon.Event("readystatechange"));
+        },
+
+        setRequestHeader: function setRequestHeader(header, value) {
+            verifyState(this);
+
+            if (unsafeHeaders[header] || /^(Sec-|Proxy-)/.test(header)) {
+                throw new Error("Refused to set unsafe header \"" + header + "\"");
+            }
+
+            if (this.requestHeaders[header]) {
+                this.requestHeaders[header] += "," + value;
+            } else {
+                this.requestHeaders[header] = value;
+            }
+        },
+
+        // Helps testing
+        setResponseHeaders: function setResponseHeaders(headers) {
+            this.responseHeaders = {};
+
+            for (var header in headers) {
+                if (headers.hasOwnProperty(header)) {
+                    this.responseHeaders[header] = headers[header];
+                }
+            }
+
+            if (this.async) {
+                this.readyStateChange(FakeXMLHttpRequest.HEADERS_RECEIVED);
+            }
+        },
+
+        // Currently treats ALL data as a DOMString (i.e. no Document)
+        send: function send(data) {
+            verifyState(this);
+
+            if (!/^(get|head)$/i.test(this.method)) {
+                if (this.requestHeaders["Content-Type"]) {
+                    var value = this.requestHeaders["Content-Type"].split(";");
+                    this.requestHeaders["Content-Type"] = value[0] + ";charset=utf-8";
+                } else {
+                    this.requestHeaders["Content-Type"] = "text/plain;charset=utf-8";
+                }
+
+                this.requestBody = data;
+            }
+
+            this.errorFlag = false;
+            this.sendFlag = this.async;
+            this.readyStateChange(FakeXMLHttpRequest.OPENED);
+
+            if (typeof this.onSend == "function") {
+                this.onSend(this);
+            }
+        },
+
+        abort: function abort() {
+            this.aborted = true;
+            this.responseText = null;
+            this.errorFlag = true;
+            this.requestHeaders = {};
+
+            if (this.readyState > sinon.FakeXMLHttpRequest.UNSENT && this.sendFlag) {
+                this.readyStateChange(sinon.FakeXMLHttpRequest.DONE);
+                this.sendFlag = false;
+            }
+
+            this.readyState = sinon.FakeXMLHttpRequest.UNSENT;
+        },
+
+        getResponseHeader: function getResponseHeader(header) {
+            if (this.readyState < FakeXMLHttpRequest.HEADERS_RECEIVED) {
+                return null;
+            }
+
+            if (/^Set-Cookie2?$/i.test(header)) {
+                return null;
+            }
+
+            header = header.toLowerCase();
+
+            for (var h in this.responseHeaders) {
+                if (h.toLowerCase() == header) {
+                    return this.responseHeaders[h];
+                }
+            }
+
+            return null;
+        },
+
+        getAllResponseHeaders: function getAllResponseHeaders() {
+            if (this.readyState < FakeXMLHttpRequest.HEADERS_RECEIVED) {
+                return "";
+            }
+
+            var headers = "";
+
+            for (var header in this.responseHeaders) {
+                if (this.responseHeaders.hasOwnProperty(header) &&
+                    !/^Set-Cookie2?$/i.test(header)) {
+                    headers += header + ": " + this.responseHeaders[header] + "\r\n";
+                }
+            }
+
+            return headers;
+        },
+
+        setResponseBody: function setResponseBody(body) {
+            verifyRequestSent(this);
+            verifyHeadersReceived(this);
+            verifyResponseBodyType(body);
+
+            var chunkSize = this.chunkSize || 10;
+            var index = 0;
+            this.responseText = "";
+
+            do {
+                if (this.async) {
+                    this.readyStateChange(FakeXMLHttpRequest.LOADING);
+                }
+
+                this.responseText += body.substring(index, index + chunkSize);
+                index += chunkSize;
+            } while (index < body.length);
+
+            var type = this.getResponseHeader("Content-Type");
+
+            if (this.responseText &&
+                (!type || /(text\/xml)|(application\/xml)|(\+xml)/.test(type))) {
+                try {
+                    this.responseXML = FakeXMLHttpRequest.parseXML(this.responseText);
+                } catch (e) {
+                    // Unable to parse XML - no biggie
+                }
+            }
+
+            if (this.async) {
+                this.readyStateChange(FakeXMLHttpRequest.DONE);
+            } else {
+                this.readyState = FakeXMLHttpRequest.DONE;
+            }
+        },
+
+        respond: function respond(status, headers, body) {
+            this.setResponseHeaders(headers || {});
+            this.status = typeof status == "number" ? status : 200;
+            this.statusText = FakeXMLHttpRequest.statusCodes[this.status];
+            this.setResponseBody(body || "");
+        }
+    });
+
+    sinon.extend(FakeXMLHttpRequest, {
+        UNSENT: 0,
+        OPENED: 1,
+        HEADERS_RECEIVED: 2,
+        LOADING: 3,
+        DONE: 4
+    });
+
+    // Borrowed from JSpec
+    FakeXMLHttpRequest.parseXML = function parseXML(text) {
+        var xmlDoc;
+
+        if (typeof DOMParser != "undefined") {
+            var parser = new DOMParser();
+            xmlDoc = parser.parseFromString(text, "text/xml");
+        } else {
+            xmlDoc = new ActiveXObject("Microsoft.XMLDOM");
+            xmlDoc.async = "false";
+            xmlDoc.loadXML(text);
+        }
+
+        return xmlDoc;
+    };
+
+    FakeXMLHttpRequest.statusCodes = {
+        100: "Continue",
+        101: "Switching Protocols",
+        200: "OK",
+        201: "Created",
+        202: "Accepted",
+        203: "Non-Authoritative Information",
+        204: "No Content",
+        205: "Reset Content",
+        206: "Partial Content",
+        300: "Multiple Choice",
+        301: "Moved Permanently",
+        302: "Found",
+        303: "See Other",
+        304: "Not Modified",
+        305: "Use Proxy",
+        307: "Temporary Redirect",
+        400: "Bad Request",
+        401: "Unauthorized",
+        402: "Payment Required",
+        403: "Forbidden",
+        404: "Not Found",
+        405: "Method Not Allowed",
+        406: "Not Acceptable",
+        407: "Proxy Authentication Required",
+        408: "Request Timeout",
+        409: "Conflict",
+        410: "Gone",
+        411: "Length Required",
+        412: "Precondition Failed",
+        413: "Request Entity Too Large",
+        414: "Request-URI Too Long",
+        415: "Unsupported Media Type",
+        416: "Requested Range Not Satisfiable",
+        417: "Expectation Failed",
+        422: "Unprocessable Entity",
+        500: "Internal Server Error",
+        501: "Not Implemented",
+        502: "Bad Gateway",
+        503: "Service Unavailable",
+        504: "Gateway Timeout",
+        505: "HTTP Version Not Supported"
+    };
+
+    sinon.useFakeXMLHttpRequest = function () {
+        sinon.FakeXMLHttpRequest.restore = function restore(keepOnCreate) {
+            if (xhr.supportsXHR) {
+                global.XMLHttpRequest = xhr.GlobalXMLHttpRequest;
+            }
+
+            if (xhr.supportsActiveX) {
+                global.ActiveXObject = xhr.GlobalActiveXObject;
+            }
+
+            delete sinon.FakeXMLHttpRequest.restore;
+
+            if (keepOnCreate !== true) {
+                delete sinon.FakeXMLHttpRequest.onCreate;
+            }
+        };
+        if (xhr.supportsXHR) {
+            global.XMLHttpRequest = sinon.FakeXMLHttpRequest;
+        }
+
+        if (xhr.supportsActiveX) {
+            global.ActiveXObject = function ActiveXObject(objId) {
+                if (objId == "Microsoft.XMLHTTP" || /^Msxml2\.XMLHTTP/i.test(objId)) {
+
+                    return new sinon.FakeXMLHttpRequest();
+                }
+
+                return new xhr.GlobalActiveXObject(objId);
+            };
+        }
+
+        return sinon.FakeXMLHttpRequest;
+    };
+
+    sinon.FakeXMLHttpRequest = FakeXMLHttpRequest;
+})(this);
+
+if (typeof module == "object" && typeof require == "function") {
+    module.exports = sinon;
+}
+
+/**
+ * @depend fake_xml_http_request.js
+ */
+/*jslint eqeqeq: false, onevar: false, regexp: false, plusplus: false*/
+/*global module, require, window*/
+/**
+ * The Sinon "server" mimics a web server that receives requests from
+ * sinon.FakeXMLHttpRequest and provides an API to respond to those requests,
+ * both synchronously and asynchronously. To respond synchronuously, canned
+ * answers have to be provided upfront.
+ *
+ * @author Christian Johansen (christian@cjohansen.no)
+ * @license BSD
+ *
+ * Copyright (c) 2010-2011 Christian Johansen
+ */
+
+if (typeof sinon == "undefined") {
+    var sinon = {};
+}
+
+sinon.fakeServer = (function () {
+    var push = [].push;
+    function F() {}
+
+    function create(proto) {
+        F.prototype = proto;
+        return new F();
+    }
+
+    function responseArray(handler) {
+        var response = handler;
+
+        if (Object.prototype.toString.call(handler) != "[object Array]") {
+            response = [200, {}, handler];
+        }
+
+        if (typeof response[2] != "string") {
+            throw new TypeError("Fake server response body should be string, but was " +
+                                typeof response[2]);
+        }
+
+        return response;
+    }
+
+    var wloc = window.location;
+    var rCurrLoc = new RegExp("^" + wloc.protocol + "//" + wloc.host);
+
+    function matchOne(response, reqMethod, reqUrl) {
+        var rmeth = response.method;
+        var matchMethod = !rmeth || rmeth.toLowerCase() == reqMethod.toLowerCase();
+        var url = response.url;
+        var matchUrl = !url || url == reqUrl || (typeof url.test == "function" && url.test(reqUrl));
+
+        return matchMethod && matchUrl;
+    }
+
+    function match(response, request) {
+        var requestMethod = this.getHTTPMethod(request);
+        var requestUrl = request.url;
+
+        if (!/^https?:\/\//.test(requestUrl) || rCurrLoc.test(requestUrl)) {
+            requestUrl = requestUrl.replace(rCurrLoc, "");
+        }
+
+        if (matchOne(response, this.getHTTPMethod(request), requestUrl)) {
+            if (typeof response.response == "function") {
+                var ru = response.url;
+                var args = [request].concat(!ru ? [] : requestUrl.match(ru).slice(1));
+                return response.response.apply(response, args);
+            }
+
+            return true;
+        }
+
+        return false;
+    }
+
+    return {
+        create: function () {
+            var server = create(this);
+            this.xhr = sinon.useFakeXMLHttpRequest();
+            server.requests = [];
+
+            this.xhr.onCreate = function (xhrObj) {
+                server.addRequest(xhrObj);
+            };
+
+            return server;
+        },
+
+        addRequest: function addRequest(xhrObj) {
+            var server = this;
+            push.call(this.requests, xhrObj);
+
+            xhrObj.onSend = function () {
+                server.handleRequest(this);
+            };
+
+            if (this.autoRespond && !this.responding) {
+                setTimeout(function () {
+                    server.responding = false;
+                    server.respond();
+                }, this.autoRespondAfter || 10);
+
+                this.responding = true;
+            }
+        },
+
+        getHTTPMethod: function getHTTPMethod(request) {
+            if (this.fakeHTTPMethods && /post/i.test(request.method)) {
+                var matches = (request.requestBody || "").match(/_method=([^\b;]+)/);
+                return !!matches ? matches[1] : request.method;
+            }
+
+            return request.method;
+        },
+
+        handleRequest: function handleRequest(xhr) {
+            if (xhr.async) {
+                if (!this.queue) {
+                    this.queue = [];
+                }
+
+                push.call(this.queue, xhr);
+            } else {
+                this.processRequest(xhr);
+            }
+        },
+
+        respondWith: function respondWith(method, url, body) {
+            if (arguments.length == 1 && typeof method != "function") {
+                this.response = responseArray(method);
+                return;
+            }
+
+            if (!this.responses) { this.responses = []; }
+
+            if (arguments.length == 1) {
+                body = method;
+                url = method = null;
+            }
+
+            if (arguments.length == 2) {
+                body = url;
+                url = method;
+                method = null;
+            }
+
+            push.call(this.responses, {
+                method: method,
+                url: url,
+                response: typeof body == "function" ? body : responseArray(body)
+            });
+        },
+
+        respond: function respond() {
+            if (arguments.length > 0) this.respondWith.apply(this, arguments);
+            var queue = this.queue || [];
+            var request;
+
+            while(request = queue.shift()) {
+                this.processRequest(request);
+            }
+        },
+
+        processRequest: function processRequest(request) {
+            try {
+                if (request.aborted) {
+                    return;
+                }
+
+                var response = this.response || [404, {}, ""];
+
+                if (this.responses) {
+                    for (var i = 0, l = this.responses.length; i < l; i++) {
+                        if (match.call(this, this.responses[i], request)) {
+                            response = this.responses[i].response;
+                            break;
+                        }
+                    }
+                }
+
+                if (request.readyState != 4) {
+                    request.respond(response[0], response[1], response[2]);
+                }
+            } catch (e) {
+                sinon.logError("Fake server request processing", e);
+            }
+        },
+
+        restore: function restore() {
+            return this.xhr.restore && this.xhr.restore.apply(this.xhr, arguments);
+        }
+    };
+}());
+
+if (typeof module == "object" && typeof require == "function") {
+    module.exports = sinon;
+}
+
+/**
+ * @depend fake_server.js
+ * @depend fake_timers.js
+ */
+/*jslint browser: true, eqeqeq: false, onevar: false*/
+/*global sinon*/
+/**
+ * Add-on for sinon.fakeServer that automatically handles a fake timer along with
+ * the FakeXMLHttpRequest. The direct inspiration for this add-on is jQuery
+ * 1.3.x, which does not use xhr object's onreadystatehandler at all - instead,
+ * it polls the object for completion with setInterval. Dispite the direct
+ * motivation, there is nothing jQuery-specific in this file, so it can be used
+ * in any environment where the ajax implementation depends on setInterval or
+ * setTimeout.
+ *
+ * @author Christian Johansen (christian@cjohansen.no)
+ * @license BSD
+ *
+ * Copyright (c) 2010-2011 Christian Johansen
+ */
+
+(function () {
+    function Server() {}
+    Server.prototype = sinon.fakeServer;
+
+    sinon.fakeServerWithClock = new Server();
+
+    sinon.fakeServerWithClock.addRequest = function addRequest(xhr) {
+        if (xhr.async) {
+            if (typeof setTimeout.clock == "object") {
+                this.clock = setTimeout.clock;
+            } else {
+                this.clock = sinon.useFakeTimers();
+                this.resetClock = true;
+            }
+
+            if (!this.longestTimeout) {
+                var clockSetTimeout = this.clock.setTimeout;
+                var clockSetInterval = this.clock.setInterval;
+                var server = this;
+
+                this.clock.setTimeout = function (fn, timeout) {
+                    server.longestTimeout = Math.max(timeout, server.longestTimeout || 0);
+
+                    return clockSetTimeout.apply(this, arguments);
+                };
+
+                this.clock.setInterval = function (fn, timeout) {
+                    server.longestTimeout = Math.max(timeout, server.longestTimeout || 0);
+
+                    return clockSetInterval.apply(this, arguments);
+                };
+            }
+        }
+
+        return sinon.fakeServer.addRequest.call(this, xhr);
+    };
+
+    sinon.fakeServerWithClock.respond = function respond() {
+        var returnVal = sinon.fakeServer.respond.apply(this, arguments);
+
+        if (this.clock) {
+            this.clock.tick(this.longestTimeout || 0);
+            this.longestTimeout = 0;
+
+            if (this.resetClock) {
+                this.clock.restore();
+                this.resetClock = false;
+            }
+        }
+
+        return returnVal;
+    };
+
+    sinon.fakeServerWithClock.restore = function restore() {
+        if (this.clock) {
+            this.clock.restore();
+        }
+
+        return sinon.fakeServer.restore.apply(this, arguments);
+    };
+}());
+
+/**
+ * @depend ../sinon.js
+ * @depend collection.js
+ * @depend util/fake_timers.js
+ * @depend util/fake_server_with_clock.js
+ */
+/*jslint eqeqeq: false, onevar: false, plusplus: false*/
+/*global require, module*/
+/**
+ * Manages fake collections as well as fake utilities such as Sinon's
+ * timers and fake XHR implementation in one convenient object.
+ *
+ * @author Christian Johansen (christian@cjohansen.no)
+ * @license BSD
+ *
+ * Copyright (c) 2010-2011 Christian Johansen
+ */
+
+if (typeof module == "object" && typeof require == "function") {
+    var sinon = require("../sinon");
+    sinon.extend(sinon, require("./util/fake_timers"));
+}
+
+(function () {
+    var push = [].push;
+
+    function exposeValue(sandbox, config, key, value) {
+        if (!value) {
+            return;
+        }
+
+        if (config.injectInto) {
+            config.injectInto[key] = value;
+        } else {
+            push.call(sandbox.args, value);
+        }
+    }
+
+    function prepareSandboxFromConfig(config) {
+        var sandbox = sinon.create(sinon.sandbox);
+
+        if (config.useFakeServer) {
+            if (typeof config.useFakeServer == "object") {
+                sandbox.serverPrototype = config.useFakeServer;
+            }
+
+            sandbox.useFakeServer();
+        }
+
+        if (config.useFakeTimers) {
+            if (typeof config.useFakeTimers == "object") {
+                sandbox.useFakeTimers.apply(sandbox, config.useFakeTimers);
+            } else {
+                sandbox.useFakeTimers();
+            }
+        }
+
+        return sandbox;
+    }
+
+    sinon.sandbox = sinon.extend(sinon.create(sinon.collection), {
+        useFakeTimers: function useFakeTimers() {
+            this.clock = sinon.useFakeTimers.apply(sinon, arguments);
+
+            return this.add(this.clock);
+        },
+
+        serverPrototype: sinon.fakeServer,
+
+        useFakeServer: function useFakeServer() {
+            var proto = this.serverPrototype || sinon.fakeServer;
+
+            if (!proto || !proto.create) {
+                return null;
+            }
+
+            this.server = proto.create();
+            return this.add(this.server);
+        },
+
+        inject: function (obj) {
+            sinon.collection.inject.call(this, obj);
+
+            if (this.clock) {
+                obj.clock = this.clock;
+            }
+
+            if (this.server) {
+                obj.server = this.server;
+                obj.requests = this.server.requests;
+            }
+
+            return obj;
+        },
+
+        create: function (config) {
+            if (!config) {
+                return sinon.create(sinon.sandbox);
+            }
+
+            var sandbox = prepareSandboxFromConfig(config);
+            sandbox.args = sandbox.args || [];
+            var prop, value, exposed = sandbox.inject({});
+
+            if (config.properties) {
+                for (var i = 0, l = config.properties.length; i < l; i++) {
+                    prop = config.properties[i];
+                    value = exposed[prop] || prop == "sandbox" && sandbox;
+                    exposeValue(sandbox, config, prop, value);
+                }
+            } else {
+                exposeValue(sandbox, config, "sandbox", value);
+            }
+
+            return sandbox;
+        }
+    });
+
+    sinon.sandbox.useFakeXMLHttpRequest = sinon.sandbox.useFakeServer;
+
+    if (typeof module == "object" && typeof require == "function") {
+        module.exports = sinon.sandbox;
+    }
+}());
+
+/**
+ * @depend ../sinon.js
+ * @depend stub.js
+ * @depend mock.js
+ * @depend sandbox.js
+ */
+/*jslint eqeqeq: false, onevar: false, forin: true, plusplus: false*/
+/*global module, require, sinon*/
+/**
+ * Test function, sandboxes fakes
+ *
+ * @author Christian Johansen (christian@cjohansen.no)
+ * @license BSD
+ *
+ * Copyright (c) 2010-2011 Christian Johansen
+ */
+
+(function (sinon) {
+    var commonJSModule = typeof module == "object" && typeof require == "function";
+
+    if (!sinon && commonJSModule) {
+        sinon = require("../sinon");
+    }
+
+    if (!sinon) {
+        return;
+    }
+
+    function test(callback) {
+        var type = typeof callback;
+
+        if (type != "function") {
+            throw new TypeError("sinon.test needs to wrap a test function, got " + type);
+        }
+
+        return function () {
+            var config = sinon.getConfig(sinon.config);
+            config.injectInto = config.injectIntoThis && this || config.injectInto;
+            var sandbox = sinon.sandbox.create(config);
+            var exception, result;
+            var args = Array.prototype.slice.call(arguments).concat(sandbox.args);
+
+            try {
+                result = callback.apply(this, args);
+            } finally {
+                sandbox.verifyAndRestore();
+            }
+
+            return result;
+        };
+    }
+
+    test.config = {
+        injectIntoThis: true,
+        injectInto: null,
+        properties: ["spy", "stub", "mock", "clock", "server", "requests"],
+        useFakeTimers: true,
+        useFakeServer: true
+    };
+
+    if (commonJSModule) {
+        module.exports = test;
+    } else {
+        sinon.test = test;
+    }
+}(typeof sinon == "object" && sinon || null));
+
+/**
+ * @depend ../sinon.js
+ * @depend test.js
+ */
+/*jslint eqeqeq: false, onevar: false, eqeqeq: false*/
+/*global module, require, sinon*/
+/**
+ * Test case, sandboxes all test functions
+ *
+ * @author Christian Johansen (christian@cjohansen.no)
+ * @license BSD
+ *
+ * Copyright (c) 2010-2011 Christian Johansen
+ */
+
+(function (sinon) {
+    var commonJSModule = typeof module == "object" && typeof require == "function";
+
+    if (!sinon && commonJSModule) {
+        sinon = require("../sinon");
+    }
+
+    if (!sinon || !Object.prototype.hasOwnProperty) {
+        return;
+    }
+
+    function createTest(property, setUp, tearDown) {
+        return function () {
+            if (setUp) {
+                setUp.apply(this, arguments);
+            }
+
+            var exception, result;
+
+            try {
+                result = property.apply(this, arguments);
+            } catch (e) {
+                exception = e;
+            }
+
+            if (tearDown) {
+                tearDown.apply(this, arguments);
+            }
+
+            if (exception) {
+                throw exception;
+            }
+
+            return result;
+        };
+    }
+
+    function testCase(tests, prefix) {
+        /*jsl:ignore*/
+        if (!tests || typeof tests != "object") {
+            throw new TypeError("sinon.testCase needs an object with test functions");
+        }
+        /*jsl:end*/
+
+        prefix = prefix || "test";
+        var rPrefix = new RegExp("^" + prefix);
+        var methods = {}, testName, property, method;
+        var setUp = tests.setUp;
+        var tearDown = tests.tearDown;
+
+        for (testName in tests) {
+            if (tests.hasOwnProperty(testName)) {
+                property = tests[testName];
+
+                if (/^(setUp|tearDown)$/.test(testName)) {
+                    continue;
+                }
+
+                if (typeof property == "function" && rPrefix.test(testName)) {
+                    method = property;
+
+                    if (setUp || tearDown) {
+                        method = createTest(property, setUp, tearDown);
+                    }
+
+                    methods[testName] = sinon.test(method);
+                } else {
+                    methods[testName] = tests[testName];
+                }
+            }
+        }
+
+        return methods;
+    }
+
+    if (commonJSModule) {
+        module.exports = testCase;
+    } else {
+        sinon.testCase = testCase;
+    }
+}(typeof sinon == "object" && sinon || null));
+
+/**
+ * @depend ../sinon.js
+ * @depend stub.js
+ */
+/*jslint eqeqeq: false, onevar: false, nomen: false, plusplus: false*/
+/*global module, require, sinon*/
+/**
+ * Assertions matching the test spy retrieval interface.
+ *
+ * @author Christian Johansen (christian@cjohansen.no)
+ * @license BSD
+ *
+ * Copyright (c) 2010-2011 Christian Johansen
+ */
+
+(function (sinon, global) {
+    var commonJSModule = typeof module == "object" && typeof require == "function";
+    var slice = Array.prototype.slice;
+    var assert;
+
+    if (!sinon && commonJSModule) {
+        sinon = require("../sinon");
+    }
+
+    if (!sinon) {
+        return;
+    }
+
+    function verifyIsStub() {
+        var method;
+
+        for (var i = 0, l = arguments.length; i < l; ++i) {
+            method = arguments[i];
+
+            if (!method) {
+                assert.fail("fake is not a spy");
+            }
+
+            if (typeof method != "function") {
+                assert.fail(method + " is not a function");
+            }
+
+            if (typeof method.getCall != "function") {
+                assert.fail(method + " is not stubbed");
+            }
+        }
+    }
+
+    function failAssertion(object, msg) {
+        object = object || global;
+        var failMethod = object.fail || assert.fail;
+        failMethod.call(object, msg);
+    }
+
+    function mirrorPropAsAssertion(name, method, message) {
+        if (arguments.length == 2) {
+            message = method;
+            method = name;
+        }
+
+        assert[name] = function (fake) {
+            verifyIsStub(fake);
+
+            var args = slice.call(arguments, 1);
+            var failed = false;
+
+            if (typeof method == "function") {
+                failed = !method(fake);
+            } else {
+                failed = typeof fake[method] == "function" ?
+                    !fake[method].apply(fake, args) : !fake[method];
+            }
+
+            if (failed) {
+                failAssertion(this, fake.printf.apply(fake, [message].concat(args)));
+            } else {
+                assert.pass(name);
+            }
+        };
+    }
+
+    function exposedName(prefix, prop) {
+        return !prefix || /^fail/.test(prop) ? prop :
+            prefix + prop.slice(0, 1).toUpperCase() + prop.slice(1);
+    };
+
+    assert = {
+        failException: "AssertError",
+
+        fail: function fail(message) {
+            var error = new Error(message);
+            error.name = this.failException || assert.failException;
+
+            throw error;
+        },
+
+        pass: function pass(assertion) {},
+
+        callOrder: function assertCallOrder() {
+            verifyIsStub.apply(null, arguments);
+            var expected = "", actual = "";
+
+            if (!sinon.calledInOrder(arguments)) {
+                try {
+                    expected = [].join.call(arguments, ", ");
+                    actual = sinon.orderByFirstCall(slice.call(arguments)).join(", ");
+                } catch (e) {
+                    // If this fails, we'll just fall back to the blank string
+                }
+
+                failAssertion(this, "expected " + expected + " to be " +
+                              "called in order but were called as " + actual);
+            } else {
+                assert.pass("callOrder");
+            }
+        },
+
+        callCount: function assertCallCount(method, count) {
+            verifyIsStub(method);
+
+            if (method.callCount != count) {
+                var msg = "expected %n to be called " + sinon.timesInWords(count) +
+                    " but was called %c%C";
+                failAssertion(this, method.printf(msg));
+            } else {
+                assert.pass("callCount");
+            }
+        },
+
+        expose: function expose(target, options) {
+            if (!target) {
+                throw new TypeError("target is null or undefined");
+            }
+
+            var o = options || {};
+            var prefix = typeof o.prefix == "undefined" && "assert" || o.prefix;
+            var includeFail = typeof o.includeFail == "undefined" || !!o.includeFail;
+
+            for (var method in this) {
+                if (method != "export" && (includeFail || !/^(fail)/.test(method))) {
+                    target[exposedName(prefix, method)] = this[method];
+                }
+            }
+
+            return target;
+        }
+    };
+
+    mirrorPropAsAssertion("called", "expected %n to have been called at least once but was never called");
+    mirrorPropAsAssertion("notCalled", function (spy) { return !spy.called; },
+                          "expected %n to not have been called but was called %c%C");
+    mirrorPropAsAssertion("calledOnce", "expected %n to be called once but was called %c%C");
+    mirrorPropAsAssertion("calledTwice", "expected %n to be called twice but was called %c%C");
+    mirrorPropAsAssertion("calledThrice", "expected %n to be called thrice but was called %c%C");
+    mirrorPropAsAssertion("calledOn", "expected %n to be called with %1 as this but was called with %t");
+    mirrorPropAsAssertion("alwaysCalledOn", "expected %n to always be called with %1 as this but was called with %t");
+    mirrorPropAsAssertion("calledWith", "expected %n to be called with arguments %*%C");
+    mirrorPropAsAssertion("alwaysCalledWith", "expected %n to always be called with arguments %*%C");
+    mirrorPropAsAssertion("calledWithExactly", "expected %n to be called with exact arguments %*%C");
+    mirrorPropAsAssertion("alwaysCalledWithExactly", "expected %n to always be called with exact arguments %*%C");
+    mirrorPropAsAssertion("neverCalledWith", "expected %n to never be called with arguments %*%C");
+    mirrorPropAsAssertion("threw", "%n did not throw exception%C");
+    mirrorPropAsAssertion("alwaysThrew", "%n did not always throw exception%C");
+
+    if (commonJSModule) {
+        module.exports = assert;
+    } else {
+        sinon.assert = assert;
+    }
+}(typeof sinon == "object" && sinon || null, typeof window != "undefined" ? window : global));
+
+return sinon;}.call(typeof window != 'undefined' && window || {}));
diff --git a/public/spec.html b/public/spec.html
new file mode 100644
index 00000000..fdc6270c
--- /dev/null
+++ b/public/spec.html
@@ -0,0 +1,30 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <meta charset="UTF-8">
+    <title>Travis CI - Distributed Continuous Integration Platform for the Open Source Community</title>
+    <link rel="stylesheet" href="stylesheets/application.css">
+    <link rel="stylesheet" href="stylesheets/jasmine.css">
+    <script>
+      var ENV = 'test'
+    </script>
+    <script src="javascripts/vendor.js"></script>
+    <script src="javascripts/mocks.js"></script>
+    <script src="javascripts/application.js"></script>
+    <script src="javascripts/specs/vendor.js"></script>
+    <script src="javascripts/specs/specs.js"></script>
+  </head>
+  <body>
+    <script>
+      for(key in minispade.modules)
+        if(key.match(/_spec$/))
+          console.log(key)
+          minispade.require(key);
+
+      var console_reporter = new jasmine.ConsoleReporter()
+      jasmine.getEnv().addReporter(new jasmine.TrivialReporter());
+      jasmine.getEnv().addReporter(console_reporter);
+      jasmine.getEnv().execute();
+    </script>
+  </body>
+</html>
diff --git a/public/stylesheets/jasmine.css b/public/stylesheets/jasmine.css
new file mode 100644
index 00000000..705dd7d6
--- /dev/null
+++ b/public/stylesheets/jasmine.css
@@ -0,0 +1,79 @@
+#HTMLReporter { font-size: 11px; font-family: Monaco, "Lucida Console", monospace; line-height: 14px; color: #333333; }
+#HTMLReporter a { text-decoration: none; }
+#HTMLReporter a:hover { text-decoration: underline; }
+#HTMLReporter p, #HTMLReporter h1, #HTMLReporter h2, #HTMLReporter h3, #HTMLReporter h4, #HTMLReporter h5, #HTMLReporter h6 { margin: 0; line-height: 14px; }
+#HTMLReporter .banner, #HTMLReporter .symbolSummary, #HTMLReporter .summary, #HTMLReporter .resultMessage, #HTMLReporter .specDetail .description, #HTMLReporter .alert .bar, #HTMLReporter .stackTrace { padding-left: 9px; padding-right: 9px; }
+#HTMLReporter #jasmine_content { position: fixed; right: 100%; }
+#HTMLReporter .version { color: #aaaaaa; }
+#HTMLReporter .banner { margin-top: 14px; }
+#HTMLReporter .duration { color: #aaaaaa; float: right; }
+#HTMLReporter .symbolSummary { overflow: hidden; *zoom: 1; margin: 14px 0; }
+#HTMLReporter .symbolSummary li { display: block; float: left; height: 7px; width: 14px; margin-bottom: 7px; font-size: 16px; }
+#HTMLReporter .symbolSummary li.passed { font-size: 14px; }
+#HTMLReporter .symbolSummary li.passed:before { color: #5e7d00; content: "\02022"; }
+#HTMLReporter .symbolSummary li.failed { line-height: 9px; }
+#HTMLReporter .symbolSummary li.failed:before { color: #b03911; content: "x"; font-weight: bold; margin-left: -1px; }
+#HTMLReporter .symbolSummary li.skipped { font-size: 14px; }
+#HTMLReporter .symbolSummary li.skipped:before { color: #bababa; content: "\02022"; }
+#HTMLReporter .symbolSummary li.pending { line-height: 11px; }
+#HTMLReporter .symbolSummary li.pending:before { color: #aaaaaa; content: "-"; }
+#HTMLReporter .bar { line-height: 28px; font-size: 14px; display: block; color: #eee; }
+#HTMLReporter .runningAlert { background-color: #666666; }
+#HTMLReporter .skippedAlert { background-color: #aaaaaa; }
+#HTMLReporter .skippedAlert:first-child { background-color: #333333; }
+#HTMLReporter .skippedAlert:hover { text-decoration: none; color: white; text-decoration: underline; }
+#HTMLReporter .passingAlert { background-color: #a6b779; }
+#HTMLReporter .passingAlert:first-child { background-color: #5e7d00; }
+#HTMLReporter .failingAlert { background-color: #cf867e; }
+#HTMLReporter .failingAlert:first-child { background-color: #b03911; }
+#HTMLReporter .results { margin-top: 14px; }
+#HTMLReporter #details { display: none; }
+#HTMLReporter .resultsMenu, #HTMLReporter .resultsMenu a { background-color: #fff; color: #333333; }
+#HTMLReporter.showDetails .summaryMenuItem { font-weight: normal; text-decoration: inherit; }
+#HTMLReporter.showDetails .summaryMenuItem:hover { text-decoration: underline; }
+#HTMLReporter.showDetails .detailsMenuItem { font-weight: bold; text-decoration: underline; }
+#HTMLReporter.showDetails .summary { display: none; }
+#HTMLReporter.showDetails #details { display: block; }
+#HTMLReporter .summaryMenuItem { font-weight: bold; text-decoration: underline; }
+#HTMLReporter .summary { margin-top: 14px; }
+#HTMLReporter .summary .suite .suite, #HTMLReporter .summary .specSummary { margin-left: 14px; }
+#HTMLReporter .summary .specSummary.passed a { color: #5e7d00; }
+#HTMLReporter .summary .specSummary.failed a { color: #b03911; }
+#HTMLReporter .description + .suite { margin-top: 0; }
+#HTMLReporter .suite { margin-top: 14px; }
+#HTMLReporter .suite a { color: #333333; }
+#HTMLReporter #details .specDetail { margin-bottom: 28px; }
+#HTMLReporter #details .specDetail .description { display: block; color: white; background-color: #b03911; }
+#HTMLReporter .resultMessage { padding-top: 14px; color: #333333; }
+#HTMLReporter .resultMessage span.result { display: block; }
+#HTMLReporter .stackTrace { margin: 5px 0 0 0; max-height: 224px; overflow: auto; line-height: 18px; color: #666666; border: 1px solid #ddd; background: white; white-space: pre; }
+
+#TrivialReporter { padding: 8px 13px; clear: both; overflow-y: scroll; background-color: white; font-family: "Helvetica Neue Light", "Lucida Grande", "Calibri", "Arial", sans-serif; /*.resultMessage {*/ /*white-space: pre;*/ /*}*/ }
+#TrivialReporter a:visited, #TrivialReporter a { color: #303; }
+#TrivialReporter a:hover, #TrivialReporter a:active { color: blue; }
+#TrivialReporter .run_spec { float: right; padding-right: 5px; font-size: .8em; text-decoration: none; }
+#TrivialReporter .banner { color: #303; background-color: #fef; padding: 5px; }
+#TrivialReporter .logo { float: left; font-size: 1.1em; padding-left: 5px; }
+#TrivialReporter .logo .version { font-size: .6em; padding-left: 1em; }
+#TrivialReporter .runner.running { background-color: yellow; }
+#TrivialReporter .options { text-align: right; font-size: .8em; }
+#TrivialReporter .suite { border: 1px outset gray; margin: 5px 0; padding-left: 1em; }
+#TrivialReporter .suite .suite { margin: 5px; }
+#TrivialReporter .suite.passed { background-color: #dfd; }
+#TrivialReporter .suite.failed { background-color: #fdd; }
+#TrivialReporter .spec { margin: 5px; padding-left: 1em; clear: both; }
+#TrivialReporter .spec.failed, #TrivialReporter .spec.passed, #TrivialReporter .spec.skipped { padding-bottom: 5px; border: 1px solid gray; }
+#TrivialReporter .spec.failed { background-color: #fbb; border-color: red; }
+#TrivialReporter .spec.passed { background-color: #bfb; border-color: green; }
+#TrivialReporter .spec.skipped { background-color: #bbb; }
+#TrivialReporter .messages { border-left: 1px dashed gray; padding-left: 1em; padding-right: 1em; }
+#TrivialReporter .passed { background-color: #cfc; display: none; }
+#TrivialReporter .failed { background-color: #fbb; }
+#TrivialReporter .skipped { color: #777; background-color: #eee; display: none; }
+#TrivialReporter .resultMessage span.result { display: block; line-height: 2em; color: black; }
+#TrivialReporter .resultMessage .mismatch { color: black; }
+#TrivialReporter .stackTrace { white-space: pre; font-size: .8em; margin-left: 10px; max-height: 5em; overflow: auto; border: 1px inset red; padding: 1em; background: #eef; }
+#TrivialReporter .finished-at { padding-left: 1em; font-size: .6em; }
+#TrivialReporter.show-passed .passed, #TrivialReporter.show-skipped .skipped { display: block; }
+#TrivialReporter #jasmine_content { position: fixed; right: 100%; }
+#TrivialReporter .runner { border: 1px solid gray; display: block; margin: 5px 0; padding: 2px 0 2px 10px; }
diff --git a/public/stylesheets/mocha.css b/public/stylesheets/mocha.css
new file mode 100644
index 00000000..5913ae31
--- /dev/null
+++ b/public/stylesheets/mocha.css
@@ -0,0 +1,176 @@
+#mocha ul, #mocha li {
+  margin: 0;
+  padding: 0;
+}
+
+#mocha ul {
+  list-style: none;
+}
+
+#mocha h1, #mocha h2 {
+  margin: 0;
+}
+
+#mocha h1 {
+  margin-top: 15px;
+  font-size: 1em;
+  font-weight: 200;
+}
+
+#mocha h1 a {
+  text-decoration: none;
+  color: inherit;
+}
+
+#mocha h1 a:hover {
+  text-decoration: underline;
+}
+
+#mocha .suite .suite h1 {
+  margin-top: 0;
+  font-size: .8em;
+}
+
+#mocha h2 {
+  font-size: 12px;
+  font-weight: normal;
+  cursor: pointer;
+}
+
+#mocha .suite {
+  margin-left: 15px;
+}
+
+#mocha .test {
+  margin-left: 15px;
+}
+
+#mocha .test:hover h2::after {
+  position: relative;
+  top: 0;
+  right: -10px;
+  content: '(view source)';
+  font-size: 12px;
+  font-family: arial;
+  color: #888;
+}
+
+#mocha .test.pending:hover h2::after {
+  content: '(pending)';
+  font-family: arial;
+}
+
+#mocha .test.pass.medium .duration {
+  background: #C09853;
+}
+
+#mocha .test.pass.slow .duration {
+  background: #B94A48;
+}
+
+#mocha .test.pass::before {
+  content: '✓';
+  font-size: 12px;
+  display: block;
+  float: left;
+  margin-right: 5px;
+  color: #00d6b2;
+}
+
+#mocha .test.pass .duration {
+  font-size: 9px;
+  margin-left: 5px;
+  padding: 2px 5px;
+  color: white;
+  -webkit-box-shadow: inset 0 1px 1px rgba(0,0,0,.2);
+  -moz-box-shadow: inset 0 1px 1px rgba(0,0,0,.2);
+  box-shadow: inset 0 1px 1px rgba(0,0,0,.2);
+  -webkit-border-radius: 5px;
+  -moz-border-radius: 5px;
+  -ms-border-radius: 5px;
+  -o-border-radius: 5px;
+  border-radius: 5px;
+}
+
+#mocha .test.pass.fast .duration {
+  display: none;
+}
+
+#mocha .test.pending {
+  color: #0b97c4;
+}
+
+#mocha .test.pending::before {
+  content: '◦';
+  color: #0b97c4;
+}
+
+#mocha .test.fail {
+  color: #c00;
+}
+
+#mocha .test.fail pre {
+  color: black;
+}
+
+#mocha .test.fail::before {
+  content: '✖';
+  font-size: 12px;
+  display: block;
+  float: left;
+  margin-right: 5px;
+  color: #c00;
+}
+
+#mocha .test pre.error {
+  color: #c00;
+}
+
+#mocha .test pre {
+  display: inline-block;
+  font: 12px/1.5 monaco, monospace;
+  margin: 5px;
+  padding: 15px;
+  border: 1px solid #eee;
+  border-bottom-color: #ddd;
+  -webkit-border-radius: 3px;
+  -webkit-box-shadow: 0 1px 3px #eee;
+}
+
+#error {
+  color: #c00;
+  font-size: 1.5  em;
+  font-weight: 100;
+  letter-spacing: 1px;
+}
+
+#stats {
+  position: fixed;
+  top: 15px;
+  right: 10px;
+  font-size: 12px;
+  margin: 0;
+  color: #888;
+}
+
+#stats .progress {
+  float: right;
+  padding-top: 0;
+}
+
+#stats em {
+  color: black;
+}
+
+#stats li {
+  display: inline-block;
+  margin: 0 5px;
+  list-style: none;
+  padding-top: 11px;
+}
+
+code .comment { color: #ddd }
+code .init { color: #2F6FAD }
+code .string { color: #5890AD }
+code .keyword { color: #8A6343 }
+code .number { color: #2F6FAD }
diff --git a/run_jasmine.coffee b/run_jasmine.coffee
new file mode 100755
index 00000000..3c276aea
--- /dev/null
+++ b/run_jasmine.coffee
@@ -0,0 +1,46 @@
+#!/usr/local/bin/phantomjs
+
+# Runs a Jasmine Suite from an html page
+# @page is a PhantomJs page object
+# @exit_func is the function to call in order to exit the script
+
+class PhantomJasmineRunner
+  constructor: (@page, @exit_func = phantom.exit) ->
+    @tries = 0
+    @max_tries = 10
+
+  get_status: -> @page.evaluate(-> console_reporter.status)
+
+  terminate: ->
+    switch @get_status()
+      when "success" then @exit_func 0
+      when "fail"    then @exit_func 1
+      else                @exit_func 2
+
+# Script Begin
+if phantom.args.length == 0
+  console.log "Need a url as the argument"
+  phantom.exit 1
+
+page = new WebPage()
+
+runner = new PhantomJasmineRunner(page)
+
+# Don't supress console output
+page.onConsoleMessage = (msg) ->
+  console.log msg
+
+  # Terminate when the reporter singals that testing is over.
+  # We cannot use a callback function for this (because page.evaluate is sandboxed),
+  # so we have to *observe* the website.
+  if msg == "ConsoleReporter finished"
+    runner.terminate()
+
+address = phantom.args[0]
+
+page.open address, (status) ->
+  if status != "success"
+    console.log "can't load the address!"
+    phantom.exit 1
+
+  # Now we wait until onConsoleMessage reads the termination signal from the log.
diff --git a/assets/javascripts/spec/support/run-mocha.js b/run_mocha.js
similarity index 100%
rename from assets/javascripts/spec/support/run-mocha.js
rename to run_mocha.js