Brennan's async node

.gitignore

@@ -0,0 +1 @@
+node_modules/

README.md

@@ -1,2 +1,5 @@
 # assignment_async_nodejs
-Async Node.js sprint
+
+by Brennan Fulmer
+
+Just some Node.js practice

event_emitter/test_emitter.js

@@ -0,0 +1,31 @@
+
+var Emitter = require(`../modules/my_emitter.js`);
+// var Emitter = require('events');
+var emitter = new Emitter();
+
+function alpha() {
+  console.log(`alpha`);
+}
+
+function bravo() {
+  console.log(`bravo`);
+}
+
+function charlie() {
+  console.log(`charlie`);
+}
+
+emitter.on(`event`, alpha);
+emitter
+  .on(`event_2`, alpha)
+  .on("event", bravo)
+  .on(`event`, charlie);
+
+emitter.emit(`event`);
+emitter.emit(`event_2`);
+
+emitter.removeListener(`event`, alpha);
+emitter.removeAllListeners(`event_2`);
+
+emitter.emit(`event`);
+emitter.emit(`event_2`);

file_ops/dummy.txt

@@ -0,0 +1 @@
+Hello!Hello again!

file_ops/fsp_tester.js

@@ -0,0 +1,29 @@
+
+var fsp = require(`../modules/promise_fs`);
+
+fsp
+  .readFile(`dummy.txt`)
+  .then(function(data) {
+    console.log(data);
+  })
+  .catch(function(err) {
+    console.error(err);
+  });
+
+fsp
+  .writeFile(`dummy.txt`, `Hello!`)
+  .then(function(res) {
+    console.log(res);
+  })
+  .catch(function(err) {
+    console.error(err);
+  });
+
+fsp
+  .appendFile(`dummy.txt`, `Hello again!`)
+  .then(function(res) {
+    console.log(res);
+  })
+  .catch(function(err) {
+    console.error(err);
+  });

index.js

@@ -0,0 +1,13 @@
+
+console.log(`
+This repository contains three parts, they are:
+
+  1. warmup
+
+  2. file_ops
+
+  3. event_emitter
+
+as you've likely guessed to check them out run the .js file in each
+directory with node
+`);

modules/my_emitter.js

@@ -0,0 +1,46 @@
+
+var emitter = function() {
+  var events = {};
+
+  this.on = function(eventName, listener) {
+    if (events[eventName] == undefined) {
+      events[eventName] = [listener];
+    } else {
+      events[eventName].push(listener);
+    }
+    return this;
+  };
+
+  this.emit = function(eventName, ...rest) {
+    if (events[eventName] == undefined) {
+      return false;
+    } else if (rest.length == 0) {
+      for (var listeners in events[eventName]) {
+        events[eventName][listeners]();
+      }
+      return true;
+    } else {
+      for (var listeners in events[eventName]) {
+        events[eventName][listeners](rest);
+      }
+      return true;
+    }
+  };
+
+  this.removeListener = function(eventName, listener) {
+    if (events[eventName] != undefined) {
+      var index = events[eventName].indexOf(listener);
+      if (index != -1) {
+        events[eventName].splice(index, 1);
+      }
+    }
+    return this;
+  };
+
+  this.removeAllListeners = function(eventName) {
+    events[eventName] = undefined;
+    return this;
+  };
+};
+
+module.exports = emitter;

modules/promise_fs.js

@@ -0,0 +1,33 @@
+
+const fs = require(`fs`);
+
+var fsp = {
+  readFile: function(path) {
+    var rf = new Promise((resolve, reject) => {
+      fs.readFile(path, `utf8`, (err, data) => {
+        err ? reject(err) : resolve(data);
+      });
+    });
+    return rf;
+  },
+
+  writeFile: function(path, text) {
+    var wf = new Promise((resolve, reject) => {
+      fs.writeFile(path, text, `utf8`, (err, res) => {
+        err ? reject(err) : resolve(text);
+      });
+    });
+    return wf;
+  },
+
+  appendFile: function(path, text) {
+    var af = new Promise((resolve, reject) => {
+      fs.appendFile(path, text, `utf8`, (err, res) => {
+        err ? reject(err) : resolve(text);
+      });
+    });
+    return af;
+  }
+};
+
+module.exports = fsp;

package.json

@@ -0,0 +1,23 @@
+{
+  "name": "async",
+  "version": "1.0.0",
+  "description": "asynchronous node programming practice",
+  "main": "index.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/BrennanFulmer/assignment_async_nodejs.git"
+  },
+  "author": "Brennan",
+  "license": "ISC",
+  "bugs": {
+    "url": "https://github.com/BrennanFulmer/assignment_async_nodejs/issues"
+  },
+  "homepage": "https://github.com/BrennanFulmer/assignment_async_nodejs#readme",
+  "dependencies": {
+    "events": "^2.0.0",
+    "fs": "0.0.1-security"
+  }
+}

warmup/warmups.js

@@ -0,0 +1,95 @@
+
+// create a promise that resolves "Hello Promise!" after one second using .then
+var greet = new Promise(function(resolve, reject) {
+  setTimeout(() => {
+    resolve(`Hello Promise!`);
+  }, 1000);
+});
+
+greet.then(function(greeting) {
+  console.log(greeting);
+});
+
+/* Create a delay(milliseconds) function that should return a promise that
+resolves the value milliseconds after delaying for the specified number of
+milliseconds */
+function delay(milliseconds) {
+  return new Promise((resolve, reject) => {
+    setTimeout(() => {
+      if (milliseconds > 0) {
+        console.log(milliseconds);
+        resolve(milliseconds);
+      } else {
+        console.log(`Done!`);
+      }
+    }, milliseconds);
+  });
+}
+
+function countDown(time) {
+  return delay(time - 100);
+}
+
+delay(1000)
+  .then(countDown)
+  .then(countDown)
+  .then(countDown)
+  .then(countDown)
+  .then(countDown)
+  .then(countDown)
+  .then(countDown)
+  .then(countDown)
+  .then(countDown)
+  .then(countDown)
+  .then(countDown);
+
+/* Create a function that accepts a number and returns a promise that resolves
+that number squared, reject if not passed a number, and map an array of
+numbers 1-9 to the function using promise.all */
+var integers = [1, 2, 3, 4, 5, 6, 7, 8, 9];
+
+function squared(number) {
+  return new Promise((resolve, reject) => {
+    if (isNaN(number)) {
+      reject(`Argument wasn't a number`);
+    } else {
+      resolve(number * number);
+    }
+  });
+}
+
+Promise.all(integers.map(squared)).then(
+  results => {
+    console.log(results);
+  },
+  error => {
+    console.log(error);
+  }
+);
+
+/* basically play with the differences between then with and without catch and
+vice versa */
+function doBadThing(forRealz) {
+  var baddest = new Promise((resolve, reject) => {
+    if (forRealz == false) {
+      resolve(`Yay!`);
+    } else if (forRealz == true) {
+      reject(`Only false will resolve`);
+    }
+  });
+  baddest.then(
+    response => {
+      console.log(response);
+    },
+    broke => {
+      console.log(broke);
+    }
+  );
+  baddest.catch(error => {
+    console.log(error);
+  });
+  return baddest;
+}
+
+doBadThing(true);
+doBadThing(false);