Added README, LICENSE, Compiled File and Package.json

Author: Jamesernator

LICENSE

@@ -0,0 +1,7 @@
+Copyright (c) 2016 James "The Jamesernator" Browning
+
+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.

README.md

@@ -0,0 +1,141 @@
+# Async
+
+This is a basic wrapper around generators to create async functions:
+
+```javascript
+var async = require('es6-simple-async');
+
+var timer = function(time) {
+    return new Promise(function(resolve) {
+        setTimeout(resolve, time);
+    });
+};
+
+var delay = async(function*(time, message) {
+    yield timer(time);
+    console.log(message);
+});
+
+async.main(function*() {
+    yield delay(1000, "Hello");
+    yield delay(2000, "Goodbye");
+});
+
+```
+
+## Functions
+
+##### async(genFunction)
+This function takes a generator function and returns a function that will return a promise. Inside the generator whenever a yield is reached the value will be turned into a Promise then when the Promise is resolved it will resume the generator sending the value to the generator.
+
+```javascript
+var async = require('es6-simple-async');
+
+var timer = function(time) {
+    return new Promise(function(resolve) {
+        setTimeout(resolve, time);
+    });
+};
+
+var delay = async(function*(value, time) {
+    yield timer(1000); // Asynchrously completes the promise then
+                       // resumes the generator at this position
+    return value; // Resolves the promise of the async function so any
+                  // async function yielding on a Promise returned by this
+                  // function will recieve value when it resumes
+});
+
+async.main(function*() {
+    var value = yield delay('cats', 1000); // recieves value cat after
+                                           // 1000 milliseconds
+    console.log("Value");
+});
+```
+
+Errors are thrown back into the generator so:
+```javascript
+
+var task = async(function*() {
+    try {
+        var data = yield request('www.google.com');
+    } catch (err) {
+        // If request('www.google.com') rejects for whatever reason we'll
+        // an error will be thrown at the yield statement so we can just
+        // wrap it in a try/catch block as usual
+        console.log("Couldn't get data");
+    };
+});
+
+```
+
+
+
+##### async.run(genFunc) / async.do(genFunc)
+async.run (or the async.do alias) immediately invokes the given async function and returns a Promise for the value returned:
+```javascript
+var timer = function(time) {
+    return new Promise(function(resolve) {
+        setTimeout(resolve, time);
+    });
+};
+
+async.run(function*() {
+    yield timer(1000);
+    return 3;
+}).then(function(value) {
+    console.log(value); // Prints 3 after 1000 seconds
+});
+
+```
+
+
+##### async.main(genFunc)
+async.main is much like async.run but if there's an error it will print it to the console.
+
+
+##### async.from(iterable)
+async.from converts an iterable into an async function, this could be useful if creating custom iterators instead of using generators.
+
+```javascript
+
+var async = require('es6-simple-async');
+
+var timer = function(time) {
+    return new Promise(function(resolve) {
+        setTimeout(resolve, time);
+    });
+};
+
+var delay = async(function*(value, time) {
+    yield timer(1000); // Asynchrously completes the promise then
+                       // resumes the generator at this position
+    return value; // Resolves the promise of the async function so any
+                  // async function yielding on a Promise returned by this
+                  // function will recieve value when it resumes
+});
+
+var CustomIterator = function() {
+    this.value = 0;
+};
+
+CustomIterator.prototype.next = function() {
+    if (this.value < 10) {
+        this.value = this.value + 1;
+        var result = delay('cats', 1000);
+        return {value: result, done: false};
+    } else {
+        return {value: 10, done: true};
+    };
+};
+
+CustomIterator.prototype[Symbol.iterator] = function() {
+    return this;
+};
+
+var task = async.from(new CustomIterator());
+task().then(function(value) {
+    console.log(value); // Prints 10 after 10 seconds
+});
+
+
+```

async.coffee

@@ -73,6 +73,8 @@ async.from = (iterable) ->
     gen_func = -> yield from iterable
     return async(gen_func)
 
+async.do = async.run
+
 if module?
     module.exports = async
 else

async.js

@@ -0,0 +1,21 @@
+{
+  "name": "es6-simple-async",
+  "main": "./async.js",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Jamesernator/es6-simple-async"
+  },
+  "version": "0.9.9",
+  "author": "James \"The Jamesernator\" Browning",
+  "description": "This is a simple async wrapper for generators",
+  "devDependencies": {
+    "coffee-script": "latest",
+    "pre-commit": "latest"
+  },
+  "scripts": {
+    "build": "coffee -o . -c async.coffee"
+  },
+  "pre-commit": {
+    "run": "build"
+  }
+}