node-schedule 0.5.0 → 1.1.0

package/.npmignore

@@ -1,6 +1,2 @@
-coverage
-node_modules
-node-schedule.tmproj
-.DS_Store
-npm-debug.log
-
+*.sublime*
+.npmrc

package/CONTRIBUTING.md

@@ -0,0 +1,31 @@
+## Rules
+1. **No `--force` pushes** or modifying the git history in any way
+2. Follow existing code style
+3. Pull requests with tests are much more likely to be accepted
+4. Follow the guidelines below
+
+## Bugfix or Feature?
+
+This project uses the [gitflow workflow](https://www.atlassian.com/git/tutorials/comparing-workflows/gitflow-workflow). Simply put, you need to decide if your contribution will be a bug fix that could be released as a patch, or a feature that will end up being a minor or major release.
+
+### Found a bug that can be fixed without affecting the API?
+
+1. **Fork** this repo
+2. Create a new branch from `master` to work in
+3. **Add tests** if needed
+4. Make sure your code **lints** by running `npm run lint`
+5. Make sure your code **passes tests** by running `npm test`
+6. Submit a **pull request** against the `master` branch
+
+### New feature or anything that would result in a change to the API?
+
+1. **Fork** this repo
+2. Create a new branch from `develop` to work in
+3. **Add tests** to as needed
+4. Make sure your code **lints** by running `npm run lint`
+5. Make sure your code **passes tests** by running `npm test`
+6. Submit a **pull request** against the `develop` branch
+
+## Releases
+
+Declaring formal releases remains the prerogative of the project maintainer.

package/README.md

@@ -1,28 +1,194 @@
-# node-schedule
+# Node Schedule
 
-[![NPM version](http://img.shields.io/npm/v/node-schedule.svg)](https://www.npmjs.com/package/node-schedule) [![Downloads](https://img.shields.io/npm/dm/node-schedule.svg)](https://www.npmjs.com/package/node-schedule)  [![Build Status](https://travis-ci.org/node-schedule/node-schedule.svg?branch=master)](https://travis-ci.org/node-schedule/node-schedule) [![Join the chat at https://gitter.im/node-schedule/node-schedule](https://img.shields.io/badge/gitter-chat-green.svg)](https://gitter.im/node-schedule/node-schedule?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
+[![NPM version](http://img.shields.io/npm/v/node-schedule.svg)](https://www.npmjs.com/package/node-schedule)
+[![Downloads](https://img.shields.io/npm/dm/node-schedule.svg)](https://www.npmjs.com/package/node-schedule)
+[![Build Status](https://travis-ci.org/node-schedule/node-schedule.svg?branch=master)](https://travis-ci.org/node-schedule/node-schedule)
+[![Join the chat at https://gitter.im/node-schedule/node-schedule](https://img.shields.io/badge/gitter-chat-green.svg)](https://gitter.im/node-schedule/node-schedule?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
 
 [![NPM](https://nodei.co/npm/node-schedule.png?downloads=true)](https://nodei.co/npm/node-schedule/)
 
->__Announcement:__ Node Schedule is looking for add additional collaborators with commit access. If you are actively involved in open source, ping [Tejas Manohar](http://tejas.io) (via [email](mailto:me@tejas.io), [Twitter](https://twitter.com/tejasmanohar), etc.) to express interest. Those who already contribute to the project are preferred.
+>__Announcement:__ Node Schedule is looking for add additional collaborators
+with commit access. If you are actively involved in open source,
+ping [Tejas Manohar] via [email](mailto:me@tejas.io) to express interest.
+Those who already contribute to the project are preferred.
 
-node-schedule is a flexible cron-like and not-cron-like job scheduler for Node.js. It allows you to schedule jobs (arbitrary functions) for execution at specific dates, with optional recurrence rules. It only uses a single timer at any given time (rather than reevaluating upcoming jobs every second/minute).
-
-Read more about the module's core functions on the [About](https://github.com/node-schedule/node-schedule/wiki/About) page of the wiki.
+Node Schedule is a flexible cron-like and not-cron-like job scheduler for Node.js.
+It allows you to schedule jobs (arbitrary functions) for execution at
+specific dates, with optional recurrence rules. It only uses a single timer
+at any given time (rather than reevaluating upcoming jobs every second/minute).
 
 ## Usage
 
-Check out our wonderful [wiki] for usage instructions.
+### Installation
 
+You can install using [npm](https://www.npmjs.com/package/node-schedule).
 
-## Contributing
+```
+npm install node-schedule
+```
+
+### Overview
+
+Node Schedule is for time-based scheduling, not interval-based scheduling.
+While you can easily bend it to your will, if you only want to do something like
+"run this function every 5 minutes", you'll find `setInterval` much easier to use,
+and far more appropriate. But if you want to, say, "run this function at the :20
+and :50 of every hour on the third Tuesday of every month," you'll find that
+Node Schedule suits your needs better. Additionally, Node Schedule has Windows
+support unlike true cron since the node runtime is now fully supported.
+
+Note that Node Schedule is designed for in-process scheduling, i.e. scheduled jobs
+will only fire as long as your script is running, and the schedule will disappear
+when execution completes. If you need to schedule jobs that will persist even when
+your script *isn't* running, consider using actual [cron].
+
+### Jobs and Scheduling
+
+Every scheduled job in Node Schedule is represented by a `Job` object. You can
+create jobs manually, then execute the `schedule()` method to apply a schedule,
+or use the convenience function `scheduleJob()` as demonstrated below.
+
+`Job` objects are `EventEmitter`'s, and emit a `run` event after each execution.
+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.
+
+### Cron-style Scheduling
+
+The cron format consists of:
+```
+*    *    *    *    *    *
+┬    ┬    ┬    ┬    ┬    ┬
+│    │    │    │    │    |
+│    │    │    │    │    └ day of week (0 - 7) (0 or 7 is Sun)
+│    │    │    │    └───── month (1 - 12)
+│    │    │    └────────── day of month (1 - 31)
+│    │    └─────────────── hour (0 - 23)
+│    └──────────────────── minute (0 - 59)
+└───────────────────────── second (0 - 59, OPTIONAL)
+```
+
+Examples with the cron format:
+
+```js
+var schedule = require('node-schedule');
+
+var j = schedule.scheduleJob('42 * * * *', function(){
+  console.log('The answer to life, the universe, and everything!');
+});
+```
+
+And:
+
+```js
+var j = schedule.scheduleJob('0 17 ? * 0,4-6', function(){
+  console.log('Today is recognized by Rebecca Black!');
+});
+```
+
+Execute a cron job every 5 Minutes = */5 * * * *
+
+#### Unsupported Cron Features
+
+Currently, `W` (nearest weekday), `L` (last day of month/week), and `#` (nth weekday
+of the month) are not supported. Most other features supported by popular cron
+implementations should work just fine.
+
+[cron-parser] is used to parse crontab instructions.
 
-This module was originally developed by [Matt Patenaude], and is now maintained by [Tejas Manohar] and [other wonderful contributors].
+### Date-based Scheduling
+
+Say you very specifically want a function to execute at 5:30am on December 21, 2012.
+Remember - in JavaScript - 0 - January, 11 - December.
+
+```js
+var schedule = require('node-schedule');
+var date = new Date(2012, 11, 21, 5, 30, 0);
+
+var j = schedule.scheduleJob(date, function(){
+  console.log('The world is going to end today.');
+});
+```
+
+You can invalidate the job with the `cancel()` method:
+
+```js
+j.cancel();
+```
+
+To use current data in the future you can use binding:
+
+```js
+var schedule = require('node-schedule');
+var date = new Date(2012, 11, 21, 5, 30, 0);
+var x = 'Tada!';
+var j = schedule.scheduleJob(date, function(y){
+  console.log(y);
+}.bind(null,x));
+x = 'Changing Data';
+```
+This will log 'Tada!' when the scheduled Job runs, rather than 'Changing Data',
+which x changes to immediately after scheduling.
+
+### Recurrence Rule Scheduling
+
+You can build recurrence rules to specify when a job should recur. For instance,
+consider this rule, which executes the function every hour at 42 minutes after the hour:
+
+```js
+var schedule = require('node-schedule');
+
+var rule = new schedule.RecurrenceRule();
+rule.minute = 42;
+
+var j = schedule.scheduleJob(rule, function(){
+  console.log('The answer to life, the universe, and everything!');
+});
+```
+
+You can also use arrays to specify a list of acceptable values, and the `Range`
+object to specify a range of start and end values, with an optional step parameter.
+For instance, this will print a message on Thursday, Friday, Saturday, and Sunday at 5pm:
+
+```js
+var rule = new schedule.RecurrenceRule();
+rule.dayOfWeek = [0, new schedule.Range(4, 6)];
+rule.hour = 17;
+rule.minute = 0;
+
+var j = schedule.scheduleJob(rule, function(){
+  console.log('Today is recognized by Rebecca Black!');
+});
+```
+
+> **Note**: It's worth noting that the default value of a component of a recurrence rule is
+`null` (except for seconds, which is 0 for familiarity with cron). *If we did not
+explicitly set `minute` to 0 above, the message would have instead been logged at
+5:00pm, 5:01pm, 5:02pm, ..., 5:59pm.* Probably not what you want.
+
+#### Object Literal Syntax
+
+To make things a little easier, an object literal syntax is also supported, like
+in this example which will log a message every Sunday at 2:30pm:
+
+```js
+var j = schedule.scheduleJob({hour: 14, minute: 30, dayOfWeek: 0}, function(){
+  console.log('Time for tea!');
+});
+```
+
+## Contributing
 
-We'd love to get your contributions. Individuals making significant and valuable contributions are given commit-access to the project to contribute as they see fit.
+This module was originally developed by [Matt Patenaude], and is now maintained by
+[Tejas Manohar] and [other wonderful contributors].
 
-Before jumping in, check out our [Contributing](https://github.com/node-schedule/node-schedule/wiki/Contributing) page on the wiki!
+We'd love to get your contributions. Individuals making significant and valuable
+contributions are given commit-access to the project to contribute as they see fit.
 
+Before jumping in, check out our [Contributing] page guide!
 
 ## Copyright and license
 
@@ -32,9 +198,10 @@ Licensed under the **[MIT License] [license]**.
 
 
 [cron]: http://unixhelp.ed.ac.uk/CGI/man-cgi?crontab+5
-[wiki]: https://github.com/node-schedule/node-schedule/wiki
-[contributing]: https://github.com/node-schedule/node-schedule/blob/master/CONTRIBUTING.md
+[Contributing]: https://github.com/node-schedule/node-schedule/blob/master/CONTRIBUTING.md
 [Matt Patenaude]: https://github.com/mattpat
+[Tejas Manohar]: http://tejas.io
 [license]: https://github.com/node-schedule/node-schedule/blob/master/LICENSE
 [Tejas Manohar]: https://github.com/tejasmanohar
 [other wonderful contributors]: https://github.com/node-schedule/node-schedule/graphs/contributors
+[cron-parser]: https://github.com/harrisiirak/cron-parser

package/lib/schedule.js

@@ -8,17 +8,26 @@
 
 var events = require('events'),
   util = require('util'),
-  increment = require('./increment.js'),
   cronParser = require('cron-parser'),
+  CronDate = require('cron-parser/lib/date'),
   lt = require('long-timeout');
 
 /* Job object */
 var anonJobCounter = 0;
 
+function isValidDate(date) {
+  // Taken from http://stackoverflow.com/a/12372720/1562178
+  // If getTime() returns NaN it'll return false anyway
+  return date.getTime() === date.getTime();
+}
+
 function Job(name, job, callback) {
   // setup a private pendingInvocations variable
   var pendingInvocations = [];
 
+  //setup a private number of invocations variable
+  var triggeredJobs = 0;
+
   // Set scope vars
   var jobName = name && typeof name === 'string' ? name : '<Anonymous Job ' + (++anonJobCounter) + '>';
   this.job = name && typeof name === 'function' ? name : job;
@@ -33,10 +42,12 @@ function Job(name, job, callback) {
   }
 
   // Check for generator
-  if (typeof this.job === 'function' && this.job.prototype.next) {
+  if (typeof this.job === 'function' &&
+      this.job.prototype &&
+      this.job.prototype.next) {
     this.job = function() {
       return this.next().value;
-    }.bind(this.job());
+    }.bind(this.job.call(this));
   }
 
   // define properties
@@ -65,6 +76,12 @@ function Job(name, job, callback) {
 
     return false;
   };
+  this.triggeredJobs = function() {
+    return triggeredJobs;
+  };
+  this.setTriggeredJobs = function(triggeredJob) {
+    triggeredJobs = triggeredJob;
+  };
   this.cancel = function(reschedule) {
     reschedule = (typeof reschedule == 'boolean') ? reschedule : false;
 
@@ -92,7 +109,7 @@ function Job(name, job, callback) {
     // remove from scheduledJobs if reschedule === false
     if (!reschedule) {
       if (this.name) {
-        scheduledJobs[this.name] = null;
+        delete scheduledJobs[this.name];
       }
     }
 
@@ -119,6 +136,26 @@ function Job(name, job, callback) {
 
     return true;
   };
+  this.reschedule = function(spec) {
+    var inv;
+    var cInvs = pendingInvocations.slice();
+
+    for (var j = 0; j < cInvs.length; j++) {
+      inv = cInvs[j];
+
+      cancelInvocation(inv);
+    }
+
+    pendingInvocations = [];
+
+    if (this.schedule(spec)) {
+      this.setTriggeredJobs(0);
+      return true;
+    } else {
+      pendingInvocations = cInvs;
+      return false;
+    }
+  };
   this.nextInvocation = function() {
     if (!pendingInvocations.length) {
       return null;
@@ -134,6 +171,7 @@ util.inherits(Job, events.EventEmitter);
 
 Job.prototype.invoke = function() {
   if (typeof this.job == 'function') {
+    this.setTriggeredJobs(this.triggeredJobs() + 1);
     this.job();
   } else {
     this.job.execute();
@@ -161,10 +199,12 @@ Job.prototype.schedule = function(spec) {
       spec = new Date(spec);
     }
 
-    if (spec instanceof Date) {
-      inv = new Invocation(self, spec);
-      scheduleInvocation(inv);
-      success = self.trackInvocation(inv);
+    if ((spec instanceof Date) && (isValidDate(spec))) {
+      if (spec.getTime() >= Date.now()) {
+        inv = new Invocation(self, spec);
+        scheduleInvocation(inv);
+        success = self.trackInvocation(inv);
+      }
     } else if (type === 'object') {
       if (!(spec instanceof RecurrenceRule)) {
         var r = new RecurrenceRule();
@@ -278,19 +318,16 @@ function RecurrenceRule(year, month, date, dayOfWeek, hour, minute, second) {
 
 RecurrenceRule.prototype.nextInvocationDate = function(base) {
   base = (base instanceof Date) ? base : (new Date());
-  increment.addDateConvenienceMethods(base);
   if (!this.recurs) {
     return null;
   }
 
   var now = new Date();
-  increment.addDateConvenienceMethods(now);
   if (this.year !== null && (typeof this.year == 'number') && this.year < now.getFullYear()) {
     return null;
   }
 
-  var next = new Date(base.getTime());
-  increment.addDateConvenienceMethods(next);
+  var next = new CronDate(base.getTime());
   next.addSecond();
 
   while (true) {
@@ -360,7 +397,7 @@ function runOnDate(date, job) {
   var then = date.getTime();
 
   if (then < now) {
-    process.nextTick(job);
+    setImmediate(job);
     return null;
   }
 
@@ -471,6 +508,21 @@ function scheduleJob() {
   return null;
 }
 
+function rescheduleJob(job, spec) {
+  if (job instanceof Job) {
+    if (job.reschedule(spec)) {
+      return job;
+    }
+  } else if (typeof job == 'string' || job instanceof String) {
+    if (job in scheduledJobs && scheduledJobs.hasOwnProperty(job)) {
+      if (scheduledJobs[job].reschedule(spec)) {
+        return scheduledJobs[job];
+      }
+    }
+  }
+  return null;
+}
+
 function cancelJob(job) {
   var success = false;
   if (job instanceof Job) {
@@ -490,6 +542,6 @@ module.exports.Range = Range;
 module.exports.RecurrenceRule = RecurrenceRule;
 module.exports.Invocation = Invocation;
 module.exports.scheduleJob = scheduleJob;
+module.exports.rescheduleJob = rescheduleJob;
 module.exports.scheduledJobs = scheduledJobs;
 module.exports.cancelJob = cancelJob;
-module.exports.addDateConvenienceMethods = increment.addDateConvenienceMethods;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "node-schedule",
-  "version": "0.5.0",
+  "version": "1.1.0",
   "description": "A cron-like and not-cron-like job scheduler for Node.",
   "keywords": [
     "schedule",
@@ -23,7 +23,7 @@
     "url": "https://github.com/node-schedule/node-schedule.git"
   },
   "dependencies": {
-    "cron-parser": "0.6.2",
+    "cron-parser": "1.1.0",
     "long-timeout": "0.0.2"
   },
   "devDependencies": {

package/test/convenience-method-test.js

@@ -48,17 +48,21 @@ module.exports = {
         }, 1250);
 
         clock.tick(1250);
-      }
-      /*,
-        "Won't run job if scheduled in the past": function(test) {
-          schedule.scheduleJob(new Date(Date.now() - 3000), function() {
+      },
+      "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);
 
-          setTimeout(function() {
+        setTimeout(function() {
           test.done();
-          }, 1000);
-        }*/
+        }, 1000);
+
+        clock.tick(1000);
+      }
   },
   ".scheduleJob(RecurrenceRule, fn)": {
     "Runs job at interval based on recur rule, repeating indefinitely": function(test) {
@@ -99,21 +103,24 @@ module.exports = {
         }, 3250);
 
         clock.tick(3250);
-      }
-      /*,
-        "Doesn't invoke job if recur rule schedules it in the past": function(test) {
-          var rule = new schedule.RecurrenceRule();
-          rule.year = 2000;
+      },
+      "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() {
+        var job = schedule.scheduleJob(rule, function() {
           test.ok(false);
-          });
+        });
+        
+        test.equal(job, null);
 
-          setTimeout(function() {
-          job.cancel();
+        setTimeout(function() {
           test.done();
-          }, 1000);
-        }*/
+        }, 1000);
+
+        clock.tick(1000);
+      }
   },
   ".scheduleJob({...}, fn)": {
     "Runs job at interval based on object, repeating indefinitely": function(test) {
@@ -155,20 +162,24 @@ module.exports = {
         }, 2250);
 
         clock.tick(2250);
-      }
-      /*,
-        "Doesn't invoke job if object schedules it in the past": function(test) {
-          var job = new schedule.scheduleJob({
-          year: 2000
-          }, function() {
+      },
+      "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);
-          });
+        });
+        
+        test.equal(job, null);
 
-          setTimeout(function() {
-          job.cancel();
+        setTimeout(function() {
           test.done();
-          }, 1000);
-        }*/
+        }, 1000);
+
+        clock.tick(1000);
+      }
   },
   ".scheduleJob({...}, {...}, fn)": {
     "Callback called for each job if callback is provided": function(test) {
@@ -188,6 +199,362 @@ module.exports = {
       clock.tick(3250);
     }
   },
+  ".rescheduleJob(job, {...})": {
+    "Reschedule jobs from object based to object based": function(test) {
+      test.expect(3);
+
+      var job = new schedule.scheduleJob({
+        second: null
+      }, function() {
+        test.ok(true);
+      });
+
+      setTimeout(function() {
+        schedule.rescheduleJob(job, {
+          minute: null
+        });
+      }, 3250);
+
+      setTimeout(function() {
+        job.cancel();
+        test.done();
+      }, 5000);
+
+      clock.tick(5000);
+    },
+    "Reschedule jobs from every minutes to every second": function(test) {
+      test.expect(3);
+
+      var timeout = 60 * 1000;
+
+      var job = new schedule.scheduleJob({
+        minute: null
+      }, function() {
+        test.ok(true);
+      });
+
+      setTimeout(function() {
+        schedule.rescheduleJob(job, {
+          second: null
+        });
+      }, timeout);
+
+      setTimeout(function() {
+        job.cancel();
+        test.done();
+      }, timeout + 2250);
+
+      clock.tick(timeout + 2250);
+    }
+  },
+  ".rescheduleJob(job, Date)": {
+    "Reschedule jobs from Date to Date": function(test) {
+      test.expect(1);
+
+      var job = new schedule.scheduleJob(new Date(Date.now() + 3000), function() {
+        test.ok(true);
+      });
+
+      setTimeout(function() {
+        schedule.rescheduleJob(job, new Date(Date.now() + 5000));
+      }, 1000);
+
+      setTimeout(function() {
+        test.done();
+      }, 6150);
+
+      clock.tick(6150);
+    },
+    "Reschedule jobs that has been executed": function(test) {
+      test.expect(2);
+
+      var job = new schedule.scheduleJob(new Date(Date.now() + 1000), function() {
+        test.ok(true);
+      });
+
+      setTimeout(function() {
+        schedule.rescheduleJob(job, new Date(Date.now() + 2000));
+      }, 2000);
+
+      setTimeout(function() {
+        test.done();
+      }, 5150);
+
+      clock.tick(5150);
+    }
+  },
+  ".rescheduleJob(job, RecurrenceRule)": {
+    "Reschedule jobs from RecurrenceRule to RecurrenceRule": function(test) {
+      test.expect(3);
+
+      var timeout = 60 * 1000;
+
+      var rule = new schedule.RecurrenceRule();
+      rule.second = null; // fire every second
+
+      var job = schedule.scheduleJob(rule, function() {
+        test.ok(true);
+      });
+
+      var newRule = new schedule.RecurrenceRule();
+      newRule.minute = null;
+
+      setTimeout(function() {
+        schedule.rescheduleJob(job, newRule);
+      }, 2250);
+
+      setTimeout(function() {
+        job.cancel();
+        test.done();
+      }, timeout + 2250);
+
+      clock.tick(timeout + 2250);
+    },
+    "Reschedule jobs from RecurrenceRule to Date": function(test) {
+      test.expect(3);
+
+      var rule = new schedule.RecurrenceRule();
+      rule.second = null; // fire every second
+
+      var job = schedule.scheduleJob(rule, function() {
+        test.ok(true);
+      });
+
+      setTimeout(function() {
+        schedule.rescheduleJob(job, new Date(Date.now() + 2000));
+      }, 2150);
+
+      setTimeout(function() {
+        test.done();
+      }, 4250);
+
+      clock.tick(4250);
+    },
+    "Reschedule jobs from RecurrenceRule to {...}": function(test) {
+      test.expect(3);
+
+      var timeout = 60 * 1000;
+
+      var rule = new schedule.RecurrenceRule();
+      rule.second = null; // fire every second
+
+      var job = schedule.scheduleJob(rule, function() {
+        test.ok(true);
+      });
+
+      setTimeout(function() {
+        schedule.rescheduleJob(job, {
+          minute: null
+        });
+      }, 2150);
+
+      setTimeout(function() {
+        job.cancel();
+        test.done();
+      }, timeout + 2150);
+
+      clock.tick(timeout + 2150);
+    },
+    "Reschedule jobs that is not available": function(test) {
+      test.expect(4);
+
+      var rule = new schedule.RecurrenceRule();
+      rule.second = null; // fire every second
+
+      var job = schedule.scheduleJob(rule, function() {
+        test.ok(true);
+      });
+
+      setTimeout(function() {
+        schedule.rescheduleJob(null, new Date(Date.now() + 2000));
+      }, 2150);
+
+      setTimeout(function() {
+        job.cancel();
+        test.done();
+      }, 4250);
+
+      clock.tick(4250);
+    }
+  },
+  '.rescheduleJob("job name", {...})': {
+    "Reschedule jobs from object based to object based": function(test) {
+      test.expect(3);
+
+      var job = new schedule.scheduleJob({
+        second: null
+      }, function() {
+        test.ok(true);
+      });
+
+      setTimeout(function() {
+        schedule.rescheduleJob(job.name, {
+          minute: null
+        });
+      }, 3250);
+
+      setTimeout(function() {
+        job.cancel();
+        test.done();
+      }, 5000);
+
+      clock.tick(5000);
+    },
+    "Reschedule jobs from every minutes to every second": function(test) {
+      test.expect(3);
+
+      var timeout = 60 * 1000;
+
+      var job = new schedule.scheduleJob({
+        minute: null
+      }, function() {
+        test.ok(true);
+      });
+
+      setTimeout(function() {
+        schedule.rescheduleJob(job.name, {
+          second: null
+        });
+      }, timeout);
+
+      setTimeout(function() {
+        job.cancel();
+        test.done();
+      }, timeout + 2250);
+
+      clock.tick(timeout + 2250);
+    }
+  },
+  '.rescheduleJob("job name", Date)': {
+    "Reschedule jobs from Date to Date": function(test) {
+      test.expect(1);
+
+      var job = new schedule.scheduleJob(new Date(Date.now() + 3000), function() {
+        test.ok(true);
+      });
+
+      setTimeout(function() {
+        schedule.rescheduleJob(job.name, new Date(Date.now() + 5000));
+      }, 1000);
+
+      setTimeout(function() {
+        test.done();
+      }, 6150);
+
+      clock.tick(6150);
+    },
+    "Reschedule jobs that has been executed": function(test) {
+      test.expect(2);
+
+      var job = new schedule.scheduleJob(new Date(Date.now() + 1000), function() {
+        test.ok(true);
+      });
+
+      setTimeout(function() {
+        schedule.rescheduleJob(job.name, new Date(Date.now() + 2000));
+      }, 2000);
+
+      setTimeout(function() {
+        test.done();
+      }, 5150);
+
+      clock.tick(5150);
+    }
+  },
+  '.rescheduleJob("job name", RecurrenceRule)': {
+    "Reschedule jobs from RecurrenceRule to RecurrenceRule": function(test) {
+      test.expect(3);
+
+      var timeout = 60 * 1000;
+
+      var rule = new schedule.RecurrenceRule();
+      rule.second = null; // fire every second
+
+      var job = schedule.scheduleJob(rule, function() {
+        test.ok(true);
+      });
+
+      var newRule = new schedule.RecurrenceRule();
+      newRule.minute = null;
+
+      setTimeout(function() {
+        schedule.rescheduleJob(job.name, newRule);
+      }, 2250);
+
+      setTimeout(function() {
+        job.cancel();
+        test.done();
+      }, timeout + 2250);
+
+      clock.tick(timeout + 2250);
+    },
+    "Reschedule jobs from RecurrenceRule to Date": function(test) {
+      test.expect(3);
+
+      var rule = new schedule.RecurrenceRule();
+      rule.second = null; // fire every second
+
+      var job = schedule.scheduleJob(rule, function() {
+        test.ok(true);
+      });
+
+      setTimeout(function() {
+        schedule.rescheduleJob(job.name, new Date(Date.now() + 2000));
+      }, 2150);
+
+      setTimeout(function() {
+        test.done();
+      }, 4250);
+
+      clock.tick(4250);
+    },
+    "Reschedule jobs from RecurrenceRule to {...}": function(test) {
+      test.expect(3);
+
+      var timeout = 60 * 1000;
+
+      var rule = new schedule.RecurrenceRule();
+      rule.second = null; // fire every second
+
+      var job = schedule.scheduleJob(rule, function() {
+        test.ok(true);
+      });
+
+      setTimeout(function() {
+        schedule.rescheduleJob(job.name, {
+          minute: null
+        });
+      }, 2150);
+
+      setTimeout(function() {
+        job.cancel();
+        test.done();
+      }, timeout + 2150);
+
+      clock.tick(timeout + 2150);
+    },
+    "Reschedule jobs that is not available": function(test) {
+      test.expect(4);
+
+      var rule = new schedule.RecurrenceRule();
+      rule.second = null; // fire every second
+
+      var job = schedule.scheduleJob(rule, function() {
+        test.ok(true);
+      });
+
+      setTimeout(function() {
+        schedule.rescheduleJob("Blah", new Date(Date.now() + 2000));
+      }, 2150);
+
+      setTimeout(function() {
+        job.cancel();
+        test.done();
+      }, 4250);
+
+      clock.tick(4250);
+    }
+  },
   ".cancelJob(Job)": {
     "Prevents all future invocations of Job passed in": function(test) {
       test.expect(2);

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

@@ -12,27 +12,6 @@ module.exports = {
     clock = sinon.useFakeTimers();
     cb();
   },
-  "Date Enhancements": {
-    "Should Not add date convenience methods unless explicitly specified": function(test) {
-      test.ok(typeof Date.addYear !== 'function');
-      test.ok(typeof Date.addMonth !== 'function');
-      test.ok(typeof Date.addDay !== 'function');
-      test.ok(typeof Date.addHour !== 'function');
-      test.ok(typeof Date.addMinute !== 'function');
-      test.ok(typeof Date.addSecond !== 'function');
-      test.done();
-    },
-    "Should add date convenience methods when explicitly specified": function(test) {
-      schedule.addDateConvenienceMethods(Date);
-      test.ok(typeof Date.addYear === 'function');
-      test.ok(typeof Date.addMonth === 'function');
-      test.ok(typeof Date.addDay === 'function');
-      test.ok(typeof Date.addHour === 'function');
-      test.ok(typeof Date.addMinute === 'function');
-      test.ok(typeof Date.addSecond === 'function');
-      test.done();
-    }
-  },
   "Date string": {
     "Should accept a valid date string": function(test) {
       test.expect(1);
@@ -46,6 +25,16 @@ module.exports = {
       }, 1250);
 
       clock.tick(1250);
+    },
+    "Should not accept invalid string as valid date": function(test) {
+      test.expect(1);
+
+      var job = schedule.scheduleJob("hello!!", function() {
+      });
+
+      test.equal(job, null);
+      test.done();
+
     }
   },
   "UTC": {

package/test/es6/job-test.js

@@ -12,6 +12,19 @@ module.exports = function(schedule) {
 
       job.runOnDate(new Date(Date.now() + 3000));
 
+      setTimeout(function() {
+        test.done();
+      }, 3250);
+    },
+    jobContextInGenerator: function(test) {
+      test.expect(1);
+
+      var job = new schedule.Job('name of job', function*() {
+        test.ok(this.name === 'name of job');
+      });
+
+      job.runOnDate(new Date(Date.now() + 3000));
+
       setTimeout(function() {
         test.done();
       }, 3250);

package/test/job-test.js

@@ -97,38 +97,54 @@ module.exports = {
 
       clock.tick(3250);
     },
-    /* No jobs will run after this test for some reason - hide for now
+    "Context is passed into generator correctly": function(test) {
+      if (!es6) {
+        test.expect(0);
+        test.done();
+        return;
+      }
+
+      es6.jobContextInGenerator(test);
+
+      clock.tick(3250);
+    },
     "Won't run job if scheduled in the past": function(test) {
       test.expect(0);
 
       var job = new schedule.Job(function() {
-      test.ok(true);
+        test.ok(false);
       });
 
       job.schedule(new Date(Date.now() - 3000));
 
       setTimeout(function() {
-      test.done();
+        test.done();
       }, 1000);
+
+      clock.tick(1000);
     },
     "Jobs still run after scheduling a Job in the past": function(test) {
       test.expect(1);
 
       var pastJob = new schedule.Job(function() {
       // Should not run, blow up if it does
-      test.ok(false);
+        test.ok(false);
       });
+
       pastJob.schedule(new Date(Date.now() - 3000));
 
       var job = new schedule.Job(function() {
-      test.ok(true);
+        test.ok(true);
       });
+
       job.schedule(new Date(Date.now() + 3000));
 
       setTimeout(function() {
-      test.done();
+        test.done();
       }, 3250);
-    },*/
+
+      clock.tick(3250);
+    },
     "Job emits 'scheduled' event with 'run at' Date": function(test) {
       test.expect(1);
 
@@ -204,25 +220,26 @@ module.exports = {
         }, 3250);
 
         clock.tick(3250);
-      }
-      /*,
-        "Doesn't invoke job if recur rule schedules it in the past": function(test) {
-          test.expect(0);
+      },
+      "Doesn't invoke job if recur rule schedules it in the past": function(test) {
+        test.expect(0);
 
-          var job = new schedule.Job(function() {
+        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() {
+        setTimeout(function() {
           job.cancel();
           test.done();
-          }, 1000);
-        }*/
+        }, 1000);
+
+        clock.tick(1000);
+      }
   },
   "#schedule({...})": {
     "Runs job at interval based on object, repeating indefinitely": function(test) {
@@ -264,24 +281,25 @@ module.exports = {
         }, 3250);
 
         clock.tick(3250);
-      }
-      /*,
-        "Doesn't invoke job if object schedules it in the past": function(test) {
-          test.expect(0);
+      },
+      "Doesn't invoke job if object schedules it in the past": function(test) {
+        test.expect(0);
 
-          var job = new schedule.Job(function() {
+        var job = new schedule.Job(function() {
           test.ok(false);
-          });
+        });
 
-          job.schedule({
+        job.schedule({
           year: 2000
-          });
+        });
 
-          setTimeout(function() {
+        setTimeout(function() {
           job.cancel();
           test.done();
-          }, 1000);
-        }*/
+        }, 1000);
+
+        clock.tick(1000);
+      }
   },
   "#schedule('jobName', {...})": {
     "Runs job with a custom name input": function(test) {
@@ -399,19 +417,42 @@ module.exports = {
                                       function() {},
                                       function() {});
 
-      test.equal(schedule.scheduledJobs.cancelJob, job1);
-      test.equal(schedule.scheduledJobs.second, job2);
+      test.strictEqual(schedule.scheduledJobs.cancelJob, job1);
+      test.strictEqual(schedule.scheduledJobs.second, job2);
       setTimeout(function() {
         job1.cancel();
         job2.cancel();
-        test.equal(schedule.scheduledJobs.cancelJob, null);
-        test.equal(schedule.scheduledJobs.second, null);
+        test.strictEqual(schedule.scheduledJobs.cancelJob, undefined);
+        test.strictEqual(schedule.scheduledJobs.second, undefined);
         test.done();
       }, 1250);
 
       clock.tick(1250);
     }
   },
+  "#reschedule": {
+    "When rescheduled counter will be reset to zero": function(test) {
+
+      var job = new schedule.scheduleJob({
+        second: null
+      }, function() {});
+
+      setTimeout(function() {
+        test.equal(job.triggeredJobs(), 3);
+        schedule.rescheduleJob(job, {
+          minute: null
+        });
+      }, 3250);
+
+      setTimeout(function() {
+        job.cancel();
+        test.equal(job.triggeredJobs(), 0);
+        test.done();
+      }, 5000);
+
+      clock.tick(5000);
+    }
+  },
   "When invoked": {
     "Job emits 'run' event": function(test) {
       test.expect(1);
@@ -429,6 +470,21 @@ module.exports = {
       }, 3250);
 
       clock.tick(3250);
+    },
+    "Job counter increase properly": function(test) {
+      var job = new schedule.Job(function() {});
+
+      job.schedule({
+        second: null // fire every second
+      });
+
+      setTimeout(function() {
+        job.cancel();
+        test.equal(job.triggeredJobs(), 2);
+        test.done();
+      }, 2250);
+
+      clock.tick(2250);
     }
   },
   tearDown: function(cb) {

package/test/schedule-cron-jobs.js

@@ -18,7 +18,7 @@ module.exports = {
     "Runs job every second": function(test) {
       test.expect(3);
 
-      var timeout = 3 * 1000;
+      var timeout = 3 * 1000 + 150;
 
       var job = schedule.scheduleJob('* * * * * *', function() {
         test.ok(true);

package/lib/increment.js

@@ -1,40 +0,0 @@
-
-'use strict';
-
-/*
-  node-schedule
-  A cron-like and not-cron-like job scheduler for Node.
-
-  This file adds convenience functions for performing incremental date math
-  in the Gregorian calendar.
-*/
-
-module.exports.addDateConvenienceMethods = addDateConvenienceMethods;
-
-function addDateConvenienceMethods(Date) {
-  if (typeof Date.addYear !== 'function') {
-    Date.addYear = function() {
-      this.setFullYear(this.getFullYear() + 1);
-    };
-
-    Date.addMonth = function() {
-      this.setMonth(this.getMonth() + 1);
-    };
-
-    Date.addDay = function() {
-      this.setDate(this.getDate() + 1);
-    };
-
-    Date.addHour = function() {
-      this.setTime(this.getTime() + (60 * 60 * 1000));
-    };
-
-    Date.addMinute = function() {
-      this.setTime(this.getTime() + (60 * 1000));
-    };
-
-    Date.addSecond = function() {
-      this.setTime(this.getTime() + 1000);
-    };
-  }
-}