added jasmine2.0 support

Author: Jeffery McRiffey

lib/_patch/jasmine2-boot.js

@@ -0,0 +1,137 @@
+/**
+ Starting with version 2.0, this file "boots" Jasmine, performing all of the necessary initialization before executing the loaded environment and all of a project's specs. This file should be loaded after `jasmine.js`, but before any project source files or spec files are loaded. Thus this file can also be used to customize Jasmine for a project.
+
+ If a project is using Jasmine via the standalone distribution, this file can be customized directly. If a project is using Jasmine via the [Ruby gem][jasmine-gem], this file can be copied into the support directory via `jasmine copy_boot_js`. Other environments (e.g., Python) will have different mechanisms.
+
+ The location of `boot.js` can be specified and/or overridden in `jasmine.yml`.
+
+ [jasmine-gem]: http://github.com/pivotal/jasmine-gem
+ */
+
+(function() {
+
+  /**
+   * ## Require & Instantiate
+   *
+   * Require Jasmine's core files. Specifically, this requires and attaches all of Jasmine's code to the `jasmine` reference.
+   */
+  window.jasmine = jasmineRequire.core(jasmineRequire);
+
+  /**
+   * Create the Jasmine environment. This is used to run all specs in a project.
+   */
+  var env = jasmine.getEnv();
+
+  /**
+   * ## The Global Interface
+   *
+   * Build up the functions that will be exposed as the Jasmine public interface. A project can customize, rename or alias any of these functions as desired, provided the implementation remains unchanged.
+   */
+  var jasmineInterface = {
+    describe: function(description, specDefinitions) {
+      return env.describe(description, specDefinitions);
+    },
+
+    xdescribe: function(description, specDefinitions) {
+      return env.xdescribe(description, specDefinitions);
+    },
+
+    it: function(desc, func) {
+      return env.it(desc, func);
+    },
+
+    xit: function(desc, func) {
+      return env.xit(desc, func);
+    },
+
+    beforeEach: function(beforeEachFunction) {
+      return env.beforeEach(beforeEachFunction);
+    },
+
+    afterEach: function(afterEachFunction) {
+      return env.afterEach(afterEachFunction);
+    },
+
+    expect: function(actual) {
+      return env.expect(actual);
+    },
+
+    pending: function() {
+      return env.pending();
+    },
+
+    spyOn: function(obj, methodName) {
+      return env.spyOn(obj, methodName);
+    },
+
+    jsApiReporter: new jasmine.JsApiReporter({
+      timer: new jasmine.Timer()
+    })
+  };
+
+  /**
+   * Add all of the Jasmine global/public interface to the proper global, so a project can use the public interface directly. For example, calling `describe` in specs instead of `jasmine.getEnv().describe`.
+   */
+  if (typeof window == "undefined" && typeof exports == "object") {
+    extend(exports, jasmineInterface);
+  } else {
+    extend(window, jasmineInterface);
+  }
+
+  /**
+   * Expose the interface for adding custom equality testers.
+   */
+  jasmine.addCustomEqualityTester = function(tester) {
+    env.addCustomEqualityTester(tester);
+  };
+
+  /**
+   * Expose the interface for adding custom expectation matchers
+   */
+  jasmine.addMatchers = function(matchers) {
+    return env.addMatchers(matchers);
+  };
+
+  /**
+   * Expose the mock interface for the JavaScript timeout functions
+   */
+  jasmine.clock = function() {
+    return env.clock;
+  };
+
+  /**
+   * The `jsApiReporter` also receives spec results, and is used by any environment that needs to extract the results  from JavaScript.
+   */
+  env.addReporter(jasmineInterface.jsApiReporter);
+
+  /**
+   * Setting up timing functions to be able to be overridden. Certain browsers (Safari, IE 8, phantomjs) require this hack.
+   */
+  window.setTimeout = window.setTimeout;
+  window.setInterval = window.setInterval;
+  window.clearTimeout = window.clearTimeout;
+  window.clearInterval = window.clearInterval;
+
+  /**
+   * ## Execution
+   *
+   * Replace the browser window's `onload`, ensure it's called, and then run all of the loaded specs. This includes initializing the `HtmlReporter` instance and then executing the loaded Jasmine environment. All of this will happen after all of the specs are loaded.
+   */
+  var currentWindowOnload = window.onload;
+
+  window.onload = function() {
+    if (currentWindowOnload) {
+      currentWindowOnload();
+    }
+    env.execute();
+  };
+
+  /**
+   * Helper function for readability above.
+   */
+  function extend(destination, source) {
+    for (var property in source) destination[property] = source[property];
+    return destination;
+  }
+
+}());

lib/_patch/jasmine2-plugin.js

@@ -0,0 +1,31 @@
+(function(){
+  var checker = setInterval(function(){
+    if(!jasmine.running){
+      var results = {};
+      var errors = [];
+      var specs = jsApiReporter.specs();
+      results.runtime = jsApiReporter.executionTime() * 1000;
+      results.total = 0;
+      results.passed = 0;
+      results.failed = 0;
+      results.tracebacks = [];
+
+      for(spec in specs){
+        var s = specs[spec]
+
+        if (s.status === 'passed') {
+            results.passed++;
+        } else {
+            results.tracebacks.push(s.description);
+            results.failed = true;
+        }
+      }
+
+      results.total = results.passed + results.failed;
+      results.url = window.location.pathname;
+      BrowserStack.post("/_report", results, function(){});
+    }
+    clearInterval(checker);
+  }, 1000);
+})();
+

lib/server.js

@@ -79,6 +79,7 @@ exports.Server = function Server(bsClient, workers) {
         framework_scripts = {
           'qunit': ['qunit-plugin.js'],
           'jasmine': ['jasmine-jsreporter.js', 'jasmine-plugin.js'],
+          'jasmine2': ['jasmine2-boot.js', 'jasmine2-plugin.js'],
           'mocha': ['mocha-plugin.js']
         };
 
@@ -103,6 +104,10 @@ exports.Server = function Server(bsClient, workers) {
               patch += "<script type='text/javascript' src='/_patch/" + script + "'></script>\n";
             });
             patch += "<script type='text/javascript'>jasmine.getEnv().addReporter(new jasmine.JSReporter());</script>\n";
+          } else if (config['test_framework'] && config['test_framework'] == "jasmine") {
+            framework_scripts['jasmine2'].forEach(function(script) {
+              patch += "<script type='text/javascript' src='/_patch/" + script + "'></script>\n";
+            });
           } else if (config['test_framework'] && config['test_framework'] == "mocha") {
             framework_scripts['mocha'].forEach(function(script) {
               patch += "<script type='text/javascript' src='/_patch/" + script + "'></script>\n";