From ec17de65446c88d33556c5d3e315a64cc2fd03c0 Mon Sep 17 00:00:00 2001
From: Christian Adam <christian.g.adam@gmail.com>
Date: Thu, 8 Oct 2015 11:14:13 -0300
Subject: [PATCH] v0.0.6

Changes:

- It is possible now to get the list of result values.
- Introducing "torch" objects that can be passed among functions in the queue.
- Possible exceptions of the functions in the queue are now handled and returned as part of rejection value.
- Improved documentation adding dependencies state.
- Introducing alias all and allSync for resolveAllSync
---
 AUTHORS                  |   1 +
 CHANGELOG                |   8 ++
 LICENSE                  |  22 ++++
 README.md                | 249 +++++++++++++++++++++------------------
 demos/PSQueueTest.js     |  59 ++++++++++
 demos/PSQueueTestFail.js |  67 +++++++++++
 demos/QAllTest.js        |  56 +++++++++
 index.js                 |  32 ++++-
 package.json             |  15 +--
 psqueue.js               | 129 ++++++++++++++++----
 test/PSQueueTest.js      |  27 -----
 test/PSQueueTestFail.js  |  33 ------
 test/QAllTest.js         |  27 -----
 13 files changed, 488 insertions(+), 237 deletions(-)
 create mode 100644 AUTHORS
 create mode 100644 CHANGELOG
 create mode 100644 LICENSE
 create mode 100644 demos/PSQueueTest.js
 create mode 100644 demos/PSQueueTestFail.js
 create mode 100644 demos/QAllTest.js
 delete mode 100644 test/PSQueueTest.js
 delete mode 100644 test/PSQueueTestFail.js
 delete mode 100644 test/QAllTest.js

diff --git a/AUTHORS b/AUTHORS
new file mode 100644
index 0000000..bea2ce5
--- /dev/null
+++ b/AUTHORS
@@ -0,0 +1 @@
+Christian Adam <christian.g.adam@gmail.com>
diff --git a/CHANGELOG b/CHANGELOG
new file mode 100644
index 0000000..9ecea00
--- /dev/null
+++ b/CHANGELOG
@@ -0,0 +1,8 @@
+v0.0.6:
+  date: 2015-10-07
+  changes:
+    - It is possible now to get the list of result values.
+    - Introducing "torch" objects that can be passed among functions in the queue.
+    - Possible exceptions of the functions in the queue are now handled and returned as part of rejection value.
+    - Improved documentation adding dependencies state.
+    - Introducing alias all and allSync for resolveAllSync
diff --git a/LICENSE b/LICENSE
new file mode 100644
index 0000000..1ea1270
--- /dev/null
+++ b/LICENSE
@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 Christian Adam
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
diff --git a/README.md b/README.md
index f571242..1a65630 100644
--- a/README.md
+++ b/README.md
@@ -1,6 +1,7 @@
 # PSQueue (Promises Sync Queue)
 
 [![Gitter](https://badges.gitter.im/Join%20Chat.svg)](https://gitter.im/cgadam/psqueue?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
+[![dependencies](https://david-dm.org/cgadam/psqueue.png)](https://david-dm.org/cgadam/psqueue)
 
 ### Getting async ducks in a row.
 
@@ -13,174 +14,196 @@ If this is your case, then this module is for you.
 ## How to use it?
 
 1. Create a PSQueue.
-2. Generate your Q promise.
-3. Add the Q promise to the queue (indicating the parameters)
+2. Create your function that returns a Q promise.
+3. Add the function to the queue (indicating the parameters)
 4. Repeat steps 2 and 3 as many times as you want.
-5. Call PSQueue's method resolveAllSync() which will return a Q promise too. This returned promise is solved 
-once ALL the Q promises in the queue are solved. The good part is that the sync queue resolves them in ORDER and 
-ONE AT THE TIME! :)
+5. Call PSQueue's method resolveAllSync() which will return a Q promise too.
+
+The promise returned by resolveAllSync() will be resolved once ALL the Q promises in the
+queue are solved. The good part is that the sync queue resolves all the promises in ORDER: ONE AT THE TIME! :)
+
+The resolved value the promise returned by resolveAllSync() will contain an array with the resolved values of
+all the other synchronously executed promises of the queue.
+
+You can optionally define a *torch* object and pass it to resolveAllSync function. The object will be systematically passed between the functions in the queue.
+Functions can then modify the value and pass it to the following functions in the queue. You need to be sure that your function will actually proccess this parameter.
 
 Example:
 
 **Q.all** resolves all the promises *asynchronously*. So, in this example:
 
-
 ```javascript
-var Q = require('q');
-
-var timestamp = (new Date()).getTime();
-var arr = ['A', 'B', 'C'];
-
-function doPromiseToItem(item){
-  var deferred = Q.defer();
-  var randomFactor = 10000 * Math.random()
-  setTimeout(function(rand){
-    console.log(item + ' solved after random ' + (Math.round((rand/1000)*100)/100) + ' secs.');
-    deferred.resolve();
-  }, randomFactor, randomFactor);
-  return deferred.promise;
-}
-
-var promises = [];
-
-for(var i=0; i<arr.length;i++){
-  var item = arr[i];
-  var promise = doPromiseToItem(item);
-  promises.push(promise);
-}
-
-Q.all(promises).then(function(){
-  var duration = Math.round(((((new Date()).getTime()) - timestamp)/1000)*100)/100;
-  console.log('ALL SOLVED in ' + duration + ' seconds.');
-});
+    var Q = require('q');
+
+    var timestamp = (new Date()).getTime();
+    var arr = ['A', 'B', 'C'];
+
+    function doPromiseToItem(item) {
+      var deferred = Q.defer();
+      var randomFactor = 10000 * Math.random()
+      setTimeout(function (rand) {
+        console.log(item + ' solved after random ' + (Math.round((rand / 1000) * 100) / 100) + ' secs.');
+        deferred.resolve(item);
+      }, randomFactor, randomFactor);
+      return deferred.promise;
+    }
+
+    var promises = [];
+
+    for (var i = 0; i < arr.length; i++) {
+      var item = arr[i];
+      var promise = doPromiseToItem(item);
+      promises.push(promise);
+    }
+
+    Q.all(promises).then(function (arrResults) {
+      var duration = Math.round(((((new Date()).getTime()) - timestamp) / 1000) * 100) / 100;
+      console.log('ALL SOLVED in ' + duration + ' seconds.');
+      console.log('Results are:\n' + arrResults.join('\n'));
+    });
 ```
 If you execute it:
 
 ```bash
+    $ cd demos
     $ node QAllTest.js
 ```
 This is one possible output you might get:
 
 ```bash
-    B solved after random 0.25 secs.
-    C solved after random 4.05 secs.
-    A solved after random 8.95 secs.
-    ALL SOLVED in 8.95 seconds.
+    C solved after random 3.03 secs.
+    B solved after random 5.09 secs.
+    A solved after random 5.45 secs.
+    ALL SOLVED in 5.46 seconds.
+    Results are:
+    A
+    B
+    C
 ```
 
-As you can see *all of the promises ran in parallel* (not in a specific order -> B,C,A) and the time it took to complete 
+As you can see *all of the promises ran in parallel* (not in a specific order -> C,B,A) and the time it took to complete
 all of them is nothing but the time it took for the latest one to finish.
 
 **PSQueue** runs all the promises *in order* and *one at the time*:
+(Example using a torch value)
 
 ```javascript
-var Q = require('q');
-var PSQueue = require('psqueue');
-
-var timestamp = (new Date()).getTime();
-var arr = ['A', 'B', 'C'];
-
-function doPromiseToItem(item){
-  var deferred = Q.defer();
-  var randomFactor = 10000 * Math.random()
-  setTimeout(function(rand){
-    console.log(item + ' solved after random ' + (Math.round((rand/1000)*100)/100) + ' secs.');
-    deferred.resolve();
-  }, randomFactor, randomFactor);
-  return deferred.promise;
-}
-
-var promisesQueue = new PSQueue();
-
-for(var i=0; i<arr.length;i++){
-  var item = arr[i];
-  promisesQueue.addPromise(doPromiseToItem, item);
-}
-
-promisesQueue.resolveAllSync().then(function(){
-  var duration = Math.round(((((new Date()).getTime()) - timestamp)/1000)*100)/100;
-  console.log('ALL SOLVED in ' + duration + ' seconds.');
-});
+    var Q = require('q'),
+      PSQueue = require('../psqueue'),
+      timestamp = (new Date()).getTime(),
+      arr = ['A', 'B', 'C'],
+      promisesQueue = new PSQueue();
+
+    function doPromiseToItem(item, torch) {
+      var deferred = Q.defer();
+      var randomFactor = 10000 * Math.random();
+      setTimeout(function (rand) {
+        console.log(item + ' solved after ' + torch.text + ' taking random ' + (Math.round((rand / 1000) * 100) / 100) + ' secs.');
+        torch.text = (torch.text === 'BEGGINING OF TIME' ? item : (torch.text + ',' + item));
+        deferred.resolve(item + ':OK');
+      }, randomFactor, randomFactor);
+      return deferred.promise;
+    }
+
+    for (var i = 0; i < arr.length; i++) {
+      var item = arr[i];
+      promisesQueue.addPromise(doPromiseToItem, item);
+    }
+
+    promisesQueue.resolveAllSync({
+      text: 'BEGGINING OF TIME'
+    }).then(function (arrResults) {
+      var duration = Math.round(((((new Date()).getTime()) - timestamp) / 1000) * 100) / 100;
+      console.log('ALL SOLVED in ' + duration + ' seconds.');
+      console.log('Results are:\n' + arrResults.join('\n'));
+    });
 ```
 If you execute it:
 
 ```bash
+    $ cd demos
     $ node PSQueueTest.js
 ```
 This is one possible output you might get:
 
 ```bash
-    A solved after random 2.47 secs.
-    B solved after random 8.79 secs.
-    C solved after random 0.88 secs.
-    ALL SOLVED in 12.16 seconds.
+    A solved after BEGGINING OF TIME taking random 9.6 secs.
+    B solved after A taking random 5.55 secs.
+    C solved after A,B taking random 1.1 secs.
+    ALL SOLVED in 16.3 seconds.
+    Results are:
+    A:OK
+    B:OK
+    C:OK
 ```
 
-As you can see no matter how much time each individual promise took to be solved, all of them are executed 
-in order (A,B,C) and the total time is the sum of the time of each of them.
+As you can see no matter how much time each individual promise took to be solved, all of them are executed
+in order (A,B,C) and the total time is the sum of the time of each of them. Also you can see how the torch value is modified from function to function appening
+the name of the item that was previosuly executed. The result of the promises is then returned in an array (arrResults).
 
 **What if a promise in the queue fails?**
 
-If one promise in the queue fails, then the following promises in the queue are not executed and the rejection value is returned to the queue where you 
-can handle it.
+If one promise in the queue fails, then the following promises in the queue are not executed and the rejection value is used for rejecting the queue's promise.
 
 Example:
 
 ```javascript
-var Q = require('q');
-var PSQueue = require('psqueue');
-
-var timestamp = (new Date()).getTime();
-var arr = ['A', 'B', 'C', 'D'];
-
-function doPromiseToItem(item){
-  var deferred = Q.defer();
-  var randomFactor = 10000 * Math.random()
-  setTimeout(function(obj){
-    if(obj.item === 'C'){
-      console.log(item + ' NOT solved after random ' + (Math.round((obj.rand/1000)*100)/100) + ' secs.');
-      deferred.reject(obj.item);
-      return;
+    var Q = require('q'),
+      PSQueue = require('../psqueue'),
+      timestamp = (new Date()).getTime(),
+      arr = ['A', 'B', 'C', 'D'],
+      promisesQueue = new PSQueue();
+
+    function doPromiseToItem(item, torch) {
+      var deferred = Q.defer();
+      var randomFactor = 10000 * Math.random();
+      setTimeout(function (obj) {
+        if (obj.item === 'C') {
+          console.log(item + ' NOT solved after random ' + (Math.round((obj.rand / 1000) * 100) / 100) + ' secs.');
+          deferred.reject(obj.item);
+          return;
+        }
+        console.log(item + ' solved after random ' + (Math.round((obj.rand / 1000) * 100) / 100) + ' secs.');
+        torch.push(item);
+        deferred.resolve();
+      }, randomFactor, {
+        "rand": randomFactor,
+        "item": item
+      });
+      return deferred.promise;
     }
-    console.log(item + ' solved after random ' + (Math.round((obj.rand/1000)*100)/100) + ' secs.');
-    deferred.resolve();
-  }, randomFactor, {"rand":randomFactor,
-                    "item" : item});
-  return deferred.promise;
-}
 
-var promisesQueue = new PSQueue();
-
-for(var i=0; i<arr.length;i++){
-  var item = arr[i];
-  promisesQueue.addPromise(doPromiseToItem, item);
-}
+    for (var i = 0; i < arr.length; i++) {
+      var item = arr[i];
+      promisesQueue.addPromise(doPromiseToItem, item);
+    }
 
-promisesQueue.resolveAllSync().fail(function(err){
-  var duration = Math.round(((((new Date()).getTime()) - timestamp)/1000)*100)/100;
-  console.log('FAILED because I found ' + err + ' after ' + duration + ' seconds.');
-});
+    var partialResult = [];
 
+    promisesQueue.resolveAllSync(partialResult).fail(function (err, arrResults) {
+      var duration = Math.round(((((new Date()).getTime()) - timestamp) / 1000) * 100) / 100;
+      console.log('FAILED because I found ' + err + ' after ' + duration + ' seconds.');
+      console.log('Partial result is: ' + partialResult.join(','));
+    });
 ```
 
 If you execute it:
 
 ```bash
+    $ cd demos
     $ node PSQueueTestFail.js
 ```
 This is one possible output you might get:
 
 ```bash
-    A solved after random 5.33 secs.
-    B solved after random 2.01 secs.
-    C NOT solved after random 4.73 secs.
-    FAILED because I found C after 12.11 seconds.
+    A solved after random 7.35 secs.
+    B solved after random 5.06 secs.
+    C NOT solved after random 4.76 secs.
+    FAILED because I found C after 17.2 seconds.
+    Partial result is: A,B
 ```
 
-As you can see **D** was never executed.
-
-
-**What if one promise needs to pass a value to another promise in the chain?**
+As you can see **D** was never executed and the torch object has been used to obtain a possible partialResult.
 
-This scenario is NOT contemplated by this module as when you create the promises that you want to add to the 
-queue you're supposed to provide the exact parameters with which the promise will be called.
+### Alias for resolveAllSync
+You can use *all* and *allSync* as alias of resolveAllSync
diff --git a/demos/PSQueueTest.js b/demos/PSQueueTest.js
new file mode 100644
index 0000000..0cbe6fc
--- /dev/null
+++ b/demos/PSQueueTest.js
@@ -0,0 +1,59 @@
+/*
+  The MIT License (MIT)
+
+  Copyright (c) 2015 Christian Adam
+
+  Permission is hereby granted, free of charge, to any person obtaining a copy
+  of this software and associated documentation files (the "Software"), to deal
+  in the Software without restriction, including without limitation the rights
+  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+  copies of the Software, and to permit persons to whom the Software is
+  furnished to do so, subject to the following conditions:
+
+  The above copyright notice and this permission notice shall be included in all
+  copies or substantial portions of the Software.
+
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+  SOFTWARE.
+*/
+
+/**
+  @overview A test file for showing how to use PSQueue. This test represent a happy scenario.
+  @author Christian Adam
+*/
+
+/* jshint node:true */
+var Q = require('q'),
+  PSQueue = require('../psqueue'),
+  timestamp = (new Date()).getTime(),
+  arr = ['A', 'B', 'C'],
+  promisesQueue = new PSQueue();
+
+function doPromiseToItem(item, torch) {
+  var deferred = Q.defer();
+  var randomFactor = 10000 * Math.random();
+  setTimeout(function (rand) {
+    console.log(item + ' solved after ' + torch.text + ' taking random ' + (Math.round((rand / 1000) * 100) / 100) + ' secs.');
+    torch.text = (torch.text === 'BEGGINING OF TIME' ? item : (torch.text + ',' + item));
+    deferred.resolve(item + ':OK');
+  }, randomFactor, randomFactor);
+  return deferred.promise;
+}
+
+for (var i = 0; i < arr.length; i++) {
+  var item = arr[i];
+  promisesQueue.addPromise(doPromiseToItem, item);
+}
+
+promisesQueue.resolveAllSync({
+  text: 'BEGGINING OF TIME'
+}).then(function (arrResults) {
+  var duration = Math.round(((((new Date()).getTime()) - timestamp) / 1000) * 100) / 100;
+  console.log('ALL SOLVED in ' + duration + ' seconds.');
+  console.log('Results are:\n' + arrResults.join('\n'));
+});
diff --git a/demos/PSQueueTestFail.js b/demos/PSQueueTestFail.js
new file mode 100644
index 0000000..7bd2564
--- /dev/null
+++ b/demos/PSQueueTestFail.js
@@ -0,0 +1,67 @@
+/*
+  The MIT License (MIT)
+
+  Copyright (c) 2015 Christian Adam
+
+  Permission is hereby granted, free of charge, to any person obtaining a copy
+  of this software and associated documentation files (the "Software"), to deal
+  in the Software without restriction, including without limitation the rights
+  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+  copies of the Software, and to permit persons to whom the Software is
+  furnished to do so, subject to the following conditions:
+
+  The above copyright notice and this permission notice shall be included in all
+  copies or substantial portions of the Software.
+
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+  SOFTWARE.
+*/
+
+/**
+  @overview A test file for showing how to use PSQueue. This test represent a failing scenario.
+  @author Christian Adam
+*/
+
+/* jshint node:true */
+var Q = require('q'),
+  PSQueue = require('../psqueue'),
+  timestamp = (new Date()).getTime(),
+  arr = ['A', 'B', 'C', 'D'],
+  promisesQueue = new PSQueue();
+
+function doPromiseToItem(item, torch) {
+  var deferred = Q.defer();
+  var randomFactor = 10000 * Math.random();
+  setTimeout(function (obj) {
+    if (obj.item === 'C') {
+      console.log(item + ' NOT solved after random ' + (Math.round((obj.rand / 1000) * 100) / 100) + ' secs.');
+      deferred.reject(obj.item);
+      return;
+    }
+    console.log(item + ' solved after random ' + (Math.round((obj.rand / 1000) * 100) / 100) + ' secs.');
+    torch.push(item);
+    deferred.resolve();
+  }, randomFactor, {
+    "rand": randomFactor,
+    "item": item
+  });
+  return deferred.promise;
+}
+
+for (var i = 0; i < arr.length; i++) {
+  var item = arr[i];
+  promisesQueue.addPromise(doPromiseToItem, item);
+}
+
+var partialResult = [];
+
+promisesQueue.resolveAllSync(partialResult).fail(function (err, arrResults) {
+  var duration = Math.round(((((new Date()).getTime()) - timestamp) / 1000) * 100) / 100;
+  console.log('FAILED because I found ' + err + ' after ' + duration + ' seconds.');
+  console.log('Partial result is: ' + partialResult.join(','));
+});
diff --git a/demos/QAllTest.js b/demos/QAllTest.js
new file mode 100644
index 0000000..6897a40
--- /dev/null
+++ b/demos/QAllTest.js
@@ -0,0 +1,56 @@
+/*
+  The MIT License (MIT)
+
+  Copyright (c) 2015 Christian Adam
+
+  Permission is hereby granted, free of charge, to any person obtaining a copy
+  of this software and associated documentation files (the "Software"), to deal
+  in the Software without restriction, including without limitation the rights
+  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+  copies of the Software, and to permit persons to whom the Software is
+  furnished to do so, subject to the following conditions:
+
+  The above copyright notice and this permission notice shall be included in all
+  copies or substantial portions of the Software.
+
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+  SOFTWARE.
+*/
+
+/**
+  @overview A test file for showing how Q.all works.
+  @author Christian Adam
+*/
+
+/* jshint node:true */
+var Q = require('q'),
+  timestamp = (new Date()).getTime(),
+  arr = ['A', 'B', 'C'],
+  promises = [];
+
+function doPromiseToItem(item) {
+  var deferred = Q.defer();
+  var randomFactor = 10000 * Math.random();
+  setTimeout(function (rand) {
+    console.log(item + ' solved after random ' + (Math.round((rand / 1000) * 100) / 100) + ' secs.');
+    deferred.resolve(item);
+  }, randomFactor, randomFactor);
+  return deferred.promise;
+}
+
+for (var i = 0; i < arr.length; i++) {
+  var item = arr[i];
+  var promise = doPromiseToItem(item);
+  promises.push(promise);
+}
+
+Q.all(promises).then(function (arrResults) {
+  var duration = Math.round(((((new Date()).getTime()) - timestamp) / 1000) * 100) / 100;
+  console.log('ALL SOLVED in ' + duration + ' seconds.');
+  console.log('Results are:\n' + arrResults.join('\n'));
+});
diff --git a/index.js b/index.js
index 7aac58a..e5ec6ac 100644
--- a/index.js
+++ b/index.js
@@ -1 +1,31 @@
-module.exports = require('./psqueue');
\ No newline at end of file
+/*
+  The MIT License (MIT)
+
+  Copyright (c) 2015 Christian Adam
+
+  Permission is hereby granted, free of charge, to any person obtaining a copy
+  of this software and associated documentation files (the "Software"), to deal
+  in the Software without restriction, including without limitation the rights
+  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+  copies of the Software, and to permit persons to whom the Software is
+  furnished to do so, subject to the following conditions:
+
+  The above copyright notice and this permission notice shall be included in all
+  copies or substantial portions of the Software.
+
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+  SOFTWARE.
+*/
+
+/**
+  @overview The main of PSQueue.
+  @author Christian Adam
+*/
+
+/* jshint node:true */
+module.exports = require('./psqueue');
diff --git a/package.json b/package.json
index 0abf004..91810d0 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "psqueue",
-  "version": "0.0.5",
+  "version": "0.0.6",
   "description": "A module to execute a list of promises in order and synchronously",
   "main": "index.js",
   "repository": {
@@ -17,24 +17,19 @@
     "list",
     "sync",
     "synchronously",
-    "queue"
+    "queue",
+    "torch"
   ],
   "dependencies": {
     "q": "*"
   },
-  "devDependencies": {
-    "q": "*"
-  },
   "author": {
     "name": "Christian Adam",
     "email": "christian.g.adam@gmail.com"
   },
-  "license": {
-    "type": "WTFPL",
-    "url": "http://www.wtfpl.net/txt/copying/"
-  },
+  "license": "MIT",
   "bugs": {
     "url": "https://github.com/cgadam/psqueue/issues"
   },
   "homepage": "https://github.com/cgadam/psqueue"
-}
\ No newline at end of file
+}
diff --git a/psqueue.js b/psqueue.js
index 296efeb..798084d 100644
--- a/psqueue.js
+++ b/psqueue.js
@@ -1,43 +1,120 @@
+/*
+  The MIT License (MIT)
+
+  Copyright (c) 2015 Christian Adam
+
+  Permission is hereby granted, free of charge, to any person obtaining a copy
+  of this software and associated documentation files (the "Software"), to deal
+  in the Software without restriction, including without limitation the rights
+  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+  copies of the Software, and to permit persons to whom the Software is
+  furnished to do so, subject to the following conditions:
+
+  The above copyright notice and this permission notice shall be included in all
+  copies or substantial portions of the Software.
+
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+  SOFTWARE.
+*/
+
+/**
+  @overview PSQueue module.
+  @author Christian Adam
+*/
+
+/* jshint node:true */
 var Q = require('q');
 
-function Promise(fn, params){
+/**
+ * A class representing a Promise
+ * @param {function} fn A function returning a Q promise.
+ * @param {object} params An array of params to pass to the function.
+ */
+function Promise(fn, params) {
   this.fn_ = fn;
   this.params_ = params;
 }
 
-function PSQueue(){
-  this.internalQueu_=[];
+/**
+ * A class representing a Queue of promises
+ * that will be solved synchronously.
+ *
+ */
+function PSQueue() {
+  this.internalQueu_ = [];
+  this.resultsList = [];
 }
 
-PSQueue.prototype.addPromise = function(fn){
-  var argsLength = arguments.length;
-  var parameters = [];
-  for(var i=1; i<argsLength; i++){
+/**
+ * Adds a promise to the queue
+ * @param {function} fn A function generating a promise.
+ */
+PSQueue.prototype.addPromise = function (fn) {
+  if (typeof fn !== 'function') {
+    throw new Error('You should add functions returning Q promises.');
+  }
+  var argsLength = arguments.length,
+    parameters = [];
+  for (var i = 1; i < argsLength; i++) {
     parameters.push(arguments[i]);
   }
   var promise = new Promise(fn, parameters);
   this.internalQueu_.push(promise);
-}
+};
 
-PSQueue.prototype.resolveAllSync = function(){
-  var deferred = Q.defer();
-  var self = this;
-  if(this.internalQueu_.length!==0){
-   var promiseObj = this.internalQueu_.shift();
-   promiseObj.fn_.apply(this, promiseObj.params_).then(function(){
-        self.resolveAllSync().then(function(){
-                                deferred.resolve();})
-                             .fail(function(err){
-                                deferred.reject(err);
-                            });
-    }).fail(function(err){
+/**
+ * Resolves all the promises added to the queue in order.
+ * @param   {object} torch An optional torch object that will be passed as last parameter in following promises.
+ * @returns {object} A Q promise that will be solved once all promises are solved in order. The promise will resolve to an
+ *                   array of values corresponding to the resolving values of each promise. If the promise fails it will
+ *                   pass the corresponding error.
+ */
+PSQueue.prototype.resolveAllSync = function (torch) {
+  var deferred = Q.defer(),
+    self = this;
+  if (this.internalQueu_.length !== 0) {
+    var promiseObj = this.internalQueu_.shift();
+    if (typeof torch === 'object') {
+      promiseObj.params_.push(torch);
+    }
+    try {
+      promiseObj.fn_.apply(this, promiseObj.params_).then(function (result) {
+        self.resultsList.push(result);
+        self.resolveAllSync(torch).then(function (resultsList) {
+            deferred.resolve(resultsList);
+          })
+          .fail(function (err) {
+            deferred.reject(err);
+          });
+      }).fail(function (err) {
+        deferred.reject(err);
+      });
+    } catch (err) {
       deferred.reject(err);
-    });
-  }
-  else{
-    deferred.resolve();
+    }
+  } else {
+    deferred.resolve(self.resultsList);
   }
   return deferred.promise;
-}
+};
+
+/**
+ * Alias for resolveAllSync
+ */
+PSQueue.prototype.allSync = function(torch){
+  return this.resolveAllSync(torch);
+};
+
+/**
+ * Alias for resolveAllSync
+ */
+PSQueue.prototype.all = function(torch){
+  return this.resolveAllSync(torch);
+};
 
-module.exports = PSQueue;
\ No newline at end of file
+module.exports = PSQueue;
diff --git a/test/PSQueueTest.js b/test/PSQueueTest.js
deleted file mode 100644
index 58b5adb..0000000
--- a/test/PSQueueTest.js
+++ /dev/null
@@ -1,27 +0,0 @@
-var Q = require('q');
-var PSQueue = require('../psqueue');
-
-var timestamp = (new Date()).getTime();
-var arr = ['A', 'B', 'C'];
-
-function doPromiseToItem(item){
-  var deferred = Q.defer();
-  var randomFactor = 10000 * Math.random()
-  setTimeout(function(rand){
-    console.log(item + ' solved after random ' + (Math.round((rand/1000)*100)/100) + ' secs.');
-    deferred.resolve();
-  }, randomFactor, randomFactor);
-  return deferred.promise;
-}
-
-var promisesQueue = new PSQueue();
-
-for(var i=0; i<arr.length;i++){
-  var item = arr[i];
-  promisesQueue.addPromise(doPromiseToItem, item);
-}
-
-promisesQueue.resolveAllSync().then(function(){
-  var duration = Math.round(((((new Date()).getTime()) - timestamp)/1000)*100)/100;
-  console.log('ALL SOLVED in ' + duration + ' seconds.');
-});
\ No newline at end of file
diff --git a/test/PSQueueTestFail.js b/test/PSQueueTestFail.js
deleted file mode 100644
index 8a8bab8..0000000
--- a/test/PSQueueTestFail.js
+++ /dev/null
@@ -1,33 +0,0 @@
-var Q = require('q');
-var PSQueue = require('../psqueue');
-
-var timestamp = (new Date()).getTime();
-var arr = ['A', 'B', 'C', 'D'];
-
-function doPromiseToItem(item){
-  var deferred = Q.defer();
-  var randomFactor = 10000 * Math.random()
-  setTimeout(function(obj){
-    if(obj.item === 'C'){
-      console.log(item + ' NOT solved after random ' + (Math.round((obj.rand/1000)*100)/100) + ' secs.');
-      deferred.reject(obj.item);
-      return;
-    }
-    console.log(item + ' solved after random ' + (Math.round((obj.rand/1000)*100)/100) + ' secs.');
-    deferred.resolve();
-  }, randomFactor, {"rand":randomFactor,
-                    "item" : item});
-  return deferred.promise;
-}
-
-var promisesQueue = new PSQueue();
-
-for(var i=0; i<arr.length;i++){
-  var item = arr[i];
-  promisesQueue.addPromise(doPromiseToItem, item);
-}
-
-promisesQueue.resolveAllSync().fail(function(err){
-  var duration = Math.round(((((new Date()).getTime()) - timestamp)/1000)*100)/100;
-  console.log('FAILED because I found ' + err + ' after ' + duration + ' seconds.');
-});
\ No newline at end of file
diff --git a/test/QAllTest.js b/test/QAllTest.js
deleted file mode 100644
index ad703e9..0000000
--- a/test/QAllTest.js
+++ /dev/null
@@ -1,27 +0,0 @@
-var Q = require('q');
-
-var timestamp = (new Date()).getTime();
-var arr = ['A', 'B', 'C'];
-
-function doPromiseToItem(item){
-  var deferred = Q.defer();
-  var randomFactor = 10000 * Math.random()
-  setTimeout(function(rand){
-    console.log(item + ' solved after random ' + (Math.round((rand/1000)*100)/100) + ' secs.');
-    deferred.resolve();
-  }, randomFactor, randomFactor);
-  return deferred.promise;
-}
-
-var promises = [];
-
-for(var i=0; i<arr.length;i++){
-  var item = arr[i];
-  var promise = doPromiseToItem(item);
-  promises.push(promise);
-}
-
-Q.all(promises).then(function(){
-  var duration = Math.round(((((new Date()).getTime()) - timestamp)/1000)*100)/100;
-  console.log('ALL SOLVED in ' + duration + ' seconds.');
-});
\ No newline at end of file