jazrb 0.1.0

data/vendor/jasmine/src/NestedResults.js

@@ -0,0 +1,99 @@
+/**
+ * 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;
+};
+
+/**
+ * Tracks a result's message.
+ * @param message
+ */
+jasmine.NestedResults.prototype.log = function(message) {
+  this.items_.push(new jasmine.MessageResult(message));
+};
+
+/**
+ * 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 != 'MessageResult') {
+    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;
+};
+
+jasmine.NestedResults.prototype.block_start = function() {
+  this.block_totalCount = this.totalCount;
+  this.block_passedCount = this.passedCount;
+  this.block_failedCount = this.failedCount;
+  this.block_skipped = this.skipped;
+  this.items_length = this.items_.length;
+};
+
+jasmine.NestedResults.prototype.block_finish = function() {
+};
+
+jasmine.NestedResults.prototype.block_abort = function() {
+  this.totalCount = this.block_totalCount;
+  this.passedCount = this.block_passedCount;
+  this.failedCount = this.block_failedCount;
+  this.skipped = this.block_skipped;
+  this.items_ = this.items_.slice(0,this.items_length);
+}

data/vendor/jasmine/src/PrettyPrinter.js

@@ -0,0 +1,122 @@
+/**
+ * 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.navigator /* && value.frames */ && value.setTimeout) {
+      this.emitScalar('<window>');
+    } else if (value instanceof jasmine.Matchers.Any) {
+      this.emitScalar(value.toString());
+    } 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) != 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;
+};

data/vendor/jasmine/src/Queue.js

@@ -0,0 +1,210 @@
+jasmine.Queue = function(env) {
+  this.env = env;
+  this.blocks = [];
+  this.running = false;
+  this.index = 0;
+  this.offset = 0;
+  this._stopped = 0;
+};
+
+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;
+  // debug("next_ !!!");
+  this.next_();
+};
+
+jasmine.Queue.prototype._start = function() {
+  var debug = window.console && window.console.debug || window.debug;
+  var self = this;
+  this._stopped--;
+  // debug("start " + this._stopped);
+  if(this._stopped == 0 && !this._signaled){
+    this._signaled = true;
+    // debug("next_ !!");
+    setTimeout(function(){
+      self._signaled = false;
+      self.next_();
+    },0);
+  }
+  if(this._timeout){
+    clearTimeout(this._timeout);
+    this._timeout = jasmine.undefined;
+  }
+};
+
+jasmine.Queue.prototype._stop = function(delay) {
+  var debug = window.console && window.console.debug || window.debug;
+  this._stopped++;
+  // debug("stop " + this._stopped);
+  if(this._stopped>0){
+    var self = this;
+    delay = delay || 4000;
+    if(this._timeout){
+      clearTimeout(this._timeout);
+    };
+    this._timeout = setTimeout(function test_timeout(){
+      // debug("failed");
+      self.blocks[0].spec.runs(function(){
+        self.blocks[0].spec.expect("test").toComplete();
+      });
+      self._start();
+    },delay);
+  }
+};
+
+jasmine.Queue.prototype._wait_for = function(condition, fn) {
+  var debug = window.console && window.console.debug || window.debug;
+  var self = this;
+  // debug(self.index,self.blocks[self.index],self.blocks[self.index].is_after);
+  self.blocks[0].spec.runs(function(){
+    // debug("queue " , self.blocks[0].spec.description,condition+"");
+    var timeout = function timeout() {
+      if(self._timeout) {
+        // debug("check " , self.blocks[0].spec.description,condition+"");
+        if(condition()){
+          // debug("okay " + self.blocks[0].spec.description);
+          fn && fn();
+          self._start();
+        } else {
+          // debug("retry");
+          setTimeout(timeout,50);
+        }
+      } else {
+        // debug("not going " + condition);
+        // debug("not going " + fn);
+        // debug("not going " + self.blocks[0].spec.description);
+      }
+    };
+    setTimeout(timeout,0);
+    // debug("?",self._stopped,condition+"");
+    self._stop();
+  });
+  self.blocks[self.index+1].is_after = self.blocks[self.index].is_after;
+};
+
+jasmine.Queue.prototype.isRunning = function() {
+  return this.running;
+};
+
+jasmine.Queue.LOOP_DONT_RECURSE = true;
+
+jasmine.Queue.prototype.next_ = function() {
+  var debug = window.console && window.console.debug || window.debug;
+  // debug("next");
+  var self = this;
+  var goAgain = true;
+
+  // debug("stopped",this._stopped,self.index,self.blocks.length);
+  while (goAgain && this._stopped <= 0) {
+    goAgain = false;
+    
+    if (self.index < self.blocks.length) {
+      var calledSynchronously = true;
+      var completedSynchronously = false;
+
+      var onComplete = function () {
+        if (jasmine.Queue.LOOP_DONT_RECURSE && calledSynchronously) {
+          completedSynchronously = true;
+          return;
+        }
+
+        /*
+        if( self.blocks[self.index]._anticipate !== jasmine.undefined ) {
+        }
+        */
+
+        self.offset = 0;
+        self.index++;
+
+        var now = new Date().getTime();
+        if(!self._signaled){
+          if (self.env.updateInterval && now - self.env.lastUpdate > self.env.updateInterval) {
+            self.env.lastUpdate = now;
+            // debug("next_ 00");
+            this._signaled = true;
+            self.env.setTimeout(function() {
+              this._signaled = false;
+              self.next_();
+            }, 0);
+          } else {
+            if (jasmine.Queue.LOOP_DONT_RECURSE && completedSynchronously) {
+              // debug("go again");
+              goAgain = true;
+            } else {
+              // debug("next_ 01");
+              self.next_();
+            }
+          }
+        }
+      };
+
+      var block = self.blocks[self.index];
+      var spec = block.spec;
+      var before = new Date().getTime();
+      var delay = 5000;
+      var runner = function runner() {
+        var saved = spec && spec.is_eventual;
+        try {
+          var now = new Date().getTime();
+          if(spec) {
+            if(now - before < delay){ 
+              spec.is_eventual = block.is_eventual;
+              spec.block_start();
+            }
+          }
+          block.execute(onComplete);
+          spec && spec.is_eventual&& spec.block_finish();
+        } catch(e) {
+          if(block.is_eventual){
+            spec && spec.block_abort();
+            setTimeout(function(){
+              runner();
+            },50);
+          } else {
+            throw e;
+          }
+        } finally {
+          spec && (spec.is_eventual = saved);
+        }
+      };
+      runner();
+
+      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;
+};
+
+

data/vendor/jasmine/src/Reporter.js

@@ -0,0 +1,27 @@
+/** 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.reportSpecResults = function(spec) {
+};
+
+//noinspection JSUnusedLocalSymbols
+jasmine.Reporter.prototype.log = function(str) {
+};
+

data/vendor/jasmine/src/Reporters.js

@@ -0,0 +1,43 @@
+/** JasmineReporters.reporter
+ *    Base object that will get called whenever a Spec, Suite, or Runner is done.  It is up to
+ *    descendants of this object to do something with the results (see json_reporter.js)
+ *
+ * @deprecated
+ */
+jasmine.Reporters = {};
+
+/**
+ * @deprecated
+ * @param callbacks
+ */
+jasmine.Reporters.reporter = function(callbacks) {
+  /**
+   * @deprecated
+   * @param callbacks
+   */
+  var that = {
+    callbacks: callbacks || {},
+
+    doCallback: function(callback, results) {
+      if (callback) {
+        callback(results);
+      }
+    },
+
+    reportRunnerResults: function(runner) {
+      that.doCallback(that.callbacks.runnerCallback, runner);
+    },
+    reportSuiteResults:  function(suite) {
+      that.doCallback(that.callbacks.suiteCallback, suite);
+    },
+    reportSpecResults:   function(spec) {
+      that.doCallback(that.callbacks.specCallback, spec);
+    },
+    log: function (str) {
+      if (this.console && this.console.log) this.console.log(str);
+    }
+  };
+
+  return that;
+};
+

data/vendor/jasmine/src/Runner.js

@@ -0,0 +1,68 @@
+/**
+ * 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_.push(beforeEachFunction);
+};
+
+jasmine.Runner.prototype.afterEach = function(afterEachFunction) {
+  afterEachFunction.typeName = 'afterEach';
+  this.after_.push(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.results = function() {
+  return this.queue.results();
+};