pdf-creator-node 1.4.0 → 1.4.1

package/example/node_modules/kew/test/defer.js

@@ -1,120 +0,0 @@
-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/kew/test/externs_node.js

@@ -1,9 +0,0 @@
-/* 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/kew/test/later.js

@@ -1,45 +0,0 @@
-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/kew/test/scopes.js

@@ -1,59 +0,0 @@
-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/kew/test/spread.js

@@ -1,59 +0,0 @@
-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/kew/test/static.js

@@ -1,393 +0,0 @@
-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()
-}