├── .gitignore
├── .npmignore
├── .travis.yml
├── LICENSE.txt
├── README.md
├── cjs
    ├── index.js
    └── package.json
├── es.js
├── esm
    └── index.js
├── index.js
├── package.json
├── rollup
    ├── es.config.js
    └── index.config.js
└── test
    ├── .test.js
    ├── dodgy.js
    ├── index.html
    ├── index.js
    ├── package.json
    └── testrunner.js


/.gitignore:
--------------------------------------------------------------------------------
1 | .DS_Store
2 | .nyc_output
3 | node_modules/
4 | package-lock.json
5 | 


--------------------------------------------------------------------------------
/.npmignore:
--------------------------------------------------------------------------------
1 | .DS_Store
2 | .nyc_output
3 | .travis.yml
4 | node_modules/
5 | rollup/
6 | test/
7 | package-lock.json
8 | 


--------------------------------------------------------------------------------
/.travis.yml:
--------------------------------------------------------------------------------
1 | language: node_js
2 | node_js:
3 |   - 0.12
4 | git:
5 |   depth: 1
6 | branches:
7 |   only:
8 |     - master


--------------------------------------------------------------------------------
/LICENSE.txt:
--------------------------------------------------------------------------------
 1 | Copyright (C) 2015 by Andrea Giammarchi - @WebReflection
 2 | 
 3 | Permission is hereby granted, free of charge, to any person obtaining a copy
 4 | of this software and associated documentation files (the "Software"), to deal
 5 | in the Software without restriction, including without limitation the rights
 6 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 7 | copies of the Software, and to permit persons to whom the Software is
 8 | furnished to do so, subject to the following conditions:
 9 | 
10 | The above copyright notice and this permission notice shall be included in
11 | all copies or substantial portions of the Software.
12 | 
13 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
14 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
15 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
16 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
17 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
18 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
19 | THE SOFTWARE.
20 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | Dodgy [![build status](https://secure.travis-ci.org/WebReflection/dodgy.svg)](http://travis-ci.org/WebReflection/dodgy)
  2 | =====
  3 | 
  4 | The idea behind this module has been explained in [my good old blog](http://webreflection.blogspot.co.uk/2015/09/on-cancelable-promises.html),
  5 | and was [born after the following gist](https://gist.github.com/WebReflection/796d1f04b1173fbcfe5a#file-lie-js) as improved and well tested 30 LOC "_life saver_".
  6 | 
  7 | * CDN global utility via https://unpkg.com/dodgy
  8 | * ESM via `import {Dodgy} from 'dodgy'`
  9 | * CJS via `const {Dodgy} = require('dodgy')`
 10 | 
 11 | ### How to opt in for .abort([optionalValue])
 12 | In order to make a promise cancelable we need to invoke the third argument which is a callback expecting to know what to do in case of abortion.
 13 | ```js
 14 | import {Dodgy} from 'dodgy';
 15 | 
 16 | var p = new Dodgy(function (res, rej, onAbort) {
 17 |   var t = setTimeout(res, 1000, 'OK');
 18 |   onAbort(function (butWhy) {
 19 |     clearTimeout(t);
 20 |     return butWhy || 'because';
 21 |   });
 22 | });
 23 | 
 24 | p.then(
 25 |   console.log.bind(console),
 26 |   console.warn.bind(console)  // <- .abort()
 27 | ).catch(
 28 |   console.error.bind(console)
 29 | );
 30 | 
 31 | // at any time later on
 32 | p.abort('not needed anynmore');
 33 | 
 34 | ```
 35 | 
 36 | ### How to opt in as externally resolvable
 37 | Canceling a Promise is one thing, resolving it externally is a whole new "_dodger_" level but we can explicitly opt in if that's needed.
 38 | ```js
 39 | var p = new Dodgy(
 40 |   function (res, rej, optInAbort) {
 41 |     // we still need to opt in for abortability
 42 |     // simply invoke the third argument
 43 |     // passing a "no-op" function, if needed
 44 |     optInAbort(Object); // Object would do
 45 |   },
 46 |   true  // <- go even dodger !!!
 47 | );
 48 | 
 49 | // our p now will have 3 methods:
 50 | p.resolve;
 51 | p.reject;
 52 | p.abort;
 53 | ```
 54 | At this point we can fully control our Promise, proudly riding the edges of nonsense-land!
 55 | 
 56 | 
 57 | ### Dodgy.race(iterable)
 58 | 
 59 | Either one Promise in the iterable solve or the returned dodgy promise is aborted, all other dodgy promises in the iterable will be aborted too.
 60 | 
 61 | ```js
 62 | var race = Dodgy.race(p1, d2, p3, p4, d5);
 63 | 
 64 | // if any of those promises is resolved
 65 | // all abortable will be aborted
 66 | // e.g.  d2.abort(); d5.abort(); will be called
 67 | 
 68 | // the same happens if the race itself is aborted
 69 | race.abort();
 70 | ```
 71 | 
 72 | 
 73 | ### Chainability
 74 | We can `p.then().catch()` as much as we like, all control methods will be propagated down the road.
 75 | 
 76 | ### Chaining abortable and resolvable promises
 77 | I believe it is a very bad idea to create alchemy capable of chaining abortaability or resolutions. The resolution per promise can be different per each Promise, and so is the reason to abort. Combine these in a chain would lead to disasters.
 78 | 
 79 | Accordingly, if we need to chain multiple abortable Promises, we can return a new one instead, creating points in the chain where abort would make sense.
 80 | 
 81 | 
 82 | ### Multiple abortable/resolvable in the same chain
 83 | The way we could resolve a Promise is different per promise, and so is the reason we might abort.
 84 | I haven't spent much time over-complicating a thing here. If you need to pass along an abortable promise that shuold abort a received one, you are free to create promises like the following:
 85 | ```js
 86 | // we have a p1, we return a p2
 87 | return new Dodgy(function (res, rej, onAbort) {
 88 |   // logic to resolve or reject here ... then ...
 89 |   onAbort(function () {
 90 |     // abort previous one
 91 |     p1.abort('from p2');
 92 |     // now abort this one doing whatever is needed
 93 |   });
 94 | });
 95 | ```
 96 | 
 97 | 
 98 | ### Compatibility
 99 | Every browser and JavaScript engine, but the Promise polyfill is not included.
100 | Try [es6-promise](https://github.com/jakearchibald/es6-promise) if you want, it worked for my [tests on IE8 too](http://webreflection.github.io/dodgy/test/).
101 | 
102 | ### Which license?
103 | The MIT style License
104 | 


--------------------------------------------------------------------------------
/cjs/index.js:
--------------------------------------------------------------------------------
 1 | 'use strict';
 2 | function Dodgy(callback, resolvable) {
 3 |   var
 4 |     resolve, reject, abort,
 5 |     status = 'pending',
 6 |     dog = new Promise(function (res, rej) {
 7 |       callback(
 8 |         resolve = function (value) {
 9 |           if (status === 'pending') {
10 |             status = 'resolved';
11 |             dog.status = status;
12 |             res(value);
13 |           }
14 |         },
15 |         reject = function (value) {
16 |           if (status === 'pending') {
17 |             status = 'rejected';
18 |             dog.status = status;
19 |             rej(value);
20 |           }
21 |         },
22 |         function onAbort(callback) {
23 |           abort = function (reason) {
24 |             if (status === 'pending') {
25 |               status = 'aborted';
26 |               dog.status = status;
27 |               rej(callback(reason));
28 |             }
29 |           };
30 |         }
31 |       );
32 |     })
33 |   ;
34 |   return evolved(dog, resolvable, abort, resolve, reject);
35 | }
36 | 
37 | function evolved(dog, resolvable, abort, resolve, reject) {
38 |   var
39 |     currentThen = dog.then,
40 |     currentCatch = dog.catch
41 |   ;
42 |   if (abort) dog.abort = abort;
43 |   if (resolvable) {
44 |     dog.resolve = resolve;
45 |     dog.reject = reject;
46 |   }
47 |   dog.then = function () {
48 |     return evolved(
49 |       currentThen.apply(dog, arguments),
50 |       resolvable, abort, resolve, reject
51 |     );
52 |   };
53 |   dog['catch'] = function () {
54 |     return evolved(
55 |       currentCatch.apply(dog, arguments),
56 |       resolvable, abort, resolve, reject
57 |     );
58 |   };
59 |   return dog;
60 | }
61 | 
62 | Dodgy.race = function (iterable) {
63 |   var dog = Promise.race(iterable).then(abort);
64 |   function abort(result) {
65 |     for (var i = 0; i < iterable.length; i++) {
66 |       if ('abort' in iterable[i]) iterable[i].abort();
67 |     }
68 |     return result;
69 |   }
70 |   dog.abort = abort;
71 |   return dog;
72 | };
73 | 
74 | Object.defineProperty(exports, '__esModule', {value: true}).default = Dodgy;
75 | exports.Dodgy = Dodgy;
76 | 


--------------------------------------------------------------------------------
/cjs/package.json:
--------------------------------------------------------------------------------
1 | {"type":"commonjs"}


--------------------------------------------------------------------------------
/es.js:
--------------------------------------------------------------------------------
1 | var dodgy=function(n){"use strict";function t(n,t){var r,e,o,u="pending",c=new Promise((function(t,a){n(r=function(n){"pending"===u&&(u="resolved",c.status=u,t(n))},e=function(n){"pending"===u&&(u="rejected",c.status=u,a(n))},(function(n){o=function(t){"pending"===u&&(u="aborted",c.status=u,a(n(t)))}}))}));return function n(t,r,e,o,u){var c=t.then,a=t.catch;e&&(t.abort=e);r&&(t.resolve=o,t.reject=u);return t.then=function(){return n(c.apply(t,arguments),r,e,o,u)},t.catch=function(){return n(a.apply(t,arguments),r,e,o,u)},t}(c,t,o,r,e)}return t.race=function(n){var t=Promise.race(n).then(r);function r(t){for(var r=0;r<n.length;r++)"abort"in n[r]&&n[r].abort();return t}return t.abort=r,t},n.Dodgy=t,n.default=t,n}({});
2 | 


--------------------------------------------------------------------------------
/esm/index.js:
--------------------------------------------------------------------------------
 1 | function Dodgy(callback, resolvable) {
 2 |   var
 3 |     resolve, reject, abort,
 4 |     status = 'pending',
 5 |     dog = new Promise(function (res, rej) {
 6 |       callback(
 7 |         resolve = function (value) {
 8 |           if (status === 'pending') {
 9 |             status = 'resolved';
10 |             dog.status = status;
11 |             res(value);
12 |           }
13 |         },
14 |         reject = function (value) {
15 |           if (status === 'pending') {
16 |             status = 'rejected';
17 |             dog.status = status;
18 |             rej(value);
19 |           }
20 |         },
21 |         function onAbort(callback) {
22 |           abort = function (reason) {
23 |             if (status === 'pending') {
24 |               status = 'aborted';
25 |               dog.status = status;
26 |               rej(callback(reason));
27 |             }
28 |           };
29 |         }
30 |       );
31 |     })
32 |   ;
33 |   return evolved(dog, resolvable, abort, resolve, reject);
34 | }
35 | 
36 | function evolved(dog, resolvable, abort, resolve, reject) {
37 |   var
38 |     currentThen = dog.then,
39 |     currentCatch = dog.catch
40 |   ;
41 |   if (abort) dog.abort = abort;
42 |   if (resolvable) {
43 |     dog.resolve = resolve;
44 |     dog.reject = reject;
45 |   }
46 |   dog.then = function () {
47 |     return evolved(
48 |       currentThen.apply(dog, arguments),
49 |       resolvable, abort, resolve, reject
50 |     );
51 |   };
52 |   dog['catch'] = function () {
53 |     return evolved(
54 |       currentCatch.apply(dog, arguments),
55 |       resolvable, abort, resolve, reject
56 |     );
57 |   };
58 |   return dog;
59 | }
60 | 
61 | Dodgy.race = function (iterable) {
62 |   var dog = Promise.race(iterable).then(abort);
63 |   function abort(result) {
64 |     for (var i = 0; i < iterable.length; i++) {
65 |       if ('abort' in iterable[i]) iterable[i].abort();
66 |     }
67 |     return result;
68 |   }
69 |   dog.abort = abort;
70 |   return dog;
71 | };
72 | 
73 | export default Dodgy;
74 | export { Dodgy };
75 | 


--------------------------------------------------------------------------------
/index.js:
--------------------------------------------------------------------------------
 1 | var dodgy = (function (exports) {
 2 |   'use strict';
 3 | 
 4 |   function Dodgy(callback, resolvable) {
 5 |     var
 6 |       resolve, reject, abort,
 7 |       status = 'pending',
 8 |       dog = new Promise(function (res, rej) {
 9 |         callback(
10 |           resolve = function (value) {
11 |             if (status === 'pending') {
12 |               status = 'resolved';
13 |               dog.status = status;
14 |               res(value);
15 |             }
16 |           },
17 |           reject = function (value) {
18 |             if (status === 'pending') {
19 |               status = 'rejected';
20 |               dog.status = status;
21 |               rej(value);
22 |             }
23 |           },
24 |           function onAbort(callback) {
25 |             abort = function (reason) {
26 |               if (status === 'pending') {
27 |                 status = 'aborted';
28 |                 dog.status = status;
29 |                 rej(callback(reason));
30 |               }
31 |             };
32 |           }
33 |         );
34 |       })
35 |     ;
36 |     return evolved(dog, resolvable, abort, resolve, reject);
37 |   }
38 | 
39 |   function evolved(dog, resolvable, abort, resolve, reject) {
40 |     var
41 |       currentThen = dog.then,
42 |       currentCatch = dog.catch
43 |     ;
44 |     if (abort) dog.abort = abort;
45 |     if (resolvable) {
46 |       dog.resolve = resolve;
47 |       dog.reject = reject;
48 |     }
49 |     dog.then = function () {
50 |       return evolved(
51 |         currentThen.apply(dog, arguments),
52 |         resolvable, abort, resolve, reject
53 |       );
54 |     };
55 |     dog['catch'] = function () {
56 |       return evolved(
57 |         currentCatch.apply(dog, arguments),
58 |         resolvable, abort, resolve, reject
59 |       );
60 |     };
61 |     return dog;
62 |   }
63 | 
64 |   Dodgy.race = function (iterable) {
65 |     var dog = Promise.race(iterable).then(abort);
66 |     function abort(result) {
67 |       for (var i = 0; i < iterable.length; i++) {
68 |         if ('abort' in iterable[i]) iterable[i].abort();
69 |       }
70 |       return result;
71 |     }
72 |     dog.abort = abort;
73 |     return dog;
74 |   };
75 | 
76 |   exports.Dodgy = Dodgy;
77 |   exports.default = Dodgy;
78 | 
79 |   return exports;
80 | 
81 | }({}));
82 | 


--------------------------------------------------------------------------------
/package.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "name": "dodgy",
 3 |   "version": "1.4.0",
 4 |   "description": "Optionally abortable, resolvable, and rejectable promises",
 5 |   "main": "./cjs/index.js",
 6 |   "module": "./esm/index.js",
 7 |   "unpkg": "es.js",
 8 |   "scripts": {
 9 |     "test": "node test/.test.js",
10 |     "build": "npm run cjs && npm run rollup:es && npm run rollup:index && npm run test",
11 |     "cjs": "ascjs esm cjs",
12 |     "rollup:es": "rollup --config rollup/es.config.js",
13 |     "rollup:index": "rollup --config rollup/index.config.js"
14 |   },
15 |   "keywords": [
16 |     "Promise",
17 |     "cancellable",
18 |     "cancelable",
19 |     "abort",
20 |     "lie",
21 |     "dodgy"
22 |   ],
23 |   "author": "Andrea Giammarchi (http://webreflection.blogspot.com/)",
24 |   "license": "MIT",
25 |   "devDependencies": {
26 |     "ascjs": "^3.1.2",
27 |     "rollup": "^2.3.0",
28 |     "rollup-plugin-node-resolve": "^5.2.0",
29 |     "rollup-plugin-terser": "^5.3.0",
30 |     "wru": "*"
31 |   }
32 | }
33 | 


--------------------------------------------------------------------------------
/rollup/es.config.js:
--------------------------------------------------------------------------------
 1 | import resolve from 'rollup-plugin-node-resolve';
 2 | import {terser} from 'rollup-plugin-terser';
 3 | 
 4 | export default {
 5 |   input: './esm/index.js',
 6 |   plugins: [
 7 |     
 8 |     resolve({module: true}),
 9 |     terser()
10 |   ],
11 |   
12 |   output: {
13 |     exports: 'named',
14 |     file: './es.js',
15 |     format: 'iife',
16 |     name: 'dodgy'
17 |   }
18 | };
19 | 


--------------------------------------------------------------------------------
/rollup/index.config.js:
--------------------------------------------------------------------------------
 1 | import resolve from 'rollup-plugin-node-resolve';
 2 | 
 3 | export default {
 4 |   input: './esm/index.js',
 5 |   plugins: [
 6 |     
 7 |     resolve({module: true})
 8 |   ],
 9 |   
10 |   output: {
11 |     exports: 'named',
12 |     file: './index.js',
13 |     format: 'iife',
14 |     name: 'dodgy'
15 |   }
16 | };
17 | 


--------------------------------------------------------------------------------
/test/.test.js:
--------------------------------------------------------------------------------
 1 | var
 2 |   fs = require('fs'),
 3 |   path = require('path'),
 4 |   spawn = require('child_process').spawn,
 5 |   modules = path.join(__dirname, '..', 'node_modules', 'wru', 'node', 'program.js'),
 6 |   tests = [],
 7 |   ext = /\.js$/,
 8 |   code = 0,
 9 |   many = 0;
10 | 
11 | function exit($code) {
12 |   if ($code) {
13 |     code = $code;
14 |   }
15 |   if (!--many) {
16 |     if (!code) {
17 |       fs.writeFileSync(
18 |         path.join(__dirname, 'index.html'),
19 |         fs.readFileSync(
20 |           path.join(__dirname, 'index.html'),
21 |           'utf-8'
22 |         ).replace(/var TESTS = \[.*?\];/, 'var TESTS = ' + JSON.stringify(tests) + ';'),
23 |         'utf-8'
24 |       );
25 |     }
26 |     process.exit(code);
27 |   }
28 | }
29 | 
30 | fs.readdirSync(__dirname).filter(function(file){
31 |   if (ext.test(file) && (fs.existsSync || path.existsSync)(path.join(__dirname, '..', 'cjs', file))) {
32 |     ++many;
33 |     tests.push(file.replace(ext, ''));
34 |     spawn(
35 |       'node', [modules, path.join('test', file)], {
36 |       detached: false,
37 |       stdio: [process.stdin, process.stdout, process.stderr]
38 |     }).on('exit', exit);
39 |   }
40 | });
41 | 


--------------------------------------------------------------------------------
/test/dodgy.js:
--------------------------------------------------------------------------------
  1 | //remove:
  2 | var Dodgy = require('../cjs').default;
  3 | //:remove
  4 | 
  5 | wru.test([
  6 |   {
  7 |     name: 'main',
  8 |     test: function () {
  9 |       wru.assert(typeof Dodgy == "function");
 10 |     }
 11 |   },{
 12 |     name: 'works as promise',
 13 |     test: function () {
 14 |       var p = new Dodgy(function (res, rej) {
 15 |         setTimeout(function () {
 16 |           res('OK');
 17 |         }, 100);
 18 |       });
 19 |       wru.assert('p has no abortability', !p.abort);
 20 |       p.then(wru.async(function (allGood) {
 21 |         wru.assert(allGood);
 22 |       }));
 23 |     }
 24 |   },{
 25 |     name: 'abort as expected',
 26 |     test: function () {
 27 |       var p = new Dodgy(function (res, rej, onAbort) {
 28 |         var t = setTimeout(function () {
 29 |           res('OK');
 30 |         }, 100);
 31 |         onAbort(function () {
 32 |           clearTimeout(t);
 33 |           return 'FAIL';
 34 |         });
 35 |       });
 36 |       wru.assert('p can be aborted', p.abort);
 37 |       p.then(Object, wru.async(function (err) {
 38 |         wru.assert(err === 'FAIL');
 39 |       }));
 40 |       setTimeout(p.abort, 10);
 41 |     }
 42 |   },{
 43 |     name: 'chainable and resolvable',
 44 |     test: function () {
 45 |       var chain = new Dodgy(function (res, rej, onAbort) {
 46 |         var t = setTimeout(
 47 |           function () {
 48 |             res('OK');
 49 |           }, 100);
 50 |           onAbort(Object);
 51 |         },
 52 |         true
 53 |       );
 54 |       wru.assert('resolvable', chain.resolve);
 55 |       wru.assert('rejectable', chain.reject);
 56 |       chain = chain.then(Object, Object).then(Object, Object).then(Object, Object);
 57 |       wru.assert('still resolvable', chain.resolve);
 58 |       wru.assert('still rejectable', chain.reject);
 59 |       wru.assert('still abortable', chain.abort);
 60 |       chain.then(wru.async(function (msg) {
 61 |         wru.assert('message received', msg == 'EVEN BETTER');
 62 |       }));
 63 |       setTimeout(function () {
 64 |         chain.resolve('EVEN BETTER');
 65 |       }, 10);
 66 |     }
 67 |   },{
 68 |     name: 'chainable and rejectable',
 69 |     test: function () {
 70 |       function reThrow(err) {
 71 |         throw err;
 72 |       }
 73 |       var chain = new Dodgy(
 74 |         function (res, rej, onAbort) {
 75 |           var t = setTimeout(res, 100, 'OK');
 76 |           onAbort(Object);
 77 |         },
 78 |         true
 79 |       );
 80 |       wru.assert('resolvable', chain.resolve);
 81 |       wru.assert('rejectable', chain.reject);
 82 |       chain = chain.then(Object, reThrow)['catch'](reThrow).then(Object, reThrow)['catch'](reThrow);
 83 |       wru.assert('still resolvable', chain.resolve);
 84 |       wru.assert('still rejectable', chain.reject);
 85 |       wru.assert('still abortable', chain.abort);
 86 | 
 87 |       chain.then(Object, wru.async(function (msg) {
 88 |         wru.assert('message received', msg == 'EPIC FAIL');
 89 |       }));
 90 | 
 91 |       setTimeout(function () {
 92 |         chain.reject('EPIC FAIL');
 93 |       }, 10);
 94 |     }
 95 |   },{
 96 |     name: 'multiple abort not invoked',
 97 |     test: function () {
 98 |       var i = 0,  chain = new Dodgy(
 99 |         function (res, rej, onAbort) {
100 |           onAbort(function () {
101 |             ++i;
102 |           });
103 |         }
104 |       );
105 |       chain.abort();
106 |       chain.abort();
107 |       wru.log(i);
108 |       wru.assert('called only once', i === 1);
109 |     }
110 |   },{
111 |     name: 'Dodgy.race with no winner',
112 |     test: function () {
113 |       var
114 |         counter = 0,
115 |         firstDog = function () { if (++counter > 1) ok(); },
116 |         secondDog = function () { if (++counter > 1) ok(); },
117 |         ok = (function () {
118 |           wru.assert('everything was canceled', counter === 2);
119 |         })
120 |       ;
121 |       Dodgy.race([
122 |         new Dodgy(function (res, rej, onAbort) {
123 |           onAbort(firstDog);
124 |         }),
125 |         new Dodgy(function (res, rej, onAbort) {
126 |           onAbort(secondDog);
127 |         })
128 |       ]).abort();
129 |     }
130 |   } ,{
131 |     name: 'Dodgy.race with one winner',
132 |     test: function () {
133 |       var
134 |         result = [],
135 |         a = new Dodgy(function (res, rej, onAbort) {
136 |           setTimeout(res, 100, 123);
137 |           onAbort(function () {
138 |             result.push('a');
139 |           });
140 |         }),
141 |         b = new Dodgy(function (res, rej, onAbort) {
142 |           onAbort(function () {
143 |             result.push('b');
144 |           });
145 |         }),
146 |         race = Dodgy.race([a, b]).then(wru.async(function () {
147 |           wru.assert('b was canceled', result.join('') === 'b');
148 |         }))
149 |       ;
150 |     }
151 |   }, {
152 |     name: 'Resolvable but not abortable',
153 |     test: function () {
154 |       var
155 |         d = new Dodgy(function (res, rej) {
156 |           // should trigger too late
157 |           setTimeout(function () {
158 |             res(1);
159 |           }, 100);
160 |         }, true).then(wru.async(function (v) {
161 |           wru.assert('expected 2, got ' + v, v === 2);
162 |           setTimeout(wru.async(function (v) {
163 |             wru.assert('OK');
164 |             d.then(wru.async(function (v) {
165 |               wru.assert('expected 2, got ' + v, v === 2);
166 |               return v;
167 |             }));
168 |           }), 200);
169 |           return v;
170 |         }))
171 |       ;
172 |       wru.assert('abort is not set', !d.abort);
173 |       // should resolve
174 |       setTimeout(function () {
175 |         d.resolve(2);
176 |       }, 10);
177 |     }
178 |   }
179 | ]);
180 | 


--------------------------------------------------------------------------------
/test/index.html:
--------------------------------------------------------------------------------
  1 | <!doctype html>
  2 | <html>
  3 |     <head>
  4 |         <title>wru test</title>
  5 |         <meta http-equiv="content-language" content="en-US"/>
  6 |         <meta name="viewport" content="width=device-width,initial-scale=1.0,maximum-scale=1.0,user-scalable=no"/>
  7 |         <meta name="apple-mobile-web-app-capable" content="yes"/>
  8 |         <meta names="apple-mobile-web-app-status-bar-style" content="black"/>
  9 |         <script>
 10 |         if (!window.Promise)
 11 |           document.write('<script src="//raw.githubusercontent.com/jakearchibald/es6-promise/master/dist/es6-promise.js"><'+'/script>');
 12 |         // here the list of tests to run with wru
 13 |         var TESTS = ["index"];
 14 |         </script>
 15 |         <script>// don't change code here
 16 |         for(var i = 0; i < TESTS.length; document.write(
 17 |           '<script src="build/' + TESTS[i++] + '.js"><' + '/script>'
 18 |         ));
 19 |         function wru(wru){
 20 |           var
 21 |             all = [],
 22 |             test = wru.test,
 23 |             XHR = typeof XMLHttpRequest === typeof XHR ?
 24 |               function () {
 25 |                 return new ActiveXObject("Microsoft.XMLHTTP");
 26 |               } :
 27 |               function () {
 28 |                 return new XMLHttpRequest;
 29 |               }
 30 |           ;
 31 |           wru.test = function () {
 32 |             all = all.concat.apply(all, arguments);
 33 |           };
 34 |           function load(file, then) {
 35 |             var xhr = XHR();
 36 |             xhr.open('get', file, true);
 37 |             xhr.onreadystatechange = function () {
 38 |               if (xhr.readyState == 4) {
 39 |                 Function("wru", xhr.responseText.
 40 |                   replace(/\/\/remove:[^\x00]*?\/\/:remove/g, '')
 41 |                 )(wru);
 42 |                 then();
 43 |               }
 44 |             };
 45 |             xhr.send(null);
 46 |           }
 47 |           this.onload = function () {
 48 |             (function onload() {
 49 |               if (TESTS.length) {
 50 |                 load('test/' + TESTS.shift() + '.js?' + Math.random(), onload);
 51 |               } else {
 52 |                 wru.test = test;
 53 |                 wru.test(all);
 54 |               }
 55 |             }());
 56 |           };
 57 |         }</script>
 58 |         <meta http-equiv="content-type" content="text/html; charset=utf-8" />
 59 |         <meta name="viewport" content="width=device-width,initial-scale=1.0,maximum-scale=1.0,user-scalable=0" />
 60 |         <style type="text/css">
 61 | #wru {
 62 |     font-family: sans-serif;
 63 |     font-size: 11pt;
 64 |     border: 1px solid #333;
 65 | }
 66 | #wru div {
 67 |     cursor: default;
 68 |     padding: 0;
 69 |     color: #000;
 70 | }
 71 | #wru div span,
 72 | #wru div strong {
 73 |     display: block;
 74 |     padding: 4px;
 75 |     margin: 0;
 76 | }
 77 | #wru div ul {
 78 |     margin: 0;
 79 |     padding-bottom: 4px;
 80 | }
 81 | #wru div.pass {
 82 |     background: #90EE90;
 83 | }
 84 | #wru div.fail {
 85 |     background: #FF6347;
 86 | }
 87 | #wru div.error {
 88 |     background: #000;
 89 |     color: #FFF;
 90 | }
 91 |         </style>
 92 |     </head>
 93 |     <body>
 94 |         <div id="wru"></div>
 95 |         <script>
 96 | /*!
 97 | (C) Andrea Giammarchi, @WebReflection - Mit Style License
 98 | */
 99 | wru(function(Y){function j(){A=K.call(m);if(A){if(typeof A=="function"){A={name:A[S]||"anonymous",test:A}}(P=l(l(Z.node,"div"),"span"))[E]=((ag(A,S)&&A[S])||(ag(A,e)&&A[e])||Q)+i+i;a=[];u=[];T=[];ab={};b("setup");T[ah]||b("test");N||r()}else{t()}}function p(aj){try{return O.call(h,aj)}catch(ai){return h.createElement(aj)}}function l(ai,aj){return ai.appendChild(p(aj))}function g(ai){P[E]=x.call(P[E],0,-2)+i+ai}function t(){var ak=Z.node.insertBefore(p("div"),Z.node.firstChild),al,aj,ai;if(ad){ai=aj="error";al="There Are Errors: "+ad}else{if(C){ai=aj="fail";al=C+" Tests Failed"}else{ai=aj="pass";al="Passed "+s+" Tests"}}Z.status=ai;ak[E]="<strong>"+al+"</strong>";ak.className=aj}function G(){var ai=this.lastChild.style;ai.display=ai.display=="none"?"block":"none"}function c(ai){P[E]+="<ul>"+D+v.call(ai,d+D)+d+"</ul>";(P.onclick=G).call(P)}function r(){f();s+=a[ah];C+=u[ah];ad+=T[ah];g("("+v.call([a[ah],M=u[ah],T[ah]],", ")+")");P=P.parentNode;T[ah]?c(T,W="error"):(M?c(u,W="fail"):W="pass");P.className=W;M=0;W=i;j()}function b(ai){if(ag(A,ai)){try{A[ai](ab)}catch(aj){aa.call(T,i+aj)}}}function ag(aj,ai){return q.call(aj,ai)}function w(){return F()<0.5?-1:1}function f(){if(R){H(R);R=0}b("teardown")}var Z={assert:function U(aj,ai){if(arguments[ah]==1){ai=aj;aj=Q}z=I;aa.call(ai?a:u,W+aj);return ai},async:function V(aj,am,ak,al){al=++N;if(typeof aj=="function"){ak=am;am=aj;aj="asynchronous test #"+al}ak=X(function(){al=0;aa.call(u,aj);--N||(R=X(r,0))},L(ak||y)||y);return function ai(){if(!al){return}z=ae;W=aj+": ";try{am.apply(this,arguments)}catch(an){z=I;aa.call(T,W+an)}W=i;if(z){H(ak);--N||(R=X(r,0))}}},test:function n(ai,aj){Z.after=aj||function(){};m=J.apply(m,[ai]);Z.random&&af.call(m,w);N||j()}},I=true,ae=!I,y=100,i=" ",Q="unknown",ah="length",S="name",e="description",D="<li>",d="</li>",k="\\|/-",q=Z.hasOwnProperty,W=i,ac=W.charAt,x=W.slice,m=[],J=m.concat,v=m.join,aa=m.push,K=m.shift,af=m.sort,N=0,M=0,s=0,C=0,ad=0,R=0,E="innerHTML",h=Y.document,O=h.createElement,B,L,F,X,H,A,P,a,u,T,ab,z;B=Y.Math;L=B.abs;F=B.random;X=Y.setTimeout;H=Y.clearTimeout;Z.node=(h.getElementById("wru")||h.body||h.documentElement);Y.setInterval(function(){N&&g(ac.call(k,M++%4))},y);undefined;Z.log=function o(aj,ai){ai?alert(aj):(typeof console!="undefined")&&console.log(aj)};y*=y;Z.random=ae;return Z}(this));
100 |         </script>
101 |     </body>
102 | </html>
103 | 


--------------------------------------------------------------------------------
/test/index.js:
--------------------------------------------------------------------------------
1 | require('./dodgy');
2 | 


--------------------------------------------------------------------------------
/test/package.json:
--------------------------------------------------------------------------------
1 | {"type":"commonjs"}


--------------------------------------------------------------------------------
/test/testrunner.js:
--------------------------------------------------------------------------------
 1 | console.log('Loading: test.html');
 2 | var page = require('webpage').create();
 3 | var url = 'index.html';
 4 | page.open(url, function (status) {
 5 |   if (status === 'success') {
 6 |     setTimeout(function () {
 7 |       var results = page.evaluate(function() {
 8 |         // remove the first node with the total from the following counts
 9 |         var passed = Math.max(0, document.querySelectorAll('.pass').length - 1);
10 |         return {
11 |           // retrieve the total executed tests number
12 |           total: ''.concat(
13 |             passed,
14 |             ' blocks (',
15 |             document.querySelector('#wru strong').textContent.replace(/\D/g, ''),
16 |             ' single tests)'
17 |           ),
18 |           passed: passed,
19 |           failed: Math.max(0, document.querySelectorAll('.fail').length - 1),
20 |           failures: [].map.call(document.querySelectorAll('.fail'), function (node) {
21 |             return node.textContent;
22 |           }),
23 |           errored: Math.max(0, document.querySelectorAll('.error').length - 1),
24 |           errors: [].map.call(document.querySelectorAll('.error'), function (node) {
25 |             return node.textContent;
26 |           })
27 |         };
28 |       });
29 |       console.log('- - - - - - - - - -');
30 |       console.log('total:   ' + results.total);
31 |       console.log('- - - - - - - - - -');
32 |       console.log('passed:  ' + results.passed);
33 |       if (results.failed) {
34 |         console.log('failures: \n' + results.failures.join('\n'));
35 |       } else {
36 |         console.log('failed: ' + results.failed);
37 |       }
38 |       if (results.errored) {
39 |         console.log('errors: \n' + results.errors.join('\n'));
40 |       } else {
41 |         console.log('errored: ' + results.errored);
42 |       }
43 |       console.log('- - - - - - - - - -');
44 |       if (0 < results.failed + results.errored) {
45 |         status = 'failed';
46 |       }
47 |       phantom.exit(0);
48 |     }, 2000);
49 |   } else {
50 |     phantom.exit(1);
51 |   }
52 | });


--------------------------------------------------------------------------------