pdf-creator-node 2.2.3 → 2.3.5

package/example/node_modules/pdf-creator-node/example/node_modules/kew/test/defer.js

@@ -0,0 +1,120 @@
+var Q = require('../kew')
+
+// create a deferred which returns a promise
+exports.testDeferredResolve = function (test) {
+  var val = "ok"
+  var defer = Q.defer()
+
+  defer.promise
+    .then(function (data) {
+      test.equal(data, val, "Promise successfully returned")
+      test.done()
+    })
+
+  setTimeout(function () {
+    defer.resolve(val)
+  }, 50)
+}
+
+// make sure a deferred can only resolve once
+exports.testDeferredResolveOnce = function (test) {
+  var defer = Q.defer()
+
+  try {
+    defer.resolve(true)
+    defer.resolve(true)
+    test.fail("Unable to resolve the same deferred twice")
+  } catch (e) {
+  }
+
+  test.done()
+}
+
+// create a deferred which returns a failed promise
+exports.testDeferredReject = function (test) {
+  var err = new Error("hello")
+  var defer = Q.defer()
+
+  defer.promise
+    .fail(function (e) {
+      test.equal(e, err, "Promise successfully failed")
+      test.done()
+    })
+
+  setTimeout(function () {
+    defer.reject(err)
+  }, 50)
+}
+
+// make sure a deferred can only reject once
+exports.testDeferredRejectOnce = function (test) {
+  var defer = Q.defer()
+
+  try {
+    defer.reject(new Error("nope 1"))
+    defer.reject(new Error("nope 2"))
+    test.fail("Unable to reject the same deferred twice")
+  } catch (e) {
+  }
+
+  test.done()
+}
+
+// make sure a deferred can only reject once
+exports.testDeferAndRejectFail = function (test) {
+  var defer
+
+  try {
+    defer = Q.defer()
+    defer.reject(new Error("nope 1"))
+    defer.resolve(true)
+    test.fail("Unable to reject and resolve the same deferred")
+  } catch (e) {
+    test.ok(true, "Unable to reject and resolve same deferred")
+  }
+
+  try {
+    defer = Q.defer()
+    defer.resolve(true)
+    defer.reject(new Error("nope 1"))
+    test.fail("Unable to reject and resolve the same deferred")
+  } catch (e) {
+    test.ok(true, "Unable to reject and resolve same deferred")
+  }
+
+  test.done()
+}
+
+// create a deferred which resolves with a node-standard callback
+exports.testDeferredResolverSuccess = function (test) {
+  var val = "ok"
+  var defer = Q.defer()
+  var callback = defer.makeNodeResolver()
+
+  defer.promise
+    .then(function (data) {
+      test.equal(data, val, "Promise successfully returned")
+      test.done()
+    })
+
+  setTimeout(function () {
+    callback(null, val)
+  }, 50)
+}
+
+// create a deferred which rejects with a node-standard callback
+exports.testDeferredResolverSuccess = function (test) {
+  var err = new Error("hello")
+  var defer = Q.defer()
+  var callback = defer.makeNodeResolver()
+
+  defer.promise
+    .fail(function (e) {
+      test.equal(e, err, "Promise successfully failed")
+      test.done()
+    })
+
+  setTimeout(function () {
+    callback(err)
+  }, 50)
+}

package/example/node_modules/pdf-creator-node/example/node_modules/kew/test/externs_node.js

@@ -0,0 +1,9 @@
+/* Node externs for Closure Compiler (just enough for kew.js). */
+
+/** @const */
+var module = {};
+
+/** @const */
+var process = {};
+/** @param {function()} callback */
+process.nextTick = function (callback) {};

package/example/node_modules/pdf-creator-node/example/node_modules/kew/test/later.js

@@ -0,0 +1,45 @@
+var Q = require('../kew')
+
+function synchronous (callback) {
+  callback()
+}
+
+var asynchronous = Q.getNextTickFunction()
+
+exports.testAsynchronousSynchronous = function (test) {
+  Q.setNextTickFunction(synchronous)
+
+  var number = 5
+
+  Q.resolve(true).then(function () {
+    number = 6
+  })
+  test.equals(number, 6, 'Q should resolve synchronously')
+
+  Q.setNextTickFunction(asynchronous)
+
+  Q.resolve(true).then(function () {
+    number = 7
+  })
+  test.equals(number, 6, 'Q should resolve asynchronously')
+  test.done()
+}
+
+exports.testSetImmediate = function (test) {
+  if (typeof setImmediate == 'undefined') {
+    test.done()
+    return
+  }
+
+  Q.setNextTickFunction(setImmediate)
+
+  var number = 5
+  Q.resolve(true).then(function () {
+    number = 6
+  })
+  test.equals(number, 5, 'Q should resolve asynchronously')
+  setImmediate(function () {
+    test.equals(number, 6, 'Q should schedule _successFn synchronously')
+    test.done()
+  })
+}

package/example/node_modules/pdf-creator-node/example/node_modules/kew/test/scopes.js

@@ -0,0 +1,59 @@
+var Q = require('../kew')
+
+exports.testThen = function (test) {
+  var detectedScope = null
+  Q.resolve(true).then(function () {
+    detectedScope = this
+  }).then(function () {
+    test.ok(Q.isPromise(detectedScope), 'then() should be called in context of promise')
+    test.done()
+  })
+}
+
+exports.testFail = function (test) {
+  var detectedScope = null
+  Q.reject(new Error()).fail(function () {
+    detectedScope = this
+  }).then(function () {
+    test.ok(Q.isPromise(detectedScope), 'fail() should be called in context of promise')
+    test.done()
+  })
+}
+
+exports.testThenBound = function (test) {
+  var detectedScope = scope
+  var scope = {}
+  Q.resolve(true).thenBound(function () {
+    detectedScope = scope
+  }, scope).then(function () {
+    test.ok(detectedScope === scope, 'thenScoped() should be called in context of scope')
+    test.done()
+  })
+}
+
+exports.testFailBound = function (test) {
+  var detectedScope = scope
+  var scope = {}
+  Q.reject(new Error()).failBound(function () {
+    detectedScope = scope
+  }, scope).then(function () {
+    test.equal(detectedScope, scope, 'failBound() should be called in context of scope')
+    test.done()
+  })
+}
+
+exports.testThenBoundWithArgs = function (test) {
+  var detectedScope = scope
+  var scope = {}
+  Q.resolve(-1).thenBound(function (a, b, c, d) {
+    test.equal(a, 1)
+    test.equal(b, 2)
+    test.equal(c, 3)
+    test.equal(d, -1)
+    detectedScope = scope
+  }, scope, 1, 2, 3).then(function () {
+    test.ok(detectedScope === scope, 'failScoped() should be called in context of scope')
+    test.done()
+  })
+}
+

package/example/node_modules/pdf-creator-node/example/node_modules/kew/test/spread.js

@@ -0,0 +1,59 @@
+var Q = require('../kew')
+
+exports.testSpreadStatic = function (test) {
+  Q.spread([Q.resolve('a'), 'b'], function (a, b) {
+    test.equal('a', a)
+    test.equal('b', b)
+    test.done()
+  })
+}
+
+exports.testSpreadMethod = function (test) {
+  Q.resolve(true)
+      .then(function () {
+        return ['a', 'b']
+      })
+      .spread(function (a, b) {
+        test.equal('a', a)
+        test.equal('b', b)
+        test.done()
+      })
+}
+
+exports.testSpreadBoundMethod = function (test) {
+  Q.resolve(true)
+      .then(function () {
+        return [Q.resolve('a'), 'b']
+      })
+      .spreadBound(function (c, a, b) {
+        test.equal('scope', this.scope)
+        test.equal('c', c)
+        test.equal('a', a)
+        test.equal('b', b)
+        test.done()
+      }, {scope: 'scope'}, 'c')
+}
+
+exports.testAllSynchronization1 = function (test) {
+  var order = []
+  Q.resolve(true)
+      .then(function () {
+        var promiseA = Q.fcall(function () {
+          order.push('a')
+        })
+        var promiseB = Q.fcall(function () {
+          order.push('b')
+        })
+
+        test.deepEqual([], order)
+
+        var promiseAB = Q.all([promiseA, promiseB])
+        test.deepEqual([], order)
+
+        return [promiseA, promiseB]
+      })
+      .then(function (results) {
+        test.deepEqual(['a', 'b'], order)
+        test.done()
+      })
+}

package/example/node_modules/pdf-creator-node/example/node_modules/kew/test/static.js

@@ -0,0 +1,393 @@
+var Q = require('../kew')
+var originalQ = require('q')
+
+// create a promise from a literal
+exports.testQResolve = function (test) {
+  var val = "ok"
+
+  Q.resolve(val)
+    .then(function (data) {
+      test.equal(data, val, "Promise successfully returned")
+      test.done()
+    })
+}
+
+// create a failed promise from an error literal
+exports.testQReject = function (test) {
+  var err = new Error("hello")
+
+  Q.reject(err)
+    .fail(function (e) {
+      test.equal(e, err, "Promise successfully failed")
+      test.done()
+    })
+}
+
+// Test Q.stats
+exports.testQStatistics = function (test) {
+  var err = new Error("hello")
+
+  var errorsEmitted = Q.stats.errorsEmitted
+  var errorsHandled = Q.stats.errorsHandled
+
+  var rejected = Q.reject(err)
+  test.equal(errorsEmitted + 1, Q.stats.errorsEmitted, "One additional error emitted")
+  test.equal(errorsHandled, Q.stats.errorsHandled, "Error hasn't been handled yet")
+
+  rejected.fail(function (e) {
+    test.equal(e, err, "Promise successfully failed")
+    test.equal(errorsEmitted + 1, Q.stats.errorsEmitted, "One additional error emitted")
+    test.equal(errorsHandled + 1, Q.stats.errorsHandled, "One additional error handled")
+  })
+
+  rejected.fail(function (e) {
+    test.equal(e, err, "Promise successfully failed")
+    test.equal(errorsEmitted + 1, Q.stats.errorsEmitted, "One additional error emitted")
+    test.equal(errorsHandled + 1, Q.stats.errorsHandled, "Only count error handling once")
+  })
+  test.done()
+}
+
+exports.testQDeferredStatistics = function (test) {
+  var err = new Error("hello")
+
+  var errorsEmitted = Q.stats.errorsEmitted
+  var errorsHandled = Q.stats.errorsHandled
+
+  var deferred = Q.defer()
+
+  deferred.fail(function (e) {
+    test.equal(e, err, "Promise successfully failed")
+    test.equal(errorsEmitted + 1, Q.stats.errorsEmitted, "One additional error emitted")
+    test.equal(errorsHandled + 1, Q.stats.errorsHandled, "One additional error handled")
+    test.done()
+  })
+
+  var rejected = deferred.reject(err)
+
+}
+
+// test Q.all with an empty array
+exports.testQEmptySuccess = function (test) {
+  var promises = []
+
+  // make sure all results come back
+  Q.all(promises)
+    .then(function (data) {
+      test.equal(data.length, 0, "No records should be returned")
+      test.done()
+    })
+}
+
+// test Q.all with only literals
+exports.testQAllLiteralsSuccess = function (test) {
+  var vals = [3, 2, 1]
+  var promises = []
+
+  promises.push(vals[0])
+  promises.push(vals[1])
+  promises.push(vals[2])
+
+  // make sure all results come back
+  Q.all(promises)
+    .then(function (data) {
+      test.equal(data[0], vals[0], "First val should be returned")
+      test.equal(data[1], vals[1], "Second val should be returned")
+      test.equal(data[2], vals[2], "Third val should be returned")
+      test.done()
+    })
+}
+
+// test Q.all with only promises
+exports.testQAllPromisesSuccess = function (test) {
+  var vals = [3, 2, 1]
+  var promises = []
+
+  promises.push(Q.resolve(vals[0]))
+  promises.push(Q.resolve(vals[1]))
+  promises.push(Q.resolve(vals[2]))
+
+  // make sure all results come back
+  Q.all(promises)
+    .then(function (data) {
+      test.equal(data[0], vals[0], "First val should be returned")
+      test.equal(data[1], vals[1], "Second val should be returned")
+      test.equal(data[2], vals[2], "Third val should be returned")
+      test.done()
+    })
+}
+
+// create a promise which waits for other promises
+exports.testQAllAssortedSuccess = function (test) {
+  var vals = [3, 2, 1]
+  var promises = []
+
+  // a promise that returns the value immediately
+  promises.push(Q.resolve(vals[0]))
+
+  // the value itself
+  promises.push(vals[1])
+
+  // a promise which returns in 10ms
+  var defer = Q.defer()
+  promises.push(defer.promise)
+  setTimeout(function () {
+    defer.resolve(vals[2])
+  }, 10)
+
+  // make sure all results come back
+  Q.all(promises)
+    .then(function (data) {
+      test.equal(data[0], vals[0], "First val should be returned")
+      test.equal(data[1], vals[1], "Second val should be returned")
+      test.equal(data[2], vals[2], "Third val should be returned")
+      test.done()
+    })
+}
+
+// test Q.all with a failing promise
+exports.testQAllError = function (test) {
+  var vals = [3, 2, 1]
+  var err = new Error("hello")
+  var promises = []
+
+  promises.push(vals[0])
+  promises.push(vals[1])
+
+  var defer = Q.defer()
+  promises.push(defer.promise)
+  defer.reject(err)
+
+  // make sure all results come back
+  Q.all(promises)
+    .fail(function (e) {
+      test.equal(e, err)
+      test.done()
+    })
+}
+
+// test all var_args
+exports.testAllVarArgs = function (test) {
+  var promises = ['a', 'b']
+
+  Q.all.apply(Q, promises)
+    .then(function (results) {
+      test.equal(promises[0], results[0], "First element should be returned")
+      test.equal(promises[1], results[1], "Second element should be returned")
+      test.done()
+    })
+}
+
+// test all array
+exports.testAllArray = function (test) {
+  var promises = ['a', 'b']
+
+  Q.all(promises)
+    .then(function (results) {
+      test.equal(promises[0], results[0], "First element should be returned")
+      test.equal(promises[1], results[1], "Second element should be returned")
+      test.done()
+    })
+}
+
+exports.testAllIsPromiseLike = function(test) {
+  var promises = ['a', originalQ('b')]
+
+  Q.all(promises)
+    .then(function (results) {
+      test.equal(promises[0], 'a', "First element should be returned")
+      test.equal(promises[1], 'b', "Second element should be returned")
+      test.done()
+    })
+}
+
+// test delay
+exports.testDelay = function (test) {
+  var val = "Hello, there"
+  var startTime = Date.now()
+
+  Q.resolve(val)
+    .then(function (v) {
+      return Q.delay(v, 1000)
+    })
+    .then(function (returnVal) {
+      test.equal(returnVal, val, "Val should be passed through")
+
+      var diff = Date.now() - startTime
+
+      // clock granularity may be off by 15
+      test.equal(diff >= 1000 - 15, true, "Should have waited a second. Actually waited " + diff)
+      test.done()
+    })
+}
+
+// test fcall
+exports.testFcall = function (test) {
+  var calledYet = false
+  var adder = function (a, b) {
+    calledYet = true
+    return a + b
+  }
+
+  Q.fcall(adder, 2, 3)
+    .then(function (val) {
+      test.equal(val, 5, "Val should be 2 + 3")
+      test.done()
+    })
+  test.ok(!calledYet, "fcall() should delay function invocation until next tick")
+}
+
+// test fcall
+exports.testFcallError = function (test) {
+  var error = function () {
+    throw new Error('my error')
+  }
+
+  Q.fcall(error)
+    .then(function (val) {
+      test.fail('fcall should throw exception')
+    }, function (err) {
+      test.equal('my error', err.message)
+    })
+    .then(function () {
+      test.done()
+    })
+}
+
+// test fcall works when fn returns a promise
+exports.testFcallGivenPromise = function (test) {
+  var calledYet = false
+  var eventualAdd = function (a, b) {
+    calledYet = true
+    return Q.resolve(a + b)
+  }
+
+  Q.fcall(eventualAdd, 2, 3)
+    .then(function (val) {
+      test.equal(val, 5, "Val should be 2 + 3")
+      test.done()
+    })
+  test.ok(!calledYet, "fcall() should delay function invocation until next tick")
+}
+
+// test nfcall, successful case
+exports.testNfcall = function (test) {
+  var nodeStyleEventualAdder = function (a, b, callback) {
+    setTimeout(function () {
+      callback(undefined, a + b)
+    }, 2)
+  }
+
+  Q.nfcall(nodeStyleEventualAdder, 2, 3)
+    .then(function (val) {
+      test.equal(val, 5, "Val should be 2 + 3")
+      test.done()
+    })
+}
+
+// test nfcall, error case
+exports.testNfcallErrors = function (test) {
+  var err = new Error('fail')
+
+  var nodeStyleFailer = function (a, b, callback) {
+    setTimeout(function() {
+      callback(err)
+    }, 2)
+  }
+
+  Q.nfcall(nodeStyleFailer, 2, 3)
+    .fail(function (e) {
+      test.equal(e, err, "Promise successfully failed")
+      test.done()
+    })
+}
+
+// test fcall
+exports.testNFcallErrorSync = function (test) {
+  var error = function () {
+    throw new Error('my error')
+  }
+
+  Q.nfcall(error)
+    .then(function (val) {
+      test.fail('nfcall should throw exception')
+    }, function (err) {
+      test.equal('my error', err.message)
+    })
+    .then(function () {
+      test.done()
+    })
+}
+
+exports.testNcall = function (test) {
+  function TwoAdder() {
+    this.a = 2
+  }
+  TwoAdder.prototype.add = function (num, callback) {
+    setTimeout(function () {
+      callback(null, this.a + num)
+    }.bind(this), 10)
+  }
+  var adder = new TwoAdder()
+  Q.ncall(adder.add, adder, 3)
+    .then(function (val) {
+      test.equal(val, 5, "Val should be 2 + 3")
+      test.done()
+    })
+}
+
+// test binding a callback function with a promise
+exports.testBindPromise = function (test) {
+  var adder = function (a, b, callback) {
+    callback(null, a + b)
+  }
+
+  var boundAdder = Q.bindPromise(adder, null, 2)
+  boundAdder(3)
+    .then(function (val) {
+      test.equal(val, 5, "Val should be 2 + 3")
+      test.done()
+    })
+}
+
+// test checking whether something is a promise
+exports.testIsPromise = function (test) {
+  var kewPromise = Q.defer()
+  var qPromise = originalQ(10)
+  var kewLikeObject = {
+    promise: function () {
+      return 'not a promise sucka!'
+    },
+    then: function (fn) {
+      fn('like a promise, brah!')
+    }
+  }
+  test.equal(Q.isPromise(kewPromise), true, 'A Kew promise is a promise')
+  test.equal(Q.isPromise(qPromise), false, 'A Q promise is not a promise')
+  test.equal(Q.isPromise(kewLikeObject), false, 'A pretend promise is not a promise')
+  test.done()
+}
+
+// test checking whether something is a promise-like object
+exports.testIsPromiseLike = function (test) {
+  var kewPromise = Q.defer()
+  var qPromise = originalQ(10)
+  var kewLikeObject = {
+    promise: function () {
+      return 'not a promise sucka!'
+    },
+    then: function (fn) {
+      fn('like a promise, brah!')
+    }
+  }
+  var kewLikeFunction = function() {}
+  kewLikeFunction.then = function(fn) {
+    fn('like a promise, brah!')
+  }
+  test.equal(Q.isPromiseLike(kewPromise), true, 'A Kew promise is promise-like')
+  test.equal(Q.isPromiseLike(qPromise), true, 'A Q promise is promise-like')
+  test.equal(Q.isPromiseLike(kewLikeObject), true, 'A pretend promise is a promise-like')
+  test.equal(Q.isPromiseLike(kewLikeFunction), true, 'A pretend function promise is a promise-like')
+
+  test.done()
+}