node-schedule 1.2.3 → 1.2.4

package/.eslintrc

@@ -1,16 +1,17 @@
 {
   "env": {
-    "node": true
+    "node": true,
+    "es6": true
   },
   "rules": {
-    "eqeqeq": [2, "smart"],
-    "indent": [2, 2],
-    "no-constant-condition": false,
-    "no-redeclare": 1,
-    "no-underscore-dangle": false,
-    "no-use-before-define": [true,"nofunc"],
-    "quotes": [2, "single"],
-    "space-before-blocks": 2,
-    "strict": 2
+    "eqeqeq": ["error", "smart"],
+    "indent": ["error", 2, { "SwitchCase": 1 }],
+    "no-constant-condition": "off",
+    "no-redeclare": "warn",
+    "no-underscore-dangle": "off",
+    "no-use-before-define": ["warn","nofunc"],
+    "quotes": ["error", "single"],
+    "space-before-blocks": "error",
+    "strict": "error"
   }
 }

package/.travis.yml

@@ -5,5 +5,11 @@ node_js:
   - "4"
   - "6"
   - "7"
-before_script: npm run lint
+before_script: >
+  if nvm ls-remote --lts | grep "$(nvm current)"; then
+    echo "running on a LTS node version, linting"
+    npm test
+  else
+    echo "running on a non-LTS node version, skipping linting"
+  fi
 script: ./node_modules/.bin/istanbul cover ./node_modules/.bin/nodeunit test && cat ./coverage/lcov.info | ./node_modules/.bin/coveralls && rm -rf ./coverage

package/README.md

@@ -48,8 +48,9 @@ They also emit a `scheduled` event each time they're scheduled to run, and a
 `canceled` event when an invocation is canceled before it's executed (both events
 receive a JavaScript date object as a parameter). Note that jobs are scheduled the
 first time immediately, so if you create a job using the `scheduleJob()`
-convenience method, you'll miss the first `scheduled` event. Also note that
-`canceled` is the single-L American spelling.
+convenience method, you'll miss the first `scheduled` event, but you can query the
+invocation manually (see below). Also note that `canceled` is the single-L American
+spelling.
 
 ### Cron-style Scheduling
 
@@ -110,12 +111,6 @@ var j = schedule.scheduleJob(date, function(){
 });
 ```
 
-You can invalidate the job with the `cancel()` method:
-
-```js
-j.cancel();
-```
-
 To use current data in the future you can use binding:
 
 ```js
@@ -200,6 +195,32 @@ var j = schedule.scheduleJob({ start: startTime, end: endTime, rule: '*/1 * * *
 });
 ```
 
+### Handle Jobs and Job Invocations
+
+There are some function to get informations for a Job and to handle the Job and
+Invocations.
+
+
+#### job.cancel(reshedule)
+You can invalidate any job with the `cancel()` method:
+
+```js
+j.cancel();
+```
+All planned invocations will be canceled. When you set the parameter ***reschedule***
+to true then the Job is newly scheduled afterwards.
+
+#### job.cancelNext(reshedule)
+This method invalidates the next planned invocation or the job.
+When you set the parameter ***reschedule*** to true then the Job is newly scheduled
+afterwards.
+
+#### job.reschedule(spec)
+This method cancels all pending invocation and registers the Job completely new again using the given specification.
+Return true/false on success/failure.
+
+#### job.nextInvocation()
+This method returns a Date object for the planned next Invocation for this Job. If no invocation is planned the method returns null.
 
 ## Contributing
 

package/lib/schedule.js

@@ -15,6 +15,7 @@ var events = require('events'),
 
 /* Job object */
 var anonJobCounter = 0;
+var scheduledJobs = {};
 
 function isValidDate(date) {
   // Taken from http://stackoverflow.com/a/12372720/1562178
@@ -190,8 +191,8 @@ Job.prototype.schedule = function(spec) {
   if (typeof spec === 'object' && spec.rule) {
     start = spec.start || undefined;
     end = spec.end || undefined;
-    spec = spec.rule;
     tz = spec.tz;
+    spec = spec.rule;
 
     if (start) {
       if (!(start instanceof Date)) {
@@ -589,8 +590,6 @@ function scheduleNextRecurrence(rule, job, prevDate, endDate) {
 }
 
 /* Convenience methods */
-var scheduledJobs = {};
-
 function scheduleJob() {
   if (arguments.length < 2) {
     return null;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "node-schedule",
-  "version": "1.2.3",
+  "version": "1.2.4",
   "description": "A cron-like and not-cron-like job scheduler for Node.",
   "keywords": [
     "schedule",
@@ -12,7 +12,7 @@
   "main": "./lib/schedule.js",
   "scripts": {
     "test": "nodeunit",
-    "lint": "eslint lib"
+    "lint": "eslint lib test"
   },
   "author": {
     "name": "Matt Patenaude",
@@ -30,7 +30,7 @@
   },
   "devDependencies": {
     "coveralls": "^2.11.2",
-    "eslint": "^0.15.1",
+    "eslint": "^3.19.0",
     "istanbul": "^0.4.5",
     "nodeunit": "^0.10.2",
     "sinon": "^1.14.1"

package/test/.eslintrc

@@ -0,0 +1,5 @@
+{
+  "rules": {
+    "quotes": ["off"]
+  }
+}

package/test/convenience-method-test.js

@@ -37,32 +37,32 @@ module.exports = {
       clock.tick(3250);
     },
     "Job doesn't emit initial 'scheduled' event": function(test) {
-        var job = schedule.scheduleJob(new Date(Date.now() + 1000), function() {});
+      var job = schedule.scheduleJob(new Date(Date.now() + 1000), function() {});
 
-        job.on('scheduled', function() {
-          test.ok(false);
-        });
+      job.on('scheduled', function() {
+        test.ok(false);
+      });
 
-        setTimeout(function() {
-          test.done();
-        }, 1250);
+      setTimeout(function() {
+        test.done();
+      }, 1250);
 
-        clock.tick(1250);
-      },
-      "Won't run job if scheduled in the past": function(test) {
-        test.expect(1);
-        var job = schedule.scheduleJob(new Date(Date.now() - 3000), function() {
-          test.ok(false);
-        });
+      clock.tick(1250);
+    },
+    "Won't run job if scheduled in the past": function(test) {
+      test.expect(1);
+      var job = schedule.scheduleJob(new Date(Date.now() - 3000), function() {
+        test.ok(false);
+      });
 
-        test.equal(job, null);
+      test.equal(job, null);
 
-        setTimeout(function() {
-          test.done();
-        }, 1000);
+      setTimeout(function() {
+        test.done();
+      }, 1000);
 
-        clock.tick(1000);
-      }
+      clock.tick(1000);
+    }
   },
   ".scheduleJob(RecurrenceRule, fn)": {
     "Runs job at interval based on recur rule, repeating indefinitely": function(test) {
@@ -83,44 +83,44 @@ module.exports = {
       clock.tick(3250);
     },
     "Job doesn't emit initial 'scheduled' event": function(test) {
-        /*
-         * If this was Job#schedule it'd fire 4 times.
-         */
-        test.expect(3);
+      /*
+        * If this was Job#schedule it'd fire 4 times.
+        */
+      test.expect(3);
 
-        var rule = new schedule.RecurrenceRule();
-        rule.second = null; // fire every second
+      var rule = new schedule.RecurrenceRule();
+      rule.second = null; // fire every second
 
-        var job = new schedule.scheduleJob(rule, function() {});
+      var job = new schedule.scheduleJob(rule, function() {});
 
-        job.on('scheduled', function(runOnDate) {
-          test.ok(true);
-        });
+      job.on('scheduled', function(runOnDate) {
+        test.ok(true);
+      });
 
-        setTimeout(function() {
-          job.cancel();
-          test.done();
-        }, 3250);
+      setTimeout(function() {
+        job.cancel();
+        test.done();
+      }, 3250);
 
-        clock.tick(3250);
-      },
-      "Doesn't invoke job if recur rule schedules it in the past": function(test) {
-        test.expect(1);
-        var rule = new schedule.RecurrenceRule();
-        rule.year = 1960;
+      clock.tick(3250);
+    },
+    "Doesn't invoke job if recur rule schedules it in the past": function(test) {
+      test.expect(1);
+      var rule = new schedule.RecurrenceRule();
+      rule.year = 1960;
 
-        var job = schedule.scheduleJob(rule, function() {
-          test.ok(false);
-        });
-        
-        test.equal(job, null);
+      var job = schedule.scheduleJob(rule, function() {
+        test.ok(false);
+      });
+      
+      test.equal(job, null);
 
-        setTimeout(function() {
-          test.done();
-        }, 1000);
+      setTimeout(function() {
+        test.done();
+      }, 1000);
 
-        clock.tick(1000);
-      }
+      clock.tick(1000);
+    }
   },
   ".scheduleJob({...}, fn)": {
     "Runs job at interval based on object, repeating indefinitely": function(test) {
@@ -140,46 +140,46 @@ module.exports = {
       clock.tick(3250);
     },
     "Job doesn't emit initial 'scheduled' event": function(test) {
-        /*
-         * With Job#schedule this would be 3:
-         *  scheduled at time 0
-         *  scheduled at time 1000
-         *  scheduled at time 2000
-         */
-        test.expect(2);
-
-        var job = schedule.scheduleJob({
-          second: null // fire every second
-        }, function() {});
-
-        job.on('scheduled', function() {
-          test.ok(true);
-        });
+      /*
+        * With Job#schedule this would be 3:
+        *  scheduled at time 0
+        *  scheduled at time 1000
+        *  scheduled at time 2000
+        */
+      test.expect(2);
 
-        setTimeout(function() {
-          job.cancel();
-          test.done();
-        }, 2250);
+      var job = schedule.scheduleJob({
+        second: null // fire every second
+      }, function() {});
 
-        clock.tick(2250);
-      },
-      "Doesn't invoke job if object schedules it in the past": function(test) {
-        test.expect(1);
+      job.on('scheduled', function() {
+        test.ok(true);
+      });
+
+      setTimeout(function() {
+        job.cancel();
+        test.done();
+      }, 2250);
+
+      clock.tick(2250);
+    },
+    "Doesn't invoke job if object schedules it in the past": function(test) {
+      test.expect(1);
+    
+      var job = schedule.scheduleJob({
+        year: 1960
+      }, function() {
+        test.ok(false);
+      });
       
-        var job = schedule.scheduleJob({
-          year: 1960
-        }, function() {
-          test.ok(false);
-        });
-        
-        test.equal(job, null);
+      test.equal(job, null);
 
-        setTimeout(function() {
-          test.done();
-        }, 1000);
+      setTimeout(function() {
+        test.done();
+      }, 1000);
 
-        clock.tick(1000);
-      }
+      clock.tick(1000);
+    }
   },
   ".scheduleJob({...}, {...}, fn)": {
     "Callback called for each job if callback is provided": function(test) {

package/test/date-convenience-methods-test.js

@@ -38,7 +38,7 @@ module.exports = {
     }
   },
   "UTC": {
-     "Should accept a valid UTC date in milliseconds": function(test) {
+    "Should accept a valid UTC date in milliseconds": function(test) {
       test.expect(1);
 
       schedule.scheduleJob(new Date(Date.now() + 1000).getTime(), function() {

package/test/job-test.js

@@ -199,47 +199,47 @@ module.exports = {
       clock.tick(3250);
     },
     "Job emits 'scheduled' event for every next invocation": function(test) {
-        // Job will run 3 times but be scheduled 4 times, 4th run never happens
-        // due to cancel.
-        test.expect(4);
+      // Job will run 3 times but be scheduled 4 times, 4th run never happens
+      // due to cancel.
+      test.expect(4);
 
-        var job = new schedule.Job(function() {});
+      var job = new schedule.Job(function() {});
 
-        job.on('scheduled', function(runOnDate) {
-          test.ok(true);
-        });
+      job.on('scheduled', function(runOnDate) {
+        test.ok(true);
+      });
 
-        var rule = new schedule.RecurrenceRule();
-        rule.second = null; // fire every second
+      var rule = new schedule.RecurrenceRule();
+      rule.second = null; // fire every second
 
-        job.schedule(rule);
+      job.schedule(rule);
 
-        setTimeout(function() {
-          job.cancel();
-          test.done();
-        }, 3250);
+      setTimeout(function() {
+        job.cancel();
+        test.done();
+      }, 3250);
 
-        clock.tick(3250);
-      },
-      "Doesn't invoke job if recur rule schedules it in the past": function(test) {
-        test.expect(0);
+      clock.tick(3250);
+    },
+    "Doesn't invoke job if recur rule schedules it in the past": function(test) {
+      test.expect(0);
 
-        var job = new schedule.Job(function() {
-          test.ok(false);
-        });
+      var job = new schedule.Job(function() {
+        test.ok(false);
+      });
 
-        var rule = new schedule.RecurrenceRule();
-        rule.year = 2000;
+      var rule = new schedule.RecurrenceRule();
+      rule.year = 2000;
 
-        job.schedule(rule);
+      job.schedule(rule);
 
-        setTimeout(function() {
-          job.cancel();
-          test.done();
-        }, 1000);
+      setTimeout(function() {
+        job.cancel();
+        test.done();
+      }, 1000);
 
-        clock.tick(1000);
-      }
+      clock.tick(1000);
+    }
   },
   "#schedule({...})": {
     "Runs job at interval based on object, repeating indefinitely": function(test) {
@@ -261,45 +261,45 @@ module.exports = {
       clock.tick(3250);
     },
     "Job emits 'scheduled' event for every next invocation": function(test) {
-        // Job will run 3 times but be scheduled 4 times, 4th run never happens
-        // due to cancel.
-        test.expect(4);
+      // Job will run 3 times but be scheduled 4 times, 4th run never happens
+      // due to cancel.
+      test.expect(4);
 
-        var job = new schedule.Job(function() {});
+      var job = new schedule.Job(function() {});
 
-        job.on('scheduled', function(runOnDate) {
-          test.ok(true);
-        });
+      job.on('scheduled', function(runOnDate) {
+        test.ok(true);
+      });
 
-        job.schedule({
-          second: null // Fire every second
-        });
+      job.schedule({
+        second: null // Fire every second
+      });
 
-        setTimeout(function() {
-          job.cancel();
-          test.done();
-        }, 3250);
+      setTimeout(function() {
+        job.cancel();
+        test.done();
+      }, 3250);
 
-        clock.tick(3250);
-      },
-      "Doesn't invoke job if object schedules it in the past": function(test) {
-        test.expect(0);
+      clock.tick(3250);
+    },
+    "Doesn't invoke job if object schedules it in the past": function(test) {
+      test.expect(0);
 
-        var job = new schedule.Job(function() {
-          test.ok(false);
-        });
+      var job = new schedule.Job(function() {
+        test.ok(false);
+      });
 
-        job.schedule({
-          year: 2000
-        });
+      job.schedule({
+        year: 2000
+      });
 
-        setTimeout(function() {
-          job.cancel();
-          test.done();
-        }, 1000);
+      setTimeout(function() {
+        job.cancel();
+        test.done();
+      }, 1000);
 
-        clock.tick(1000);
-      }
+      clock.tick(1000);
+    }
   },
   "#schedule('jobName', {...})": {
     "Runs job with a custom name input": function(test) {

package/test/recurrence-rule-test.js

@@ -302,72 +302,72 @@ module.exports = {
     "nextInvocationDate on an invalid month should return null": function(test) {
       var rule = new schedule.RecurrenceRule();
       rule.month = 12;
-      var next = rule.nextInvocationDate(next);
+      var next = rule.nextInvocationDate();
       test.equal(next, null);
 
-      var rule = new schedule.RecurrenceRule();
-      rule.month = 'asdfasdf';
-      next = rule.nextInvocationDate(next);
-      test.equal(next, null);
+      var rule2 = new schedule.RecurrenceRule();
+      rule2.month = 'asdfasdf';
+      var next2 = rule2.nextInvocationDate(next);
+      test.equal(next2, null);
 
       test.done();
     },
     "nextInvocationDate on an invalid second should return null": function(test) {
       var rule = new schedule.RecurrenceRule();
       rule.second = 60;
-      var next = rule.nextInvocationDate(next);
+      var next = rule.nextInvocationDate();
       test.equal(next, null);
 
-      var rule = new schedule.RecurrenceRule();
-      rule.second = 'asdfasdf';
-      next = rule.nextInvocationDate(next);
-      test.equal(next, null);
+      var rule2 = new schedule.RecurrenceRule();
+      rule2.second = 'asdfasdf';
+      var next2 = rule2.nextInvocationDate();
+      test.equal(next2, null);
 
       test.done();
     },
     "nextInvocationDate on an invalid hour should return null": function(test) {
       var rule = new schedule.RecurrenceRule();
       rule.hour = 24;
-      var next = rule.nextInvocationDate(next);
+      var next = rule.nextInvocationDate();
       test.equal(next, null);
 
-      var rule = new schedule.RecurrenceRule();
-      rule.hour = 'asdfasdf';
-      next = rule.nextInvocationDate(next);
-      test.equal(next, null);
+      var rule2 = new schedule.RecurrenceRule();
+      rule2.hour = 'asdfasdf';
+      var next2 = rule2.nextInvocationDate();
+      test.equal(next2, null);
 
       test.done();
     },
     "nextInvocationDate on an invalid date should return null": function(test) {
       var rule = new schedule.RecurrenceRule();
       rule.date = 90;
-      var next = rule.nextInvocationDate(next);
+      var next = rule.nextInvocationDate();
       test.equal(next, null);
 
       // Test February
-      var rule = new schedule.RecurrenceRule();
-      rule.month = 1;
-      rule.date = 30;
-      next = rule.nextInvocationDate(next);
-      test.equal(next, null);
+      var rule2 = new schedule.RecurrenceRule();
+      rule2.month = 1;
+      rule2.date = 30;
+      var next2 = rule2.nextInvocationDate();
+      test.equal(next2, null);
 
-      var rule = new schedule.RecurrenceRule();
-      rule.date = 'asdfasdf';
-      next = rule.nextInvocationDate(next);
-      test.equal(next, null);
+      var rule3 = new schedule.RecurrenceRule();
+      rule3.date = 'asdfasdf';
+      var next3 = rule3.nextInvocationDate();
+      test.equal(next3, null);
 
       test.done();
     },
     "nextInvocationDate on an invalid dayOfWeek should return null": function(test) {
       var rule = new schedule.RecurrenceRule();
       rule.dayOfWeek = 90;
-      var next = rule.nextInvocationDate(next);
+      var next = rule.nextInvocationDate();
       test.equal(next, null);
 
-      var rule = new schedule.RecurrenceRule();
-      rule.dayOfWeek = 'asdfasdf';
-      next = rule.nextInvocationDate(next);
-      test.equal(next, null);
+      var rule2 = new schedule.RecurrenceRule();
+      rule2.dayOfWeek = 'asdfasdf';
+      var next2 = rule.nextInvocationDate();
+      test.equal(next2, null);
 
       test.done();
     }

package/.npmignore

@@ -1,2 +0,0 @@
-*.sublime*
-.npmrc