Squashed commit of work to make Jasmine a collection of isolated modules. Note now that in our test suite, "jasmine" now always refers to the build jasmine loaded from jasmine.js and "j$" always refers to the code in the src directories.

Also, dev_boot.js is now a copy of boot.js and has additional changes to load jasmine the second time, into the j$ reference.
2013-05-28 14:09:20 -07:00
parent 7516bba2b0
commit aca43bd3a3
52 changed files with 3828 additions and 3323 deletions
--- a/src/core/DelayedFunctionScheduler.js
+++ b/src/core/DelayedFunctionScheduler.js
@@ -1,104 +1,108 @@
-jasmine.DelayedFunctionScheduler = function() {
-  var self = this;
-  var scheduledFunctions = {};
-  var currentTime = 0;
-  var delayedFnCount = 0;
+getJasmineRequireObj().DelayedFunctionScheduler = function() {
+  function DelayedFunctionScheduler() {
+    var self = this;
+    var scheduledFunctions = {};
+    var currentTime = 0;
+    var delayedFnCount = 0;

-  self.tick = function(millis) {
-    millis = millis || 0;
-    runFunctionsWithinRange(currentTime, currentTime + millis);
-    currentTime = currentTime + millis;
-  };
-
-  self.scheduleFunction = function(funcToCall, millis, params, recurring, timeoutKey, runAtMillis) {
-    millis = millis || 0;
-    timeoutKey = timeoutKey || ++delayedFnCount;
-    runAtMillis = runAtMillis || (currentTime + millis);
-    scheduledFunctions[timeoutKey] = {
-      runAtMillis: runAtMillis,
-      funcToCall: funcToCall,
-      recurring: recurring,
-      params: params,
-      timeoutKey: timeoutKey,
-      millis: millis
+    self.tick = function(millis) {
+      millis = millis || 0;
+      runFunctionsWithinRange(currentTime, currentTime + millis);
+      currentTime = currentTime + millis;
    };
-    return timeoutKey;
-  };

-  self.removeFunctionWithId = function(timeoutKey) {
-    delete scheduledFunctions[timeoutKey];
-  };
+    self.scheduleFunction = function(funcToCall, millis, params, recurring, timeoutKey, runAtMillis) {
+      millis = millis || 0;
+      timeoutKey = timeoutKey || ++delayedFnCount;
+      runAtMillis = runAtMillis || (currentTime + millis);
+      scheduledFunctions[timeoutKey] = {
+        runAtMillis: runAtMillis,
+        funcToCall: funcToCall,
+        recurring: recurring,
+        params: params,
+        timeoutKey: timeoutKey,
+        millis: millis
+      };
+      return timeoutKey;
+    };

-  self.reset = function() {
-    currentTime = 0;
-    scheduledFunctions = {};
-    delayedFnCount = 0;
-  };
+    self.removeFunctionWithId = function(timeoutKey) {
+      delete scheduledFunctions[timeoutKey];
+    };

-  return self;
+    self.reset = function() {
+      currentTime = 0;
+      scheduledFunctions = {};
+      delayedFnCount = 0;
+    };

+    return self;

-  //finds/dupes functions within range and removes them.
-  function functionsWithinRange(startMillis, endMillis) {
-    var fnsToRun = [];
-    for (var timeoutKey in scheduledFunctions) {
-      var scheduledFunc = scheduledFunctions[timeoutKey];
-      if (scheduledFunc &&
+    // finds/dupes functions within range and removes them.
+    function functionsWithinRange(startMillis, endMillis) {
+      var fnsToRun = [];
+      for (var timeoutKey in scheduledFunctions) {
+        var scheduledFunc = scheduledFunctions[timeoutKey];
+        if (scheduledFunc &&
          scheduledFunc.runAtMillis >= startMillis &&
-            scheduledFunc.runAtMillis <= endMillis) {
-        //remove fn -- we'll reschedule later if it is recurring.
-        self.removeFunctionWithId(timeoutKey);
-        if (!scheduledFunc.recurring) {
-          fnsToRun.push(scheduledFunc); // schedules each function only once
-        } else {
-          fnsToRun.push(buildNthInstanceOf(scheduledFunc, 0));
-          var additionalTimesFnRunsInRange =
-            Math.floor((endMillis - scheduledFunc.runAtMillis) / scheduledFunc.millis);
-          for (var i = 0; i < additionalTimesFnRunsInRange; i++) {
-            fnsToRun.push(buildNthInstanceOf(scheduledFunc, i + 1));
+          scheduledFunc.runAtMillis <= endMillis) {
+
+          // remove fn -- we'll reschedule later if it is recurring.
+          self.removeFunctionWithId(timeoutKey);
+          if (!scheduledFunc.recurring) {
+            fnsToRun.push(scheduledFunc); // schedules each function only once
+          } else {
+            fnsToRun.push(buildNthInstanceOf(scheduledFunc, 0));
+            var additionalTimesFnRunsInRange =
+              Math.floor((endMillis - scheduledFunc.runAtMillis) / scheduledFunc.millis);
+            for (var i = 0; i < additionalTimesFnRunsInRange; i++) {
+              fnsToRun.push(buildNthInstanceOf(scheduledFunc, i + 1));
+            }
+            reschedule(buildNthInstanceOf(scheduledFunc, additionalTimesFnRunsInRange));
          }
-          reschedule(buildNthInstanceOf(scheduledFunc, additionalTimesFnRunsInRange));
        }
      }
+
+      return fnsToRun;
    }

-    return fnsToRun;
-  }
-
-  function buildNthInstanceOf(scheduledFunc, n) {
-    return {
-      runAtMillis: scheduledFunc.runAtMillis + (scheduledFunc.millis * n),
-      funcToCall: scheduledFunc.funcToCall,
-      params: scheduledFunc.params,
-      millis: scheduledFunc.millis,
-      recurring: scheduledFunc.recurring,
-      timeoutKey: scheduledFunc.timeoutKey
-    };
-  }
-
-  function reschedule(scheduledFn) {
-    self.scheduleFunction(scheduledFn.funcToCall,
-      scheduledFn.millis,
-      scheduledFn.params,
-      true,
-      scheduledFn.timeoutKey,
-      scheduledFn.runAtMillis + scheduledFn.millis);
-  }
-
-
-  function runFunctionsWithinRange(startMillis, endMillis) {
-    var funcsToRun = functionsWithinRange(startMillis, endMillis);
-    if (funcsToRun.length === 0) {
-      return;
+    function buildNthInstanceOf(scheduledFunc, n) {
+      return {
+        runAtMillis: scheduledFunc.runAtMillis + (scheduledFunc.millis * n),
+        funcToCall: scheduledFunc.funcToCall,
+        params: scheduledFunc.params,
+        millis: scheduledFunc.millis,
+        recurring: scheduledFunc.recurring,
+        timeoutKey: scheduledFunc.timeoutKey
+      };
    }

-    funcsToRun.sort(function(a, b) {
-      return a.runAtMillis - b.runAtMillis;
-    });
+    function reschedule(scheduledFn) {
+      self.scheduleFunction(scheduledFn.funcToCall,
+        scheduledFn.millis,
+        scheduledFn.params,
+        true,
+        scheduledFn.timeoutKey,
+        scheduledFn.runAtMillis + scheduledFn.millis);
+    }

-    for (var i = 0; i < funcsToRun.length; ++i) {
-      var funcToRun = funcsToRun[i];
-      funcToRun.funcToCall.apply(null, funcToRun.params);
+
+    function runFunctionsWithinRange(startMillis, endMillis) {
+      var funcsToRun = functionsWithinRange(startMillis, endMillis);
+      if (funcsToRun.length === 0) {
+        return;
+      }
+
+      funcsToRun.sort(function(a, b) {
+        return a.runAtMillis - b.runAtMillis;
+      });
+
+      for (var i = 0; i < funcsToRun.length; ++i) {
+        var funcToRun = funcsToRun[i];
+        funcToRun.funcToCall.apply(null, funcToRun.params);
+      }
    }
  }
+
+  return DelayedFunctionScheduler;
 };