jb/dwf - updated Jasmine to move mock-timeout into the src dir & build; rake build simplified

.gitignore

@@ -1 +1,2 @@
-.idea
+.idea/
+.idea/inspectionProfiles/

Rakefile

@@ -1,20 +1,14 @@
 desc 'Builds lib/jasmine from source'
 task :build do
-  sources = [ "src/base.js",
+
-    "src/util.js",
+  # these files must be better
-    "src/Env.js",
+  sources  = ["src/base.js", "src/util.js", "src/Env.js"]
-    "src/ActionCollection.js",
+
-    "src/Matchers.js",
+  sources += Dir.glob('src/*.js').reject{|f| sources.include?(f)}
-    "src/NestedResults.js",
-    "src/PrettyPrinter.js",
-    "src/QueuedFunction.js",
-    "src/Reporters.js",
-    "src/Runner.js",
-    "src/Spec.js",
-    "src/Suite.js"]
 
   jasmine = File.new('lib/jasmine.js', 'w')
   sources.each do |source_filename|
     jasmine.puts(File.read(source_filename))
   end
 end
+

lib/jasmine.js

@@ -721,6 +721,164 @@ jasmine.Matchers.Any.prototype.toString = function() {
   return '<jasmine.any(' + this.expectedClass + ')>';
 };
 
+// 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] = undefined;
+  };
+
+  self.clearInterval = function(timeoutKey) {
+    self.scheduledFunctions[timeoutKey] = 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 != undefined &&
+        scheduledFunc.runAtMillis >= oldMillis &&
+        scheduledFunc.runAtMillis <= nowMillis) {
+      funcsToRun.push(scheduledFunc);
+      this.scheduledFunctions[timeoutKey] = 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
+  };
+};
+
+
+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() {
+    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: window.setTimeout,
+    clearTimeout: window.clearTimeout,
+    setInterval: window.setInterval,
+    clearInterval: window.clearInterval
+  },
+
+  assertInstalled: function() {
+    if (jasmine.Clock.installed != jasmine.Clock.defaultFakeTimer) {
+      throw new Error("Mock clock is not installed, use jasmine.Clock.useMock()");
+    }
+  },  
+
+  installed: null
+};
+jasmine.Clock.installed = jasmine.Clock.real;
+
+window.setTimeout = function(funcToCall, millis) {
+  return jasmine.Clock.installed.setTimeout.apply(this, arguments);
+};
+
+window.setInterval = function(funcToCall, millis) {
+  return jasmine.Clock.installed.setInterval.apply(this, arguments);
+};
+
+window.clearTimeout = function(timeoutKey) {
+  return jasmine.Clock.installed.clearTimeout.apply(this, arguments);
+};
+
+window.clearInterval = function(timeoutKey) {
+  return jasmine.Clock.installed.clearInterval.apply(this, arguments);
+};
+
 /**
  * Holds results; allows for the results array to hold another jasmine.NestedResults
  *

spec/runner.html

@@ -18,11 +18,11 @@
 <script type="text/javascript" src="../src/Runner.js"></script>
 <script type="text/javascript" src="../src/Spec.js"></script>
 <script type="text/javascript" src="../src/Suite.js"></script>
+<script type="text/javascript" src="../src/mock-timeout.js"></script>
 
 <script type="text/javascript" src="../lib/TrivialReporter.js"></script>
 <script type="text/javascript" src="../lib/json_reporter.js"></script>
 
-<script type="text/javascript" src="lib/mock-timeout.js"></script>
 
 <script type="text/javascript">
   jasmine.include('suites/ExceptionsTest.js', true);

src/mock-timeout.js

@@ -0,0 +1,158 @@
+// 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] = undefined;
+  };
+
+  self.clearInterval = function(timeoutKey) {
+    self.scheduledFunctions[timeoutKey] = 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 != undefined &&
+        scheduledFunc.runAtMillis >= oldMillis &&
+        scheduledFunc.runAtMillis <= nowMillis) {
+      funcsToRun.push(scheduledFunc);
+      this.scheduledFunctions[timeoutKey] = 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
+  };
+};
+
+
+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() {
+    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: window.setTimeout,
+    clearTimeout: window.clearTimeout,
+    setInterval: window.setInterval,
+    clearInterval: window.clearInterval
+  },
+
+  assertInstalled: function() {
+    if (jasmine.Clock.installed != jasmine.Clock.defaultFakeTimer) {
+      throw new Error("Mock clock is not installed, use jasmine.Clock.useMock()");
+    }
+  },  
+
+  installed: null
+};
+jasmine.Clock.installed = jasmine.Clock.real;
+
+window.setTimeout = function(funcToCall, millis) {
+  return jasmine.Clock.installed.setTimeout.apply(this, arguments);
+};
+
+window.setInterval = function(funcToCall, millis) {
+  return jasmine.Clock.installed.setInterval.apply(this, arguments);
+};
+
+window.clearTimeout = function(timeoutKey) {
+  return jasmine.Clock.installed.clearTimeout.apply(this, arguments);
+};
+
+window.clearInterval = function(timeoutKey) {
+  return jasmine.Clock.installed.clearInterval.apply(this, arguments);
+};
+