1

nodejs/node_modules/node-schedule/lib/schedule.js

@@ -0,0 +1,648 @@
+
+'use strict';
+
+/*
+  node-schedule
+  A cron-like and not-cron-like job scheduler for Node.
+*/
+
+var events = require('events'),
+  util = require('util'),
+  cronParser = require('cron-parser'),
+  CronDate = require('cron-parser/lib/date'),
+  lt = require('long-timeout'),
+  sorted = require('sorted-array-functions');
+
+/* Job object */
+var anonJobCounter = 0;
+var scheduledJobs = {};
+
+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;
+
+  // Make sure callback is actually a callback
+  if (this.job === name) {
+    // Name wasn't provided and maybe a callback is there
+    this.callback = typeof job === 'function' ? job : false;
+  } else {
+    // Name was provided, and maybe a callback is there
+    this.callback = typeof callback === 'function' ? callback : false;
+  }
+
+  // Check for generator
+  if (typeof this.job === 'function' &&
+      this.job.prototype &&
+      this.job.prototype.next) {
+    this.job = function() {
+      return this.next().value;
+    }.bind(this.job.call(this));
+  }
+
+  // define properties
+  Object.defineProperty(this, 'name', {
+    value: jobName,
+    writable: false,
+    enumerable: true
+  });
+
+  // method that require private access
+  this.trackInvocation = function(invocation) {
+    // add to our invocation list
+    sorted.add(pendingInvocations, invocation, sorter);
+    return true;
+  };
+  this.stopTrackingInvocation = function(invocation) {
+    var invIdx = pendingInvocations.indexOf(invocation);
+    if (invIdx > -1) {
+      pendingInvocations.splice(invIdx, 1);
+      return true;
+    }
+
+    return false;
+  };
+  this.triggeredJobs = function() {
+    return triggeredJobs;
+  };
+  this.setTriggeredJobs = function(triggeredJob) {
+    triggeredJobs = triggeredJob;
+  };
+  this.cancel = function(reschedule) {
+    reschedule = (typeof reschedule == 'boolean') ? reschedule : false;
+
+    var inv, newInv;
+    var newInvs = [];
+    for (var j = 0; j < pendingInvocations.length; j++) {
+      inv = pendingInvocations[j];
+
+      cancelInvocation(inv);
+
+      if (reschedule && inv.recurrenceRule.recurs) {
+        newInv = scheduleNextRecurrence(inv.recurrenceRule, this, inv.fireDate, inv.endDate);
+        if (newInv !== null) {
+          newInvs.push(newInv);
+        }
+      }
+    }
+
+    pendingInvocations = [];
+
+    for (var k = 0; k < newInvs.length; k++) {
+      this.trackInvocation(newInvs[k]);
+    }
+
+    // remove from scheduledJobs if reschedule === false
+    if (!reschedule) {
+      if (this.name) {
+        delete scheduledJobs[this.name];
+      }
+    }
+
+    return true;
+  };
+  this.cancelNext = function(reschedule) {
+    reschedule = (typeof reschedule == 'boolean') ? reschedule : true;
+
+    if (!pendingInvocations.length) {
+      return false;
+    }
+
+    var newInv;
+    var nextInv = pendingInvocations.shift();
+
+    cancelInvocation(nextInv);
+
+    if (reschedule && nextInv.recurrenceRule.recurs) {
+      newInv = scheduleNextRecurrence(nextInv.recurrenceRule, this, nextInv.fireDate, nextInv.endDate);
+      if (newInv !== null) {
+        this.trackInvocation(newInv);
+      }
+    }
+
+    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;
+    }
+    return pendingInvocations[0].fireDate;
+  };
+  this.pendingInvocations = function() {
+    return pendingInvocations;
+  };
+}
+
+util.inherits(Job, events.EventEmitter);
+
+Job.prototype.invoke = function(fireDate) {
+  if (typeof this.job == 'function') {
+    this.setTriggeredJobs(this.triggeredJobs() + 1);
+    this.job(fireDate);
+  } else {
+    this.job.execute(fireDate);
+  }
+};
+
+Job.prototype.runOnDate = function(date) {
+  return this.schedule(date);
+};
+
+Job.prototype.schedule = function(spec) {
+  var self = this;
+  var success = false;
+  var inv;
+  var start;
+  var end;
+  var tz;
+
+  if (typeof spec === 'object' && spec.rule) {
+    start = spec.start || undefined;
+    end = spec.end || undefined;
+    tz = spec.tz;
+    spec = spec.rule;
+
+    if (start) {
+      if (!(start instanceof Date)) {
+        start = new Date(start);
+      }
+
+      start = new CronDate(start, tz);
+      if (!isValidDate(start) || start.getTime() < Date.now()) {
+        start = undefined;
+      }
+    }
+
+    if (end && !(end instanceof Date) && !isValidDate(end = new Date(end))) {
+      end = undefined;
+    }
+
+    if (end) {
+      end = new CronDate(end, tz);
+    }
+  }
+
+  try {
+    var res = cronParser.parseExpression(spec, { currentDate: start, tz: tz });
+    inv = scheduleNextRecurrence(res, self, start, end);
+    if (inv !== null) {
+      success = self.trackInvocation(inv);
+    }
+  } catch (err) {
+    var type = typeof spec;
+    if ((type === 'string') || (type === 'number')) {
+      spec = new Date(spec);
+    }
+
+    if ((spec instanceof Date) && (isValidDate(spec))) {
+      spec = new CronDate(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();
+        if ('year' in spec) {
+          r.year = spec.year;
+        }
+        if ('month' in spec) {
+          r.month = spec.month;
+        }
+        if ('date' in spec) {
+          r.date = spec.date;
+        }
+        if ('dayOfWeek' in spec) {
+          r.dayOfWeek = spec.dayOfWeek;
+        }
+        if ('hour' in spec) {
+          r.hour = spec.hour;
+        }
+        if ('minute' in spec) {
+          r.minute = spec.minute;
+        }
+        if ('second' in spec) {
+          r.second = spec.second;
+        }
+
+        spec = r;
+      }
+
+      spec.tz = tz;
+      inv = scheduleNextRecurrence(spec, self, start, end);
+      if (inv !== null) {
+        success = self.trackInvocation(inv);
+      }
+    }
+  }
+
+  scheduledJobs[this.name] = this;
+  return success;
+};
+
+/* API
+  invoke()
+  runOnDate(date)
+  schedule(date || recurrenceRule || cronstring)
+  cancel(reschedule = false)
+  cancelNext(reschedule = true)
+
+   Property constraints
+  name: readonly
+  job: readwrite
+*/
+
+/* DoesntRecur rule */
+var DoesntRecur = new RecurrenceRule();
+DoesntRecur.recurs = false;
+
+/* Invocation object */
+function Invocation(job, fireDate, recurrenceRule, endDate) {
+  this.job = job;
+  this.fireDate = fireDate;
+  this.endDate = endDate;
+  this.recurrenceRule = recurrenceRule || DoesntRecur;
+
+  this.timerID = null;
+}
+
+function sorter(a, b) {
+  return (a.fireDate.getTime() - b.fireDate.getTime());
+}
+
+/* Range object */
+function Range(start, end, step) {
+  this.start = start || 0;
+  this.end = end || 60;
+  this.step = step || 1;
+}
+
+Range.prototype.contains = function(val) {
+  if (this.step === null || this.step === 1) {
+    return (val >= this.start && val <= this.end);
+  } else {
+    for (var i = this.start; i < this.end; i += this.step) {
+      if (i === val) {
+        return true;
+      }
+    }
+
+    return false;
+  }
+};
+
+/* RecurrenceRule object */
+/*
+  Interpreting each property:
+  null - any value is valid
+  number - fixed value
+  Range - value must fall in range
+  array - value must validate against any item in list
+
+  NOTE: Cron months are 1-based, but RecurrenceRule months are 0-based.
+*/
+function RecurrenceRule(year, month, date, dayOfWeek, hour, minute, second) {
+  this.recurs = true;
+
+  this.year = (year == null) ? null : year;
+  this.month = (month == null) ? null : month;
+  this.date = (date == null) ? null : date;
+  this.dayOfWeek = (dayOfWeek == null) ? null : dayOfWeek;
+  this.hour = (hour == null) ? null : hour;
+  this.minute = (minute == null) ? null : minute;
+  this.second = (second == null) ? 0 : second;
+}
+
+RecurrenceRule.prototype.isValid = function() {
+  function isValidType(num) {
+    if (Array.isArray(num) || (num instanceof Array)) {
+      return num.every(function(e) {
+        return isValidType(e);
+      });
+    }
+    return !(Number.isNaN(Number(num)) && !(num instanceof Range));
+  }
+  if (this.month !== null && (this.month < 0 || this.month > 11 || !isValidType(this.month))) {
+    return false;
+  }
+  if (this.dayOfWeek !== null && (this.dayOfWeek < 0 || this.dayOfWeek > 6 || !isValidType(this.dayOfWeek))) {
+    return false;
+  }
+  if (this.hour !== null && (this.hour < 0 || this.hour > 23 || !isValidType(this.hour))) {
+    return false;
+  }
+  if (this.minute !== null && (this.minute < 0 || this.minute > 59 || !isValidType(this.minute))) {
+    return false;
+  }
+  if (this.second !== null && (this.second < 0 || this.second > 59 || !isValidType(this.second))) {
+    return false;
+  }
+  if (this.date !== null) {
+    if(!isValidType(this.date)) {
+      return false;
+    }
+    switch (this.month) {
+      case 3:
+      case 5:
+      case 8:
+      case 10:
+        if (this.date < 1 || this. date > 30) {
+          return false;
+        }
+        break;
+      case 1:
+        if (this.date < 1 || this. date > 29) {
+          return false;
+        }
+        break;
+      default:
+        if (this.date < 1 || this. date > 31) {
+          return false;
+        }
+    }
+  }
+  return true;
+};
+
+RecurrenceRule.prototype.nextInvocationDate = function(base) {
+  base = ((base instanceof CronDate) || (base instanceof Date)) ? base : (new Date());
+  if (!this.recurs) {
+    return null;
+  }
+
+  if(!this.isValid()) {
+    return null;
+  }
+
+  var now = new CronDate(Date.now(), this.tz);
+  var fullYear = now.getFullYear();
+  if ((this.year !== null) &&
+      (typeof this.year == 'number') &&
+      (this.year < fullYear)) {
+    return null;
+  }
+
+  var next = new CronDate(base.getTime(), this.tz);
+  next.addSecond();
+
+  while (true) {
+    if (this.year !== null) {
+      fullYear = next.getFullYear();
+      if ((typeof this.year == 'number') && (this.year < fullYear)) {
+        next = null;
+        break;
+      }
+
+      if (!recurMatch(fullYear, this.year)) {
+        next.addYear();
+        next.setMonth(0);
+        next.setDate(1);
+        next.setHours(0);
+        next.setMinutes(0);
+        next.setSeconds(0);
+        continue;
+      }
+    }
+    if (this.month != null && !recurMatch(next.getMonth(), this.month)) {
+      next.addMonth();
+      continue;
+    }
+    if (this.date != null && !recurMatch(next.getDate(), this.date)) {
+      next.addDay();
+      continue;
+    }
+    if (this.dayOfWeek != null && !recurMatch(next.getDay(), this.dayOfWeek)) {
+      next.addDay();
+      continue;
+    }
+    if (this.hour != null && !recurMatch(next.getHours(), this.hour)) {
+      next.addHour();
+      continue;
+    }
+    if (this.minute != null && !recurMatch(next.getMinutes(), this.minute)) {
+      next.addMinute();
+      continue;
+    }
+    if (this.second != null && !recurMatch(next.getSeconds(), this.second)) {
+      next.addSecond();
+      continue;
+    }
+
+    break;
+  }
+
+  return next ? next.toDate() : null;
+};
+
+function recurMatch(val, matcher) {
+  if (matcher == null) {
+    return true;
+  }
+
+  if (typeof matcher === 'number') {
+    return (val === matcher);
+  } else if(typeof matcher === 'string') {
+    return (val === Number(matcher));
+  } else if (matcher instanceof Range) {
+    return matcher.contains(val);
+  } else if (Array.isArray(matcher) || (matcher instanceof Array)) {
+    for (var i = 0; i < matcher.length; i++) {
+      if (recurMatch(val, matcher[i])) {
+        return true;
+      }
+    }
+  }
+
+  return false;
+}
+
+/* Date-based scheduler */
+function runOnDate(date, job) {
+  var now = Date.now();
+  var then = date.getTime();
+  
+  return lt.setTimeout(function() {
+    if (then > Date.now())
+      runOnDate(date, job);
+    else
+      job();
+  }, (then < now ? 0 : then - now));
+}
+
+var invocations = [];
+var currentInvocation = null;
+
+function scheduleInvocation(invocation) {
+  sorted.add(invocations, invocation, sorter);
+  prepareNextInvocation();
+  var date = invocation.fireDate instanceof CronDate ? invocation.fireDate.toDate() : invocation.fireDate;
+  invocation.job.emit('scheduled', date);
+}
+
+function prepareNextInvocation() {
+  if (invocations.length > 0 && currentInvocation !== invocations[0]) {
+    if (currentInvocation !== null) {
+      lt.clearTimeout(currentInvocation.timerID);
+      currentInvocation.timerID = null;
+      currentInvocation = null;
+    }
+
+    currentInvocation = invocations[0];
+
+    var job = currentInvocation.job;
+    var cinv = currentInvocation;
+    currentInvocation.timerID = runOnDate(currentInvocation.fireDate, function() {
+      currentInvocationFinished();
+
+      if (job.callback) {
+        job.callback();
+      }
+
+      if (cinv.recurrenceRule.recurs || cinv.recurrenceRule._endDate === null) {
+        var inv = scheduleNextRecurrence(cinv.recurrenceRule, cinv.job, cinv.fireDate, cinv.endDate);
+        if (inv !== null) {
+          inv.job.trackInvocation(inv);
+        }
+      }
+
+      job.stopTrackingInvocation(cinv);
+
+      job.invoke(cinv.fireDate instanceof CronDate ? cinv.fireDate.toDate() : cinv.fireDate);
+      job.emit('run');
+    });
+  }
+}
+
+function currentInvocationFinished() {
+  invocations.shift();
+  currentInvocation = null;
+  prepareNextInvocation();
+}
+
+function cancelInvocation(invocation) {
+  var idx = invocations.indexOf(invocation);
+  if (idx > -1) {
+    invocations.splice(idx, 1);
+    if (invocation.timerID !== null) {
+      lt.clearTimeout(invocation.timerID);
+    }
+
+    if (currentInvocation === invocation) {
+      currentInvocation = null;
+    }
+
+    invocation.job.emit('canceled', invocation.fireDate);
+    prepareNextInvocation();
+  }
+}
+
+/* Recurrence scheduler */
+function scheduleNextRecurrence(rule, job, prevDate, endDate) {
+
+  prevDate = (prevDate instanceof CronDate) ? prevDate : new CronDate();
+
+  var date = (rule instanceof RecurrenceRule) ? rule.nextInvocationDate(prevDate) : rule.next();
+  if (date === null) {
+    return null;
+  }
+
+  if ((endDate instanceof CronDate) && date.getTime() > endDate.getTime()) {
+    return null;
+  }
+
+  var inv = new Invocation(job, date, rule, endDate);
+  scheduleInvocation(inv);
+
+  return inv;
+}
+
+/* Convenience methods */
+function scheduleJob() {
+  if (arguments.length < 2) {
+    return null;
+  }
+
+  var name = (arguments.length >= 3 && typeof arguments[0] === 'string') ? arguments[0] : null;
+  var spec = name ? arguments[1] : arguments[0];
+  var method = name ? arguments[2] : arguments[1];
+  var callback = name ? arguments[3] : arguments[2];
+
+  var job = new Job(name, method, callback);
+
+  if (job.schedule(spec)) {
+    return job;
+  }
+
+  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) {
+    success = job.cancel();
+  } else if (typeof job == 'string' || job instanceof String) {
+    if (job in scheduledJobs && scheduledJobs.hasOwnProperty(job)) {
+      success = scheduledJobs[job].cancel();
+    }
+  }
+
+  return success;
+}
+
+/* Public API */
+module.exports.Job = Job;
+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;