From f618a44b9e845e4cd15efe697b1a426ccc839b36 Mon Sep 17 00:00:00 2001
From: "David Humphrey (:humph) david.humphrey@senecacollege.ca"
 <david.humphrey@senecacollege.ca>
Date: Sat, 15 Feb 2014 10:05:04 -0500
Subject: [PATCH 01/17] Begin work on FileSystemShell and touch command

---
 src/fs.js    |  5 ++++
 src/index.js |  5 ++--
 src/shell.js | 78 ++++++++++++++++++++++++++++++++++++++++++++++++++++
 3 files changed, 86 insertions(+), 2 deletions(-)
 create mode 100644 src/shell.js

diff --git a/src/fs.js b/src/fs.js
index 5a8e223..122ce21 100644
--- a/src/fs.js
+++ b/src/fs.js
@@ -53,6 +53,7 @@ define(function(require) {
 
   var providers = require('src/providers/providers');
   var adapters = require('src/adapters/adapters');
+  var Shell = require('src/shell');
 
   /*
    * DirectoryEntry
@@ -2473,6 +2474,10 @@ define(function(require) {
       callback(error);
     }
   };
+  FileSystem.prototype.Shell = function(options) {
+    return new Shell(this, options);
+  };
+
   return FileSystem;
 
 });
diff --git a/src/index.js b/src/index.js
index eeebb53..f343bd6 100644
--- a/src/index.js
+++ b/src/index.js
@@ -4,7 +4,8 @@ define(function(require) {
 
   return {
     FileSystem: require('src/fs'),
+    FileSystemShell: require('src/shell'),
     Path: require('src/path')
-  }
+  };
 
-});
\ No newline at end of file
+});
diff --git a/src/shell.js b/src/shell.js
new file mode 100644
index 0000000..48eb925
--- /dev/null
+++ b/src/shell.js
@@ -0,0 +1,78 @@
+define(function(require) {
+
+  function Shell(fs, options) {
+    options = options || {};
+
+    var cwd = options.cwd || '/';
+
+    Object.defineProperty(this, 'fs', {
+      get: function() { return fs; },
+      enumerable: true
+    });
+
+    Object.defineProperty(this, 'cwd', {
+      get: function() { return cwd; },
+      enumerable: true
+    });
+
+    // We include `cd` on the this vs. proto so that
+    // we can access cwd without exposing it externally.
+    this.cd = function(path) {
+
+    };
+
+  }
+
+  Shell.prototype.ls = function(path) {
+
+  };
+
+  Shell.prototype.rm = function(path, options, callback) {
+
+  };
+
+  Shell.prototype.mv = function(path) {
+
+  };
+
+  Shell.prototype.cp = function(path) {
+
+  };
+
+  Shell.prototype.mkdir = function(path) {
+
+  };
+
+  Shell.prototype.touch = function(path, options, callback) {
+    var fs = this.fs;
+    path = Path.resolve(this.cwd, path);
+
+    function createFile(path) {
+      fs.writeFile(path, '', function(error) {
+        callback(error);
+      });
+    }
+
+    function updateTimes(path) {
+      var now = Date.now();
+      fs.utimes(path, now, now, function(error) {
+        callback(error);
+      });
+    }
+
+    fs.stat(path, function(error, stats) {
+      if(error) {
+        createFile(path);
+      } else {
+        updateTimes(path);
+      }
+    });
+  };
+
+  Shell.prototype.ln = function(path) {
+
+  };
+
+  return Shell;
+
+});

From e43b1ba551f7e74e4a7c078b3a90edd7a3a2b41b Mon Sep 17 00:00:00 2001
From: "David Humphrey (:humph) david.humphrey@senecacollege.ca"
 <david.humphrey@senecacollege.ca>
Date: Sat, 15 Feb 2014 10:54:54 -0500
Subject: [PATCH 02/17] Working touch command with tests

---
 src/shell.js                   |  27 ++++++++-
 tests/lib/test-utils.js        |   5 ++
 tests/spec/shell/touch.spec.js | 104 +++++++++++++++++++++++++++++++++
 tests/test-manifest.js         |   3 +
 4 files changed, 137 insertions(+), 2 deletions(-)
 create mode 100644 tests/spec/shell/touch.spec.js

diff --git a/src/shell.js b/src/shell.js
index 48eb925..c1f18b5 100644
--- a/src/shell.js
+++ b/src/shell.js
@@ -1,5 +1,9 @@
 define(function(require) {
 
+  var Path = require('src/path');
+
+
+
   function Shell(fs, options) {
     options = options || {};
 
@@ -43,8 +47,19 @@ define(function(require) {
 
   };
 
+  /**
+   * Create a file if it does not exist, or update access and
+   * modified times if it does. Valid options include:
+   *
+   *  * create - whether to create the file if missing (defaults to true)
+   *  * date - use the provided Date value instead of current date/time
+   */
   Shell.prototype.touch = function(path, options, callback) {
     var fs = this.fs;
+    if(typeof options === 'function') {
+      callback = options;
+      options = {};
+    }
     path = Path.resolve(this.cwd, path);
 
     function createFile(path) {
@@ -55,14 +70,22 @@ define(function(require) {
 
     function updateTimes(path) {
       var now = Date.now();
-      fs.utimes(path, now, now, function(error) {
+      var atime = options.date || now;
+      var mtime = options.date || now;
+
+      fs.utimes(path, atime, mtime, function(error) {
         callback(error);
       });
     }
 
     fs.stat(path, function(error, stats) {
       if(error) {
-        createFile(path);
+        // Skip file creation if create is `false`
+        if(options.create === false) {
+          callback();
+        } else {
+          createFile(path);
+        }
       } else {
         updateTimes(path);
       }
diff --git a/tests/lib/test-utils.js b/tests/lib/test-utils.js
index 666a2f2..bca7658 100644
--- a/tests/lib/test-utils.js
+++ b/tests/lib/test-utils.js
@@ -68,6 +68,10 @@ function(Filer, IndexedDBTestProvider, WebSQLTestProvider, MemoryTestProvider) {
     return _provider;
   }
 
+  function shell() {
+    return fs().Shell();
+  }
+
   function cleanup(callback) {
     if(!_provider) {
       return;
@@ -100,6 +104,7 @@ function(Filer, IndexedDBTestProvider, WebSQLTestProvider, MemoryTestProvider) {
     uniqueName: uniqueName,
     setup: setup,
     fs: fs,
+    shell: shell,
     provider: provider,
     providers: {
       IndexedDB: IndexedDBTestProvider,
diff --git a/tests/spec/shell/touch.spec.js b/tests/spec/shell/touch.spec.js
new file mode 100644
index 0000000..ba86827
--- /dev/null
+++ b/tests/spec/shell/touch.spec.js
@@ -0,0 +1,104 @@
+define(["Filer", "util"], function(Filer, util) {
+
+  function getTimes(fs, path, callback) {
+    fs.stat(path, function(error, stats) {
+      if(error) throw error;
+      callback({mtime: stats.mtime, atime: stats.atime});
+    });
+  }
+
+  describe('FileSystemShell.touch', function() {
+    beforeEach(util.setup);
+    afterEach(util.cleanup);
+
+    it('should be a function', function() {
+      var shell = util.shell();
+      expect(shell.touch).to.be.a('function');
+    });
+
+    it('should create a new file if path does not exist', function(done) {
+      var fs = util.fs();
+      var shell = fs.Shell();
+
+      shell.touch('/newfile', function(error) {
+        if(error) throw error;
+
+        fs.stat('/newfile', function(error, stats) {
+          expect(error).not.to.exist;
+          expect(stats.type).to.equal('FILE');
+          done();
+        });
+      });
+    });
+
+    it('should skip creating a new file if options.create is false', function(done) {
+      var fs = util.fs();
+      var shell = fs.Shell();
+
+      shell.touch('/newfile', { create: false }, function(error) {
+        if(error) throw error;
+
+        fs.stat('/newfile', function(error, stats) {
+          expect(error).to.exist;
+          done();
+        });
+      });
+    });
+
+    it('should update times if path does exist', function(done) {
+      var fs = util.fs();
+      var shell = fs.Shell();
+      var atime = Date.parse('1 Oct 2000 15:33:22');
+      var mtime = Date.parse('30 Sep 2000 06:43:54');
+
+      fs.open('/newfile', 'w', function (error, fd) {
+        if (error) throw error;
+
+        fs.futimes(fd, atime, mtime, function (error) {
+          if(error) throw error;
+
+          fs.close(fd, function(error) {
+            if(error) throw error;
+
+            getTimes(fs, '/newfile', function(times1) {
+              shell.touch('/newfile', function(error) {
+                expect(error).not.to.exist;
+
+                getTimes(fs, '/newfile', function(times2) {
+                  expect(times2.mtime).to.be.above(times1.mtime);
+                  expect(times2.atime).to.be.above(times1.atime);
+                  done();
+                });
+              });
+            });
+          });
+        });
+      });
+    });
+
+    it('should update times to specified date if path does exist', function(done) {
+      var fs = util.fs();
+      var shell = fs.Shell();
+      var date = Date.parse('1 Oct 2001 15:33:22');
+
+      fs.open('/newfile', 'w', function (error, fd) {
+        if (error) throw error;
+
+        fs.close(fd, function(error) {
+          if(error) throw error;
+
+          shell.touch('/newfile', { date: date }, function(error) {
+            expect(error).not.to.exist;
+
+            getTimes(fs, '/newfile', function(times) {
+              expect(times.mtime).to.equal(date);
+              expect(times.atime).to.equal(date);
+              done();
+            });
+          });
+        });
+      });
+    });
+  });
+
+});
diff --git a/tests/test-manifest.js b/tests/test-manifest.js
index 73e8ae5..f7f77e4 100644
--- a/tests/test-manifest.js
+++ b/tests/test-manifest.js
@@ -42,6 +42,9 @@ define([
   "spec/adapters/adapters.spec",
   "spec/adapters/adapters.general.spec",
 
+  // Filer.FileSystemShell.*
+  "spec/shell/touch.spec",
+
   // Ported node.js tests (filenames match names in https://github.com/joyent/node/tree/master/test)
   "spec/node-js/simple/test-fs-mkdir",
   "spec/node-js/simple/test-fs-null-bytes",

From 263b9cd9b0a6f776d76b674ab5cf441bb8e70a96 Mon Sep 17 00:00:00 2001
From: "David Humphrey (:humph) david.humphrey@senecacollege.ca"
 <david.humphrey@senecacollege.ca>
Date: Sat, 15 Feb 2014 15:28:00 -0500
Subject: [PATCH 03/17] Add shell.exec with test

---
 src/shell.js                   | 68 ++++++++++++++++++++--------------
 tests/spec/shell/exec.spec.js  | 33 +++++++++++++++++
 tests/spec/shell/touch.spec.js |  4 +-
 tests/test-manifest.js         |  1 +
 4 files changed, 77 insertions(+), 29 deletions(-)
 create mode 100644 tests/spec/shell/exec.spec.js

diff --git a/src/shell.js b/src/shell.js
index c1f18b5..06957ea 100644
--- a/src/shell.js
+++ b/src/shell.js
@@ -2,8 +2,6 @@ define(function(require) {
 
   var Path = require('src/path');
 
-
-
   function Shell(fs, options) {
     options = options || {};
 
@@ -22,36 +20,55 @@ define(function(require) {
     // We include `cd` on the this vs. proto so that
     // we can access cwd without exposing it externally.
     this.cd = function(path) {
-
+      this.cwd = Path.resolve(this.cwd, path);
     };
 
   }
 
-  Shell.prototype.ls = function(path) {
-
-  };
-
-  Shell.prototype.rm = function(path, options, callback) {
-
-  };
-
-  Shell.prototype.mv = function(path) {
-
-  };
-
-  Shell.prototype.cp = function(path) {
-
-  };
-
-  Shell.prototype.mkdir = function(path) {
+  /**
+   * Execute the .js command located at `path`. Such commands
+   * should assume the existence of 3 arguments, which will be
+   * defined at runtime:
+   *
+   *   * options - an object containing any arguments, data, etc.
+   *   * callback - a callback function(error, result) to call when done.
+   *
+   * The .js command's contents should be the body of a function
+   * that looks like this:
+   *
+   * function(fs, options, callback) {
+   *   // .js code here
+   * }
+   */
+  Shell.prototype.exec = function(path, options, callback) {
+    var fs = this.fs;
+    if(typeof options === 'function') {
+      callback = options;
+      options = {};
+    }
+    options = options || {};
+    callback = callback || function(){};
+    path = Path.resolve(this.cwd, path);
 
+    fs.readFile(path, "utf8", function(error, data) {
+      if(error) {
+        callback(error);
+        return;
+      }
+      try {
+        var cmd = new Function('fs', 'options', 'callback', data);
+        cmd(fs, options, callback);
+      } catch(e) {
+        callback(e);
+      }
+    });
   };
 
   /**
    * Create a file if it does not exist, or update access and
    * modified times if it does. Valid options include:
    *
-   *  * create - whether to create the file if missing (defaults to true)
+   *  * updateOnly - whether to create the file if missing (defaults to false)
    *  * date - use the provided Date value instead of current date/time
    */
   Shell.prototype.touch = function(path, options, callback) {
@@ -60,6 +77,8 @@ define(function(require) {
       callback = options;
       options = {};
     }
+    options = options || {};
+    callback = callback || function(){};
     path = Path.resolve(this.cwd, path);
 
     function createFile(path) {
@@ -80,8 +99,7 @@ define(function(require) {
 
     fs.stat(path, function(error, stats) {
       if(error) {
-        // Skip file creation if create is `false`
-        if(options.create === false) {
+        if(options.updateOnly === true) {
           callback();
         } else {
           createFile(path);
@@ -92,10 +110,6 @@ define(function(require) {
     });
   };
 
-  Shell.prototype.ln = function(path) {
-
-  };
-
   return Shell;
 
 });
diff --git a/tests/spec/shell/exec.spec.js b/tests/spec/shell/exec.spec.js
new file mode 100644
index 0000000..6f325a0
--- /dev/null
+++ b/tests/spec/shell/exec.spec.js
@@ -0,0 +1,33 @@
+define(["Filer", "util"], function(Filer, util) {
+
+  describe('FileSystemShell.exec', function() {
+    beforeEach(util.setup);
+    afterEach(util.cleanup);
+
+    it('should be a function', function() {
+      var shell = util.shell();
+      expect(shell.exec).to.be.a('function');
+    });
+
+    it('should be able to execute a command .js file from the filesystem', function(done) {
+      var fs = util.fs();
+      var shell = fs.Shell();
+      var cmdString = "fs.writeFile(options.path, options.data, callback);";
+
+      fs.writeFile('/cmd.js', cmdString, function(error) {
+        if(error) throw error;
+
+        shell.exec('/cmd.js', {path: '/test', data: 'hello world'}, function(error, result) {
+          if(error) throw error;
+
+          fs.readFile('/test', 'utf8', function(error, data) {
+            if(error) throw error;
+            expect(data).to.equal('hello world');
+            done();
+          });
+        });
+      });
+    });
+  });
+
+});
diff --git a/tests/spec/shell/touch.spec.js b/tests/spec/shell/touch.spec.js
index ba86827..3b3a12a 100644
--- a/tests/spec/shell/touch.spec.js
+++ b/tests/spec/shell/touch.spec.js
@@ -31,11 +31,11 @@ define(["Filer", "util"], function(Filer, util) {
       });
     });
 
-    it('should skip creating a new file if options.create is false', function(done) {
+    it('should skip creating a new file if options.updateOnly is true', function(done) {
       var fs = util.fs();
       var shell = fs.Shell();
 
-      shell.touch('/newfile', { create: false }, function(error) {
+      shell.touch('/newfile', { updateOnly: true }, function(error) {
         if(error) throw error;
 
         fs.stat('/newfile', function(error, stats) {
diff --git a/tests/test-manifest.js b/tests/test-manifest.js
index f7f77e4..3faf91d 100644
--- a/tests/test-manifest.js
+++ b/tests/test-manifest.js
@@ -44,6 +44,7 @@ define([
 
   // Filer.FileSystemShell.*
   "spec/shell/touch.spec",
+  "spec/shell/exec.spec",
 
   // Ported node.js tests (filenames match names in https://github.com/joyent/node/tree/master/test)
   "spec/node-js/simple/test-fs-mkdir",

From 2d3b15d31074a61626c91e359bc45ff03044a4d8 Mon Sep 17 00:00:00 2001
From: "David Humphrey (:humph) david.humphrey@senecacollege.ca"
 <david.humphrey@senecacollege.ca>
Date: Sat, 15 Feb 2014 15:43:38 -0500
Subject: [PATCH 04/17] Deal with jshint hating the Function constructor

---
 gruntfile.js | 19 +++++++++++--------
 src/shell.js |  1 +
 2 files changed, 12 insertions(+), 8 deletions(-)

diff --git a/gruntfile.js b/gruntfile.js
index 1b627ad..13fa88e 100644
--- a/gruntfile.js
+++ b/gruntfile.js
@@ -18,14 +18,17 @@ module.exports = function(grunt) {
 
     jshint: {
       // Don't bother with src/path.js
-      all: ['gruntfile.js',
-            'src/constants.js',
-            'src/error.js',
-            'src/fs.js',
-            'src/shared.js',
-            'src/providers/**/*.js',
-            'src/adapters/**/*.js'
-           ]
+      all: [
+        'gruntfile.js',
+        'src/constants.js',
+        'src/error.js',
+        'src/fs.js',
+        'src/index.js',
+        'src/shared.js',
+        'src/shell.js',
+        'src/providers/**/*.js',
+        'src/adapters/**/*.js'
+      ]
     },
 
     mocha: {
diff --git a/src/shell.js b/src/shell.js
index 06957ea..c53699a 100644
--- a/src/shell.js
+++ b/src/shell.js
@@ -1,3 +1,4 @@
+/* jshint evil:true */
 define(function(require) {
 
   var Path = require('src/path');

From d7cce709f965f2bf16c6d8f5be4d451330ccc3e7 Mon Sep 17 00:00:00 2001
From: "David Humphrey (:humph) david.humphrey@senecacollege.ca"
 <david.humphrey@senecacollege.ca>
Date: Mon, 17 Feb 2014 10:47:47 -0500
Subject: [PATCH 05/17] Fix shell.cd and add tests

---
 src/shell.js                |  29 ++++++----
 tests/spec/shell/cd.spec.js | 104 ++++++++++++++++++++++++++++++++++++
 tests/test-manifest.js      |   1 +
 3 files changed, 124 insertions(+), 10 deletions(-)
 create mode 100644 tests/spec/shell/cd.spec.js

diff --git a/src/shell.js b/src/shell.js
index c53699a..4b31b81 100644
--- a/src/shell.js
+++ b/src/shell.js
@@ -2,11 +2,12 @@
 define(function(require) {
 
   var Path = require('src/path');
+  var Error = require('src/error');
 
   function Shell(fs, options) {
     options = options || {};
 
-    var cwd = options.cwd || '/';
+    var cwd = '/';
 
     Object.defineProperty(this, 'fs', {
       get: function() { return fs; },
@@ -20,10 +21,22 @@ define(function(require) {
 
     // We include `cd` on the this vs. proto so that
     // we can access cwd without exposing it externally.
-    this.cd = function(path) {
-      this.cwd = Path.resolve(this.cwd, path);
+    this.cd = function(path, callback) {
+      path = Path.resolve(this.cwd, path);
+      // Make sure the path actually exists, and is a dir
+      fs.stat(path, function(err, stats) {
+        if(err) {
+          callback(new Error.ENotDirectory());
+          return;
+        }
+        if(stats.type === 'DIRECTORY') {
+          cwd = path;
+          callback();
+        } else {
+          callback(new Error.ENotDirectory());
+        }
+      });
     };
-
   }
 
   /**
@@ -83,9 +96,7 @@ define(function(require) {
     path = Path.resolve(this.cwd, path);
 
     function createFile(path) {
-      fs.writeFile(path, '', function(error) {
-        callback(error);
-      });
+      fs.writeFile(path, '', callback);
     }
 
     function updateTimes(path) {
@@ -93,9 +104,7 @@ define(function(require) {
       var atime = options.date || now;
       var mtime = options.date || now;
 
-      fs.utimes(path, atime, mtime, function(error) {
-        callback(error);
-      });
+      fs.utimes(path, atime, mtime, callback);
     }
 
     fs.stat(path, function(error, stats) {
diff --git a/tests/spec/shell/cd.spec.js b/tests/spec/shell/cd.spec.js
new file mode 100644
index 0000000..8f01264
--- /dev/null
+++ b/tests/spec/shell/cd.spec.js
@@ -0,0 +1,104 @@
+define(["Filer", "util"], function(Filer, util) {
+
+  describe('FileSystemShell.cd', function() {
+    beforeEach(util.setup);
+    afterEach(util.cleanup);
+
+    it('should be a function', function() {
+      var shell = util.shell();
+      expect(shell.cd).to.be.a('function');
+    });
+
+    it('should default to a cwd of /', function() {
+      var shell = util.shell();
+      expect(shell.cwd).to.equal('/');
+    });
+
+    it('should allow changing the path to a valid dir', function(done) {
+      var fs = util.fs();
+      var shell = fs.Shell();
+
+      fs.mkdir('/dir', function(err) {
+        if(err) throw err;
+
+        expect(shell.cwd).to.equal('/');
+        shell.cd('/dir', function(err) {
+          expect(err).not.to.exist;
+          expect(shell.cwd).to.equal('/dir');
+          done();
+        });
+      });
+    });
+
+    it('should fail when changing the path to an invalid dir', function(done) {
+      var fs = util.fs();
+      var shell = fs.Shell();
+
+      fs.mkdir('/dir', function(err) {
+        if(err) throw err;
+
+        expect(shell.cwd).to.equal('/');
+        shell.cd('/nodir', function(err) {
+          expect(err).to.exist;
+          expect(err.name).to.equal('ENotDirectory');
+          expect(shell.cwd).to.equal('/');
+          done();
+        });
+      });
+    });
+
+    it('should fail when changing the path to a file', function(done) {
+      var fs = util.fs();
+      var shell = fs.Shell();
+
+      fs.writeFile('/file', 'file', function(err) {
+        if(err) throw err;
+
+        expect(shell.cwd).to.equal('/');
+        shell.cd('/file', function(err) {
+          expect(err).to.exist;
+          expect(err.name).to.equal('ENotDirectory');
+          expect(shell.cwd).to.equal('/');
+          done();
+        });
+      });
+    });
+
+    it('should allow relative paths for a valid dir', function(done) {
+      var fs = util.fs();
+      var shell = fs.Shell();
+
+      fs.mkdir('/dir', function(err) {
+        if(err) throw err;
+
+        expect(shell.cwd).to.equal('/');
+        shell.cd('./dir', function(err) {
+          expect(err).not.to.exist;
+          expect(shell.cwd).to.equal('/dir');
+          done();
+        });
+      });
+    });
+
+    it('should allow .. in paths for a valid dir', function(done) {
+      var fs = util.fs();
+      var shell = fs.Shell();
+
+      fs.mkdir('/dir', function(err) {
+        if(err) throw err;
+
+        expect(shell.cwd).to.equal('/');
+        shell.cd('./dir', function(err) {
+          expect(err).not.to.exist;
+          expect(shell.cwd).to.equal('/dir');
+          shell.cd('..', function(err) {
+            expect(err).not.to.exist;
+            expect(shell.cwd).to.equal('/');
+            done();
+          });
+        });
+      });
+    });
+
+  });
+});
diff --git a/tests/test-manifest.js b/tests/test-manifest.js
index 3faf91d..2fa4f63 100644
--- a/tests/test-manifest.js
+++ b/tests/test-manifest.js
@@ -43,6 +43,7 @@ define([
   "spec/adapters/adapters.general.spec",
 
   // Filer.FileSystemShell.*
+  "spec/shell/cd.spec",
   "spec/shell/touch.spec",
   "spec/shell/exec.spec",
 

From ef095267402327eddc89d218fe9bedd6bfd3b880 Mon Sep 17 00:00:00 2001
From: "David Humphrey (:humph) david.humphrey@senecacollege.ca"
 <david.humphrey@senecacollege.ca>
Date: Mon, 17 Feb 2014 16:55:36 -0500
Subject: [PATCH 06/17] Add cd test for symlink'ed dir

---
 tests/spec/shell/cd.spec.js | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)

diff --git a/tests/spec/shell/cd.spec.js b/tests/spec/shell/cd.spec.js
index 8f01264..151b703 100644
--- a/tests/spec/shell/cd.spec.js
+++ b/tests/spec/shell/cd.spec.js
@@ -100,5 +100,24 @@ define(["Filer", "util"], function(Filer, util) {
       });
     });
 
+    it('should follow symlinks to dirs', function(done) {
+      var fs = util.fs();
+
+      fs.mkdir('/dir', function(error) {
+        if(error) throw error;
+
+        fs.symlink('/dir', '/link', function(error) {
+          if(error) throw error;
+
+          var shell = fs.Shell();
+          shell.cd('link', function(error) {
+            expect(error).not.to.exist;
+            expect(shell.cwd).to.equal('/link');
+            done();
+          });
+        });
+      });
+    });
+
   });
 });

From 2829079bd318a4ef7943b287efe4eb070bf3d0d5 Mon Sep 17 00:00:00 2001
From: "David Humphrey (:humph) david.humphrey@senecacollege.ca"
 <david.humphrey@senecacollege.ca>
Date: Tue, 18 Feb 2014 14:51:06 -0500
Subject: [PATCH 07/17] Add Shell.cat() with tests

---
 lib/async.js                 | 964 +++++++++++++++++++++++++++++++++++
 src/shell.js                 |  45 +-
 tests/spec/shell/cat.spec.js |  82 +++
 tests/test-manifest.js       |   1 +
 4 files changed, 1089 insertions(+), 3 deletions(-)
 create mode 100644 lib/async.js
 create mode 100644 tests/spec/shell/cat.spec.js

diff --git a/lib/async.js b/lib/async.js
new file mode 100644
index 0000000..2f52b6c
--- /dev/null
+++ b/lib/async.js
@@ -0,0 +1,964 @@
+/*global setImmediate: false, setTimeout: false, console: false */
+
+/**
+ * https://raw.github.com/caolan/async/master/lib/async.js Feb 18, 2014
+ * Used under MIT - https://github.com/caolan/async/blob/master/LICENSE
+ */
+
+(function () {
+
+    var async = {};
+
+    // global on the server, window in the browser
+    var root, previous_async;
+
+    root = this;
+    if (root != null) {
+      previous_async = root.async;
+    }
+
+    async.noConflict = function () {
+        root.async = previous_async;
+        return async;
+    };
+
+    function only_once(fn) {
+        var called = false;
+        return function() {
+            if (called) throw new Error("Callback was already called.");
+            called = true;
+            fn.apply(root, arguments);
+        }
+    }
+
+    //// cross-browser compatiblity functions ////
+
+    var _each = function (arr, iterator) {
+        if (arr.forEach) {
+            return arr.forEach(iterator);
+        }
+        for (var i = 0; i < arr.length; i += 1) {
+            iterator(arr[i], i, arr);
+        }
+    };
+
+    var _map = function (arr, iterator) {
+        if (arr.map) {
+            return arr.map(iterator);
+        }
+        var results = [];
+        _each(arr, function (x, i, a) {
+            results.push(iterator(x, i, a));
+        });
+        return results;
+    };
+
+    var _reduce = function (arr, iterator, memo) {
+        if (arr.reduce) {
+            return arr.reduce(iterator, memo);
+        }
+        _each(arr, function (x, i, a) {
+            memo = iterator(memo, x, i, a);
+        });
+        return memo;
+    };
+
+    var _keys = function (obj) {
+        if (Object.keys) {
+            return Object.keys(obj);
+        }
+        var keys = [];
+        for (var k in obj) {
+            if (obj.hasOwnProperty(k)) {
+                keys.push(k);
+            }
+        }
+        return keys;
+    };
+
+    //// exported async module functions ////
+
+    //// nextTick implementation with browser-compatible fallback ////
+    if (typeof process === 'undefined' || !(process.nextTick)) {
+        if (typeof setImmediate === 'function') {
+            async.nextTick = function (fn) {
+                // not a direct alias for IE10 compatibility
+                setImmediate(fn);
+            };
+            async.setImmediate = async.nextTick;
+        }
+        else {
+            async.nextTick = function (fn) {
+                setTimeout(fn, 0);
+            };
+            async.setImmediate = async.nextTick;
+        }
+    }
+    else {
+        async.nextTick = process.nextTick;
+        if (typeof setImmediate !== 'undefined') {
+            async.setImmediate = function (fn) {
+              // not a direct alias for IE10 compatibility
+              setImmediate(fn);
+            };
+        }
+        else {
+            async.setImmediate = async.nextTick;
+        }
+    }
+
+    async.each = function (arr, iterator, callback) {
+        callback = callback || function () {};
+        if (!arr.length) {
+            return callback();
+        }
+        var completed = 0;
+        _each(arr, function (x) {
+            iterator(x, only_once(function (err) {
+                if (err) {
+                    callback(err);
+                    callback = function () {};
+                }
+                else {
+                    completed += 1;
+                    if (completed >= arr.length) {
+                        callback(null);
+                    }
+                }
+            }));
+        });
+    };
+    async.forEach = async.each;
+
+    async.eachSeries = function (arr, iterator, callback) {
+        callback = callback || function () {};
+        if (!arr.length) {
+            return callback();
+        }
+        var completed = 0;
+        var iterate = function () {
+            iterator(arr[completed], function (err) {
+                if (err) {
+                    callback(err);
+                    callback = function () {};
+                }
+                else {
+                    completed += 1;
+                    if (completed >= arr.length) {
+                        callback(null);
+                    }
+                    else {
+                        iterate();
+                    }
+                }
+            });
+        };
+        iterate();
+    };
+    async.forEachSeries = async.eachSeries;
+
+    async.eachLimit = function (arr, limit, iterator, callback) {
+        var fn = _eachLimit(limit);
+        fn.apply(null, [arr, iterator, callback]);
+    };
+    async.forEachLimit = async.eachLimit;
+
+    var _eachLimit = function (limit) {
+
+        return function (arr, iterator, callback) {
+            callback = callback || function () {};
+            if (!arr.length || limit <= 0) {
+                return callback();
+            }
+            var completed = 0;
+            var started = 0;
+            var running = 0;
+
+            (function replenish () {
+                if (completed >= arr.length) {
+                    return callback();
+                }
+
+                while (running < limit && started < arr.length) {
+                    started += 1;
+                    running += 1;
+                    iterator(arr[started - 1], function (err) {
+                        if (err) {
+                            callback(err);
+                            callback = function () {};
+                        }
+                        else {
+                            completed += 1;
+                            running -= 1;
+                            if (completed >= arr.length) {
+                                callback();
+                            }
+                            else {
+                                replenish();
+                            }
+                        }
+                    });
+                }
+            })();
+        };
+    };
+
+
+    var doParallel = function (fn) {
+        return function () {
+            var args = Array.prototype.slice.call(arguments);
+            return fn.apply(null, [async.each].concat(args));
+        };
+    };
+    var doParallelLimit = function(limit, fn) {
+        return function () {
+            var args = Array.prototype.slice.call(arguments);
+            return fn.apply(null, [_eachLimit(limit)].concat(args));
+        };
+    };
+    var doSeries = function (fn) {
+        return function () {
+            var args = Array.prototype.slice.call(arguments);
+            return fn.apply(null, [async.eachSeries].concat(args));
+        };
+    };
+
+
+    var _asyncMap = function (eachfn, arr, iterator, callback) {
+        var results = [];
+        arr = _map(arr, function (x, i) {
+            return {index: i, value: x};
+        });
+        eachfn(arr, function (x, callback) {
+            iterator(x.value, function (err, v) {
+                results[x.index] = v;
+                callback(err);
+            });
+        }, function (err) {
+            callback(err, results);
+        });
+    };
+    async.map = doParallel(_asyncMap);
+    async.mapSeries = doSeries(_asyncMap);
+    async.mapLimit = function (arr, limit, iterator, callback) {
+        return _mapLimit(limit)(arr, iterator, callback);
+    };
+
+    var _mapLimit = function(limit) {
+        return doParallelLimit(limit, _asyncMap);
+    };
+
+    // reduce only has a series version, as doing reduce in parallel won't
+    // work in many situations.
+    async.reduce = function (arr, memo, iterator, callback) {
+        async.eachSeries(arr, function (x, callback) {
+            iterator(memo, x, function (err, v) {
+                memo = v;
+                callback(err);
+            });
+        }, function (err) {
+            callback(err, memo);
+        });
+    };
+    // inject alias
+    async.inject = async.reduce;
+    // foldl alias
+    async.foldl = async.reduce;
+
+    async.reduceRight = function (arr, memo, iterator, callback) {
+        var reversed = _map(arr, function (x) {
+            return x;
+        }).reverse();
+        async.reduce(reversed, memo, iterator, callback);
+    };
+    // foldr alias
+    async.foldr = async.reduceRight;
+
+    var _filter = function (eachfn, arr, iterator, callback) {
+        var results = [];
+        arr = _map(arr, function (x, i) {
+            return {index: i, value: x};
+        });
+        eachfn(arr, function (x, callback) {
+            iterator(x.value, function (v) {
+                if (v) {
+                    results.push(x);
+                }
+                callback();
+            });
+        }, function (err) {
+            callback(_map(results.sort(function (a, b) {
+                return a.index - b.index;
+            }), function (x) {
+                return x.value;
+            }));
+        });
+    };
+    async.filter = doParallel(_filter);
+    async.filterSeries = doSeries(_filter);
+    // select alias
+    async.select = async.filter;
+    async.selectSeries = async.filterSeries;
+
+    var _reject = function (eachfn, arr, iterator, callback) {
+        var results = [];
+        arr = _map(arr, function (x, i) {
+            return {index: i, value: x};
+        });
+        eachfn(arr, function (x, callback) {
+            iterator(x.value, function (v) {
+                if (!v) {
+                    results.push(x);
+                }
+                callback();
+            });
+        }, function (err) {
+            callback(_map(results.sort(function (a, b) {
+                return a.index - b.index;
+            }), function (x) {
+                return x.value;
+            }));
+        });
+    };
+    async.reject = doParallel(_reject);
+    async.rejectSeries = doSeries(_reject);
+
+    var _detect = function (eachfn, arr, iterator, main_callback) {
+        eachfn(arr, function (x, callback) {
+            iterator(x, function (result) {
+                if (result) {
+                    main_callback(x);
+                    main_callback = function () {};
+                }
+                else {
+                    callback();
+                }
+            });
+        }, function (err) {
+            main_callback();
+        });
+    };
+    async.detect = doParallel(_detect);
+    async.detectSeries = doSeries(_detect);
+
+    async.some = function (arr, iterator, main_callback) {
+        async.each(arr, function (x, callback) {
+            iterator(x, function (v) {
+                if (v) {
+                    main_callback(true);
+                    main_callback = function () {};
+                }
+                callback();
+            });
+        }, function (err) {
+            main_callback(false);
+        });
+    };
+    // any alias
+    async.any = async.some;
+
+    async.every = function (arr, iterator, main_callback) {
+        async.each(arr, function (x, callback) {
+            iterator(x, function (v) {
+                if (!v) {
+                    main_callback(false);
+                    main_callback = function () {};
+                }
+                callback();
+            });
+        }, function (err) {
+            main_callback(true);
+        });
+    };
+    // all alias
+    async.all = async.every;
+
+    async.sortBy = function (arr, iterator, callback) {
+        async.map(arr, function (x, callback) {
+            iterator(x, function (err, criteria) {
+                if (err) {
+                    callback(err);
+                }
+                else {
+                    callback(null, {value: x, criteria: criteria});
+                }
+            });
+        }, function (err, results) {
+            if (err) {
+                return callback(err);
+            }
+            else {
+                var fn = function (left, right) {
+                    var a = left.criteria, b = right.criteria;
+                    return a < b ? -1 : a > b ? 1 : 0;
+                };
+                callback(null, _map(results.sort(fn), function (x) {
+                    return x.value;
+                }));
+            }
+        });
+    };
+
+    async.auto = function (tasks, callback) {
+        callback = callback || function () {};
+        var keys = _keys(tasks);
+        if (!keys.length) {
+            return callback(null);
+        }
+
+        var results = {};
+
+        var listeners = [];
+        var addListener = function (fn) {
+            listeners.unshift(fn);
+        };
+        var removeListener = function (fn) {
+            for (var i = 0; i < listeners.length; i += 1) {
+                if (listeners[i] === fn) {
+                    listeners.splice(i, 1);
+                    return;
+                }
+            }
+        };
+        var taskComplete = function () {
+            _each(listeners.slice(0), function (fn) {
+                fn();
+            });
+        };
+
+        addListener(function () {
+            if (_keys(results).length === keys.length) {
+                callback(null, results);
+                callback = function () {};
+            }
+        });
+
+        _each(keys, function (k) {
+            var task = (tasks[k] instanceof Function) ? [tasks[k]]: tasks[k];
+            var taskCallback = function (err) {
+                var args = Array.prototype.slice.call(arguments, 1);
+                if (args.length <= 1) {
+                    args = args[0];
+                }
+                if (err) {
+                    var safeResults = {};
+                    _each(_keys(results), function(rkey) {
+                        safeResults[rkey] = results[rkey];
+                    });
+                    safeResults[k] = args;
+                    callback(err, safeResults);
+                    // stop subsequent errors hitting callback multiple times
+                    callback = function () {};
+                }
+                else {
+                    results[k] = args;
+                    async.setImmediate(taskComplete);
+                }
+            };
+            var requires = task.slice(0, Math.abs(task.length - 1)) || [];
+            var ready = function () {
+                return _reduce(requires, function (a, x) {
+                    return (a && results.hasOwnProperty(x));
+                }, true) && !results.hasOwnProperty(k);
+            };
+            if (ready()) {
+                task[task.length - 1](taskCallback, results);
+            }
+            else {
+                var listener = function () {
+                    if (ready()) {
+                        removeListener(listener);
+                        task[task.length - 1](taskCallback, results);
+                    }
+                };
+                addListener(listener);
+            }
+        });
+    };
+
+    async.waterfall = function (tasks, callback) {
+        callback = callback || function () {};
+        if (tasks.constructor !== Array) {
+          var err = new Error('First argument to waterfall must be an array of functions');
+          return callback(err);
+        }
+        if (!tasks.length) {
+            return callback();
+        }
+        var wrapIterator = function (iterator) {
+            return function (err) {
+                if (err) {
+                    callback.apply(null, arguments);
+                    callback = function () {};
+                }
+                else {
+                    var args = Array.prototype.slice.call(arguments, 1);
+                    var next = iterator.next();
+                    if (next) {
+                        args.push(wrapIterator(next));
+                    }
+                    else {
+                        args.push(callback);
+                    }
+                    async.setImmediate(function () {
+                        iterator.apply(null, args);
+                    });
+                }
+            };
+        };
+        wrapIterator(async.iterator(tasks))();
+    };
+
+    var _parallel = function(eachfn, tasks, callback) {
+        callback = callback || function () {};
+        if (tasks.constructor === Array) {
+            eachfn.map(tasks, function (fn, callback) {
+                if (fn) {
+                    fn(function (err) {
+                        var args = Array.prototype.slice.call(arguments, 1);
+                        if (args.length <= 1) {
+                            args = args[0];
+                        }
+                        callback.call(null, err, args);
+                    });
+                }
+            }, callback);
+        }
+        else {
+            var results = {};
+            eachfn.each(_keys(tasks), function (k, callback) {
+                tasks[k](function (err) {
+                    var args = Array.prototype.slice.call(arguments, 1);
+                    if (args.length <= 1) {
+                        args = args[0];
+                    }
+                    results[k] = args;
+                    callback(err);
+                });
+            }, function (err) {
+                callback(err, results);
+            });
+        }
+    };
+
+    async.parallel = function (tasks, callback) {
+        _parallel({ map: async.map, each: async.each }, tasks, callback);
+    };
+
+    async.parallelLimit = function(tasks, limit, callback) {
+        _parallel({ map: _mapLimit(limit), each: _eachLimit(limit) }, tasks, callback);
+    };
+
+    async.series = function (tasks, callback) {
+        callback = callback || function () {};
+        if (tasks.constructor === Array) {
+            async.mapSeries(tasks, function (fn, callback) {
+                if (fn) {
+                    fn(function (err) {
+                        var args = Array.prototype.slice.call(arguments, 1);
+                        if (args.length <= 1) {
+                            args = args[0];
+                        }
+                        callback.call(null, err, args);
+                    });
+                }
+            }, callback);
+        }
+        else {
+            var results = {};
+            async.eachSeries(_keys(tasks), function (k, callback) {
+                tasks[k](function (err) {
+                    var args = Array.prototype.slice.call(arguments, 1);
+                    if (args.length <= 1) {
+                        args = args[0];
+                    }
+                    results[k] = args;
+                    callback(err);
+                });
+            }, function (err) {
+                callback(err, results);
+            });
+        }
+    };
+
+    async.iterator = function (tasks) {
+        var makeCallback = function (index) {
+            var fn = function () {
+                if (tasks.length) {
+                    tasks[index].apply(null, arguments);
+                }
+                return fn.next();
+            };
+            fn.next = function () {
+                return (index < tasks.length - 1) ? makeCallback(index + 1): null;
+            };
+            return fn;
+        };
+        return makeCallback(0);
+    };
+
+    async.apply = function (fn) {
+        var args = Array.prototype.slice.call(arguments, 1);
+        return function () {
+            return fn.apply(
+                null, args.concat(Array.prototype.slice.call(arguments))
+            );
+        };
+    };
+
+    var _concat = function (eachfn, arr, fn, callback) {
+        var r = [];
+        eachfn(arr, function (x, cb) {
+            fn(x, function (err, y) {
+                r = r.concat(y || []);
+                cb(err);
+            });
+        }, function (err) {
+            callback(err, r);
+        });
+    };
+    async.concat = doParallel(_concat);
+    async.concatSeries = doSeries(_concat);
+
+    async.whilst = function (test, iterator, callback) {
+        if (test()) {
+            iterator(function (err) {
+                if (err) {
+                    return callback(err);
+                }
+                async.whilst(test, iterator, callback);
+            });
+        }
+        else {
+            callback();
+        }
+    };
+
+    async.doWhilst = function (iterator, test, callback) {
+        iterator(function (err) {
+            if (err) {
+                return callback(err);
+            }
+            if (test()) {
+                async.doWhilst(iterator, test, callback);
+            }
+            else {
+                callback();
+            }
+        });
+    };
+
+    async.until = function (test, iterator, callback) {
+        if (!test()) {
+            iterator(function (err) {
+                if (err) {
+                    return callback(err);
+                }
+                async.until(test, iterator, callback);
+            });
+        }
+        else {
+            callback();
+        }
+    };
+
+    async.doUntil = function (iterator, test, callback) {
+        iterator(function (err) {
+            if (err) {
+                return callback(err);
+            }
+            if (!test()) {
+                async.doUntil(iterator, test, callback);
+            }
+            else {
+                callback();
+            }
+        });
+    };
+
+    async.queue = function (worker, concurrency) {
+        if (concurrency === undefined) {
+            concurrency = 1;
+        }
+        function _insert(q, data, pos, callback) {
+          if(data.constructor !== Array) {
+              data = [data];
+          }
+          _each(data, function(task) {
+              var item = {
+                  data: task,
+                  callback: typeof callback === 'function' ? callback : null
+              };
+
+              if (pos) {
+                q.tasks.unshift(item);
+              } else {
+                q.tasks.push(item);
+              }
+
+              if (q.saturated && q.tasks.length === concurrency) {
+                  q.saturated();
+              }
+              async.setImmediate(q.process);
+          });
+        }
+
+        var workers = 0;
+        var q = {
+            tasks: [],
+            concurrency: concurrency,
+            saturated: null,
+            empty: null,
+            drain: null,
+            push: function (data, callback) {
+              _insert(q, data, false, callback);
+            },
+            unshift: function (data, callback) {
+              _insert(q, data, true, callback);
+            },
+            process: function () {
+                if (workers < q.concurrency && q.tasks.length) {
+                    var task = q.tasks.shift();
+                    if (q.empty && q.tasks.length === 0) {
+                        q.empty();
+                    }
+                    workers += 1;
+                    var next = function () {
+                        workers -= 1;
+                        if (task.callback) {
+                            task.callback.apply(task, arguments);
+                        }
+                        if (q.drain && q.tasks.length + workers === 0) {
+                            q.drain();
+                        }
+                        q.process();
+                    };
+                    var cb = only_once(next);
+                    worker(task.data, cb);
+                }
+            },
+            length: function () {
+                return q.tasks.length;
+            },
+            running: function () {
+                return workers;
+            }
+        };
+        return q;
+    };
+
+    async.cargo = function (worker, payload) {
+        var working     = false,
+            tasks       = [];
+
+        var cargo = {
+            tasks: tasks,
+            payload: payload,
+            saturated: null,
+            empty: null,
+            drain: null,
+            push: function (data, callback) {
+                if(data.constructor !== Array) {
+                    data = [data];
+                }
+                _each(data, function(task) {
+                    tasks.push({
+                        data: task,
+                        callback: typeof callback === 'function' ? callback : null
+                    });
+                    if (cargo.saturated && tasks.length === payload) {
+                        cargo.saturated();
+                    }
+                });
+                async.setImmediate(cargo.process);
+            },
+            process: function process() {
+                if (working) return;
+                if (tasks.length === 0) {
+                    if(cargo.drain) cargo.drain();
+                    return;
+                }
+
+                var ts = typeof payload === 'number'
+                            ? tasks.splice(0, payload)
+                            : tasks.splice(0);
+
+                var ds = _map(ts, function (task) {
+                    return task.data;
+                });
+
+                if(cargo.empty) cargo.empty();
+                working = true;
+                worker(ds, function () {
+                    working = false;
+
+                    var args = arguments;
+                    _each(ts, function (data) {
+                        if (data.callback) {
+                            data.callback.apply(null, args);
+                        }
+                    });
+
+                    process();
+                });
+            },
+            length: function () {
+                return tasks.length;
+            },
+            running: function () {
+                return working;
+            }
+        };
+        return cargo;
+    };
+
+    var _console_fn = function (name) {
+        return function (fn) {
+            var args = Array.prototype.slice.call(arguments, 1);
+            fn.apply(null, args.concat([function (err) {
+                var args = Array.prototype.slice.call(arguments, 1);
+                if (typeof console !== 'undefined') {
+                    if (err) {
+                        if (console.error) {
+                            console.error(err);
+                        }
+                    }
+                    else if (console[name]) {
+                        _each(args, function (x) {
+                            console[name](x);
+                        });
+                    }
+                }
+            }]));
+        };
+    };
+    async.log = _console_fn('log');
+    async.dir = _console_fn('dir');
+    /*async.info = _console_fn('info');
+    async.warn = _console_fn('warn');
+    async.error = _console_fn('error');*/
+
+    async.memoize = function (fn, hasher) {
+        var memo = {};
+        var queues = {};
+        hasher = hasher || function (x) {
+            return x;
+        };
+        var memoized = function () {
+            var args = Array.prototype.slice.call(arguments);
+            var callback = args.pop();
+            var key = hasher.apply(null, args);
+            if (key in memo) {
+                callback.apply(null, memo[key]);
+            }
+            else if (key in queues) {
+                queues[key].push(callback);
+            }
+            else {
+                queues[key] = [callback];
+                fn.apply(null, args.concat([function () {
+                    memo[key] = arguments;
+                    var q = queues[key];
+                    delete queues[key];
+                    for (var i = 0, l = q.length; i < l; i++) {
+                      q[i].apply(null, arguments);
+                    }
+                }]));
+            }
+        };
+        memoized.memo = memo;
+        memoized.unmemoized = fn;
+        return memoized;
+    };
+
+    async.unmemoize = function (fn) {
+      return function () {
+        return (fn.unmemoized || fn).apply(null, arguments);
+      };
+    };
+
+    async.times = function (count, iterator, callback) {
+        var counter = [];
+        for (var i = 0; i < count; i++) {
+            counter.push(i);
+        }
+        return async.map(counter, iterator, callback);
+    };
+
+    async.timesSeries = function (count, iterator, callback) {
+        var counter = [];
+        for (var i = 0; i < count; i++) {
+            counter.push(i);
+        }
+        return async.mapSeries(counter, iterator, callback);
+    };
+
+    async.compose = function (/* functions... */) {
+        var fns = Array.prototype.reverse.call(arguments);
+        return function () {
+            var that = this;
+            var args = Array.prototype.slice.call(arguments);
+            var callback = args.pop();
+            async.reduce(fns, args, function (newargs, fn, cb) {
+                fn.apply(that, newargs.concat([function () {
+                    var err = arguments[0];
+                    var nextargs = Array.prototype.slice.call(arguments, 1);
+                    cb(err, nextargs);
+                }]))
+            },
+            function (err, results) {
+                callback.apply(that, [err].concat(results));
+            });
+        };
+    };
+
+    var _applyEach = function (eachfn, fns /*args...*/) {
+        var go = function () {
+            var that = this;
+            var args = Array.prototype.slice.call(arguments);
+            var callback = args.pop();
+            return eachfn(fns, function (fn, cb) {
+                fn.apply(that, args.concat([cb]));
+            },
+            callback);
+        };
+        if (arguments.length > 2) {
+            var args = Array.prototype.slice.call(arguments, 2);
+            return go.apply(this, args);
+        }
+        else {
+            return go;
+        }
+    };
+    async.applyEach = doParallel(_applyEach);
+    async.applyEachSeries = doSeries(_applyEach);
+
+    async.forever = function (fn, callback) {
+        function next(err) {
+            if (err) {
+                if (callback) {
+                    return callback(err);
+                }
+                throw err;
+            }
+            fn(next);
+        }
+        next();
+    };
+
+    // AMD / RequireJS
+    if (typeof define !== 'undefined' && define.amd) {
+        define([], function () {
+            return async;
+        });
+    }
+    // Node.js
+    else if (typeof module !== 'undefined' && module.exports) {
+        module.exports = async;
+    }
+    // included directly via <script> tag
+    else {
+        root.async = async;
+    }
+
+}());
diff --git a/src/shell.js b/src/shell.js
index 4b31b81..6a386e4 100644
--- a/src/shell.js
+++ b/src/shell.js
@@ -2,7 +2,8 @@
 define(function(require) {
 
   var Path = require('src/path');
-  var Error = require('src/error');
+  var FilerError = require('src/error');
+  var async = require('async');
 
   function Shell(fs, options) {
     options = options || {};
@@ -26,14 +27,14 @@ define(function(require) {
       // Make sure the path actually exists, and is a dir
       fs.stat(path, function(err, stats) {
         if(err) {
-          callback(new Error.ENotDirectory());
+          callback(new FilerError.ENotDirectory());
           return;
         }
         if(stats.type === 'DIRECTORY') {
           cwd = path;
           callback();
         } else {
-          callback(new Error.ENotDirectory());
+          callback(new FilerError.ENotDirectory());
         }
       });
     };
@@ -120,6 +121,44 @@ define(function(require) {
     });
   };
 
+  /**
+   * Concatenate multiple files into a single String, with each
+   * file separated by a newline. The `files` argument should
+   * be a String (path to single file) or an Array of Strings
+   * (multiple file paths).
+   */
+  Shell.prototype.cat = function(files, callback) {
+    if(!files) {
+      callback(new Error("Missing files argument"));
+      return;
+    }
+
+    var fs = this.fs;
+    var all = '';
+    files = typeof files === 'string' ? [ files ] : files;
+    callback = callback || function(){};
+
+    function append(item, callback) {
+      var filename = Path.resolve(this.cwd, item);
+      fs.readFile(filename, 'utf8', function(error, data) {
+        if(error) {
+          callback(error);
+          return;
+        }
+        all += data + '\n';
+        callback();
+      });
+    }
+
+    async.eachSeries(files, append, function(error) {
+      if(error) {
+        callback(error);
+      } else {
+        callback(null, all.replace(/\n$/, ''));
+      }
+    });
+  };
+
   return Shell;
 
 });
diff --git a/tests/spec/shell/cat.spec.js b/tests/spec/shell/cat.spec.js
new file mode 100644
index 0000000..5464e2d
--- /dev/null
+++ b/tests/spec/shell/cat.spec.js
@@ -0,0 +1,82 @@
+define(["Filer", "util"], function(Filer, util) {
+
+  describe('FileSystemShell.cat', function() {
+    beforeEach(util.setup);
+    afterEach(util.cleanup);
+
+    it('should be a function', function() {
+      var shell = util.shell();
+      expect(shell.cat).to.be.a('function');
+    });
+
+    it('should fail when files argument is absent', function(done) {
+      var fs = util.fs();
+      var shell = fs.Shell();
+
+      shell.cat(null, function(error, data) {
+        expect(error).to.exist;
+        expect(data).not.to.exist;
+        done();
+      });
+    });
+
+    it('should return the contents of a single file', function(done) {
+      var fs = util.fs();
+      var shell = fs.Shell();
+      var contents = "file contents";
+
+      fs.writeFile('/file', contents, function(err) {
+        if(err) throw err;
+
+        shell.cat('/file', function(err, data) {
+          expect(err).not.to.exist;
+          expect(data).to.equal(contents);
+          done();
+        });
+      });
+    });
+
+    it('should return the contents of multiple files', function(done) {
+      var fs = util.fs();
+      var shell = fs.Shell();
+      var contents = "file contents";
+      var contents2 = contents + '\n' + contents;
+
+      fs.writeFile('/file', contents, function(err) {
+        if(err) throw err;
+
+        fs.writeFile('/file2', contents2, function(err) {
+          if(err) throw err;
+
+          shell.cat(['/file', '/file2'], function(err, data) {
+            expect(err).not.to.exist;
+            expect(data).to.equal(contents + '\n' + contents2);
+            done();
+          });
+        });
+      });
+    });
+
+    it('should fail if any of multiple file paths is invalid', function(done) {
+      var fs = util.fs();
+      var shell = fs.Shell();
+      var contents = "file contents";
+      var contents2 = contents + '\n' + contents;
+
+      fs.writeFile('/file', contents, function(err) {
+        if(err) throw err;
+
+        fs.writeFile('/file2', contents2, function(err) {
+          if(err) throw err;
+
+          shell.cat(['/file', '/nofile'], function(err, data) {
+            expect(err).to.exist;
+            expect(data).not.to.exist;
+            done();
+          });
+        });
+      });
+    });
+
+  });
+});
diff --git a/tests/test-manifest.js b/tests/test-manifest.js
index 2fa4f63..32758c0 100644
--- a/tests/test-manifest.js
+++ b/tests/test-manifest.js
@@ -46,6 +46,7 @@ define([
   "spec/shell/cd.spec",
   "spec/shell/touch.spec",
   "spec/shell/exec.spec",
+  "spec/shell/cat.spec",
 
   // Ported node.js tests (filenames match names in https://github.com/joyent/node/tree/master/test)
   "spec/node-js/simple/test-fs-mkdir",

From e4767019cce0670596d2020a168f8ee5ea391bcf Mon Sep 17 00:00:00 2001
From: "David Humphrey (:humph) david.humphrey@senecacollege.ca"
 <david.humphrey@senecacollege.ca>
Date: Tue, 18 Feb 2014 16:48:53 -0500
Subject: [PATCH 08/17] Add shell.ls() with tests

---
 src/shell.js                |  82 ++++++++++++++++
 tests/spec/shell/ls.spec.js | 186 ++++++++++++++++++++++++++++++++++++
 tests/test-manifest.js      |   1 +
 3 files changed, 269 insertions(+)
 create mode 100644 tests/spec/shell/ls.spec.js

diff --git a/src/shell.js b/src/shell.js
index 6a386e4..1497ea7 100644
--- a/src/shell.js
+++ b/src/shell.js
@@ -159,6 +159,88 @@ define(function(require) {
     });
   };
 
+  /**
+   * Get the listing of a directory, returning an array of
+   * file entries in the following form:
+   *
+   * {
+   *   path: <String> the basename of the directory entry
+   *   links: <Number> the number of links to the entry
+   *   size: <Number> the size in bytes of the entry
+   *   modified: <Number> the last modified date/time
+   *   type: <String> the type of the entry
+   *   contents: <Array> an optional array of child entries
+   * }
+   *
+   * By default ls() gives a shallow listing. If you want
+   * to follow directories as they are encountered, use
+   * the `recursive=true` option.
+   */
+  Shell.prototype.ls = function(dir, options, callback) {
+    if(!dir) {
+      callback(new Error("Missing dir argument"));
+      return;
+    }
+
+    var fs = this.fs;
+    if(typeof options === 'function') {
+      callback = options;
+      options = {};
+    }
+    options = options || {};
+    callback = callback || function(){};
+
+    function list(path, callback) {
+      var pathname = Path.resolve(this.cwd, path);
+      var result = [];
+
+      fs.readdir(pathname, function(error, entries) {
+        if(error) {
+          callback(error);
+          return;
+        }
+
+        function getDirEntry(name, callback) {
+          name = Path.join(pathname, name);
+          fs.stat(name, function(error, stats) {
+            if(error) {
+              callback(error);
+              return;
+            }
+            var entry = {
+              path: Path.basename(name),
+              links: stats.nlinks,
+              size: stats.size,
+              modified: stats.mtime,
+              type: stats.type
+            };
+
+            if(options.recursive && stats.type === 'DIRECTORY') {
+              list(Path.join(pathname, entry.path), function(error, items) {
+                if(error) {
+                  callback(error);
+                  return;
+                }
+                entry.contents = items;
+                result.push(entry);
+                callback();
+              });
+            } else {
+              result.push(entry);
+              callback();
+            }
+          });
+        }
+
+        async.each(entries, getDirEntry, function(error) {
+          callback(error, result);
+        });
+      });
+    }
+
+    list(dir, callback);
+  };
+
   return Shell;
 
 });
diff --git a/tests/spec/shell/ls.spec.js b/tests/spec/shell/ls.spec.js
new file mode 100644
index 0000000..9c51c30
--- /dev/null
+++ b/tests/spec/shell/ls.spec.js
@@ -0,0 +1,186 @@
+define(["Filer", "util"], function(Filer, util) {
+
+  describe('FileSystemShell.ls', function() {
+    beforeEach(util.setup);
+    afterEach(util.cleanup);
+
+    it('should be a function', function() {
+      var shell = util.shell();
+      expect(shell.ls).to.be.a('function');
+    });
+
+    it('should fail when dirs argument is absent', function(done) {
+      var fs = util.fs();
+      var shell = fs.Shell();
+
+      shell.cat(null, function(error, list) {
+        expect(error).to.exist;
+        expect(list).not.to.exist;
+        done();
+      });
+    });
+
+    it('should return the contents of a simple dir', function(done) {
+      var fs = util.fs();
+      var shell = fs.Shell();
+      var contents = "a";
+      var contents2 = "bb";
+
+      fs.writeFile('/file', contents, function(err) {
+        if(err) throw err;
+
+        fs.writeFile('/file2', contents2, function(err) {
+          if(err) throw err;
+
+          shell.ls('/', function(err, list) {
+            expect(err).not.to.exist;
+            expect(list.length).to.equal(2);
+
+            var item0 = list[0];
+            expect(item0.path).to.equal('file');
+            expect(item0.links).to.equal(1);
+            expect(item0.size).to.equal(1);
+            expect(item0.modified).to.be.a('number');
+            expect(item0.type).to.equal('FILE');
+            expect(item0.contents).not.to.exist;
+
+            var item1 = list[1];
+            expect(item1.path).to.equal('file2');
+            expect(item1.links).to.equal(1);
+            expect(item1.size).to.equal(2);
+            expect(item1.modified).to.be.a('number');
+            expect(item1.type).to.equal('FILE');
+            expect(item0.contents).not.to.exist;
+
+            done();
+          });
+        });
+      });
+    });
+
+    it('should return the shallow contents of a dir tree', function(done) {
+      var fs = util.fs();
+      var shell = fs.Shell();
+      var contents = "a";
+
+      fs.mkdir('/dir', function(err) {
+        if(err) throw err;
+
+        fs.mkdir('/dir/dir2', function(err) {
+          if(err) throw err;
+
+          fs.writeFile('/dir/file', contents, function(err) {
+            if(err) throw err;
+
+            fs.writeFile('/dir/file2', contents, function(err) {
+              if(err) throw err;
+
+              shell.ls('/dir', function(err, list) {
+                expect(err).not.to.exist;
+                expect(list.length).to.equal(3);
+
+                // We shouldn't rely on the order we'll get the listing
+                list.forEach(function(item, i, arr) {
+                  switch(item.path) {
+                  case 'dir2':
+                    expect(item.links).to.equal(1);
+                    expect(item.size).to.be.a('number');
+                    expect(item.modified).to.be.a('number');
+                    expect(item.type).to.equal('DIRECTORY');
+                    expect(item.contents).not.to.exist;
+                    break;
+                  case 'file':
+                  case 'file2':
+                    expect(item.links).to.equal(1);
+                    expect(item.size).to.equal(1);
+                    expect(item.modified).to.be.a('number');
+                    expect(item.type).to.equal('FILE');
+                    expect(item.contents).not.to.exist;
+                    break;
+                  default:
+                    // shouldn't happen
+                    expect(true).to.be.false;
+                    break;
+                  }
+
+                  if(i === arr.length -1) {
+                    done();
+                  }
+                });
+              });
+            });
+          });
+        });
+      });
+    });
+
+    it('should return the deep contents of a dir tree', function(done) {
+      var fs = util.fs();
+      var shell = fs.Shell();
+      var contents = "a";
+
+      fs.mkdir('/dir', function(err) {
+        if(err) throw err;
+
+        fs.mkdir('/dir/dir2', function(err) {
+          if(err) throw err;
+
+          fs.writeFile('/dir/dir2/file', contents, function(err) {
+            if(err) throw err;
+
+            fs.writeFile('/dir/file', contents, function(err) {
+              if(err) throw err;
+
+              fs.writeFile('/dir/file2', contents, function(err) {
+                if(err) throw err;
+
+                shell.ls('/dir', { recursive: true }, function(err, list) {
+                  expect(err).not.to.exist;
+                  expect(list.length).to.equal(3);
+
+                  // We shouldn't rely on the order we'll get the listing
+                  list.forEach(function(item, i, arr) {
+                    switch(item.path) {
+                    case 'dir2':
+                      expect(item.links).to.equal(1);
+                      expect(item.size).to.be.a('number');
+                      expect(item.modified).to.be.a('number');
+                      expect(item.type).to.equal('DIRECTORY');
+                      expect(item.contents).to.exist;
+                      expect(item.contents.length).to.equal(1);
+                      var contents0 = item.contents[0];
+                      expect(contents0.path).to.equal('file');
+                      expect(contents0.links).to.equal(1);
+                      expect(contents0.size).to.equal(1);
+                      expect(contents0.modified).to.be.a('number');
+                      expect(contents0.type).to.equal('FILE');
+                      expect(contents0.contents).not.to.exist;
+                      break;
+                    case 'file':
+                    case 'file2':
+                      expect(item.links).to.equal(1);
+                      expect(item.size).to.equal(1);
+                      expect(item.modified).to.be.a('number');
+                      expect(item.type).to.equal('FILE');
+                      expect(item.contents).not.to.exist;
+                      break;
+                    default:
+                      // shouldn't happen
+                      expect(true).to.be.false;
+                      break;
+                    }
+
+                    if(i === arr.length -1) {
+                      done();
+                    }
+                 });
+                });
+              });
+            });
+          });
+        });
+      });
+    });
+
+  });
+});
diff --git a/tests/test-manifest.js b/tests/test-manifest.js
index 32758c0..d0efa70 100644
--- a/tests/test-manifest.js
+++ b/tests/test-manifest.js
@@ -47,6 +47,7 @@ define([
   "spec/shell/touch.spec",
   "spec/shell/exec.spec",
   "spec/shell/cat.spec",
+  "spec/shell/ls.spec",
 
   // Ported node.js tests (filenames match names in https://github.com/joyent/node/tree/master/test)
   "spec/node-js/simple/test-fs-mkdir",

From 83c55308dcf9c47181c37a837281bd39a0940788 Mon Sep 17 00:00:00 2001
From: "David Humphrey (:humph) david.humphrey@senecacollege.ca"
 <david.humphrey@senecacollege.ca>
Date: Wed, 19 Feb 2014 11:25:30 -0500
Subject: [PATCH 09/17] Add shell.rm() with tests

---
 src/shell.js                |  83 +++++++++++++++++++---
 tests/spec/shell/rm.spec.js | 137 ++++++++++++++++++++++++++++++++++++
 tests/test-manifest.js      |   1 +
 3 files changed, 213 insertions(+), 8 deletions(-)
 create mode 100644 tests/spec/shell/rm.spec.js

diff --git a/src/shell.js b/src/shell.js
index 1497ea7..d70058e 100644
--- a/src/shell.js
+++ b/src/shell.js
@@ -128,15 +128,16 @@ define(function(require) {
    * (multiple file paths).
    */
   Shell.prototype.cat = function(files, callback) {
+    var fs = this.fs;
+    var all = '';
+    callback = callback || function(){};
+
     if(!files) {
       callback(new Error("Missing files argument"));
       return;
     }
 
-    var fs = this.fs;
-    var all = '';
     files = typeof files === 'string' ? [ files ] : files;
-    callback = callback || function(){};
 
     function append(item, callback) {
       var filename = Path.resolve(this.cwd, item);
@@ -177,11 +178,6 @@ define(function(require) {
    * the `recursive=true` option.
    */
   Shell.prototype.ls = function(dir, options, callback) {
-    if(!dir) {
-      callback(new Error("Missing dir argument"));
-      return;
-    }
-
     var fs = this.fs;
     if(typeof options === 'function') {
       callback = options;
@@ -190,6 +186,11 @@ define(function(require) {
     options = options || {};
     callback = callback || function(){};
 
+    if(!dir) {
+      callback(new Error("Missing dir argument"));
+      return;
+    }
+
     function list(path, callback) {
       var pathname = Path.resolve(this.cwd, path);
       var result = [];
@@ -241,6 +242,72 @@ define(function(require) {
     list(dir, callback);
   };
 
+  Shell.prototype.rm = function(path, options, callback) {
+    var fs = this.fs;
+    if(typeof options === 'function') {
+      callback = options;
+      options = {};
+    }
+    options = options || {};
+    callback = callback || function(){};
+
+    if(!path) {
+      callback(new Error("Missing path argument"));
+      return;
+    }
+
+    function remove(pathname, callback) {
+      pathname = Path.resolve(this.cwd, pathname);
+      fs.stat(pathname, function(error, stats) {
+        if(error) {
+          callback(error);
+          return;
+        }
+
+        // If this is a file, delete it and we're done
+        if(stats.type === 'FILE') {
+          fs.unlink(pathname, callback);
+          return;
+        }
+
+        // If it's a dir, check if it's empty
+        fs.readdir(pathname, function(error, entries) {
+          if(error) {
+            callback(error);
+            return;
+          }
+
+          // If dir is empty, delete it and we're done
+          if(entries.length === 0) {
+            fs.rmdir(pathname, callback);
+            return;
+          }
+
+          // If not, see if we're allowed to delete recursively
+          if(!options.recursive) {
+            callback(new FilerError.ENotEmpty());
+            return;
+          }
+
+          // Remove each dir entry recursively, then delete the dir.
+          entries = entries.map(function(filename) {
+            // Root dir entries absolutely
+            return Path.join(pathname, filename);
+          });
+          async.each(entries, remove, function(error) {
+            if(error) {
+              callback(error);
+              return;
+            }
+            fs.rmdir(pathname, callback);
+          });
+        });
+      });
+    }
+
+    remove(path, callback);
+  };
+
   return Shell;
 
 });
diff --git a/tests/spec/shell/rm.spec.js b/tests/spec/shell/rm.spec.js
new file mode 100644
index 0000000..628e03f
--- /dev/null
+++ b/tests/spec/shell/rm.spec.js
@@ -0,0 +1,137 @@
+define(["Filer", "util"], function(Filer, util) {
+
+  describe('FileSystemShell.rm', function() {
+    beforeEach(util.setup);
+    afterEach(util.cleanup);
+
+    it('should be a function', function() {
+      var shell = util.shell();
+      expect(shell.rm).to.be.a('function');
+    });
+
+    it('should fail when path argument is absent', function(done) {
+      var fs = util.fs();
+      var shell = fs.Shell();
+
+      shell.rm(null, function(error, list) {
+        expect(error).to.exist;
+        expect(list).not.to.exist;
+        done();
+      });
+    });
+
+    it('should remove a single file', function(done) {
+      var fs = util.fs();
+      var shell = fs.Shell();
+      var contents = "a";
+
+      fs.writeFile('/file', contents, function(err) {
+        if(err) throw err;
+
+        shell.rm('/file', function(err) {
+          expect(err).not.to.exist;
+
+          fs.stat('/file', function(err, stats) {
+            expect(err).to.exist;
+            expect(stats).not.to.exist;
+            done();
+          });
+        });
+      });
+    });
+
+    it('should remove an empty dir', function(done) {
+      var fs = util.fs();
+      var shell = fs.Shell();
+
+      fs.mkdir('/dir', function(err) {
+        if(err) throw err;
+
+        shell.rm('/dir', function(err) {
+          expect(err).not.to.exist;
+
+          fs.stat('/dir', function(err, stats) {
+            expect(err).to.exist;
+            expect(stats).not.to.exist;
+            done();
+          });
+        });
+      });
+    });
+
+    it('should fail to remove a non-empty dir', function(done) {
+      var fs = util.fs();
+      var shell = fs.Shell();
+
+      fs.mkdir('/dir', function(err) {
+        if(err) throw err;
+
+        shell.touch('/dir/file', function(err) {
+          if(err) throw err;
+
+          shell.rm('/dir', function(err) {
+            expect(err).to.exist;
+            expect(err.name).to.equal('ENotEmpty');
+            done();
+          });
+        });
+      });
+    });
+
+    it('should remove a non-empty dir with option.recursive set', function(done) {
+      var fs = util.fs();
+      var shell = fs.Shell();
+
+      fs.mkdir('/dir', function(err) {
+        if(err) throw err;
+
+        shell.touch('/dir/file', function(err) {
+          if(err) throw err;
+
+          shell.rm('/dir', { recursive: true }, function(err) {
+            expect(err).not.to.exist;
+
+            fs.stat('/dir', function(err, stats) {
+              expect(err).to.exist;
+              expect(stats).not.to.exist;
+              done();
+            });
+          });
+        });
+      });
+    });
+
+    it('should work on a complex dir structure', function(done) {
+      var fs = util.fs();
+      var shell = fs.Shell();
+      var contents = "a";
+
+      fs.mkdir('/dir', function(err) {
+        if(err) throw err;
+
+        fs.mkdir('/dir/dir2', function(err) {
+          if(err) throw err;
+
+          fs.writeFile('/dir/file', contents, function(err) {
+            if(err) throw err;
+
+            fs.writeFile('/dir/file2', contents, function(err) {
+              if(err) throw err;
+
+              shell.rm('/dir', { recursive: true }, function(err) {
+                expect(err).not.to.exist;
+
+                fs.stat('/dir', function(err, stats) {
+                  expect(err).to.exist;
+                  expect(stats).not.to.exist;
+                  done();
+                });
+              });
+            });
+          });
+        });
+      });
+    });
+
+  });
+});
diff --git a/tests/test-manifest.js b/tests/test-manifest.js
index d0efa70..55cd181 100644
--- a/tests/test-manifest.js
+++ b/tests/test-manifest.js
@@ -48,6 +48,7 @@ define([
   "spec/shell/exec.spec",
   "spec/shell/cat.spec",
   "spec/shell/ls.spec",
+  "spec/shell/rm.spec",
 
   // Ported node.js tests (filenames match names in https://github.com/joyent/node/tree/master/test)
   "spec/node-js/simple/test-fs-mkdir",

From 21f5d15f518cba2a785028004452cc6ed6d0a7dd Mon Sep 17 00:00:00 2001
From: "David Humphrey (:humph) david.humphrey@senecacollege.ca"
 <david.humphrey@senecacollege.ca>
Date: Wed, 19 Feb 2014 12:15:02 -0500
Subject: [PATCH 10/17] Add support for shell.env, PWD, TMP, and tempDir, with
 tests

---
 src/shell.js                 |  51 ++++++++++++++++
 tests/lib/test-utils.js      |   4 +-
 tests/spec/shell/env.spec.js | 113 +++++++++++++++++++++++++++++++++++
 tests/test-manifest.js       |   1 +
 4 files changed, 167 insertions(+), 2 deletions(-)
 create mode 100644 tests/spec/shell/env.spec.js

diff --git a/src/shell.js b/src/shell.js
index d70058e..b29a2f9 100644
--- a/src/shell.js
+++ b/src/shell.js
@@ -8,18 +8,45 @@ define(function(require) {
   function Shell(fs, options) {
     options = options || {};
 
+    var env = options.env || {};
+    env.TMP = env.TMP || '/tmp';
+    env.PATH = env.PATH || '';
+
     var cwd = '/';
 
+    /**
+     * The bound FileSystem (cannot be changed)
+     */
     Object.defineProperty(this, 'fs', {
       get: function() { return fs; },
       enumerable: true
     });
 
+    /**
+     * The current working directory (changed with `cd()`)
+     */
     Object.defineProperty(this, 'cwd', {
       get: function() { return cwd; },
       enumerable: true
     });
 
+    /**
+     * Support bash's $PWD on the env
+     */
+    Object.defineProperty(env, 'PWD', {
+      get: function() { return cwd; },
+      enumerable: true
+    });
+
+    /**
+     * The shell's environment (e.g., for things like
+     * path, tmp, and other env vars)
+     */
+    Object.defineProperty(this, 'env', {
+      get: function() { return env; },
+      enumerable: true
+    });
+
     // We include `cd` on the this vs. proto so that
     // we can access cwd without exposing it externally.
     this.cd = function(path, callback) {
@@ -242,6 +269,13 @@ define(function(require) {
     list(dir, callback);
   };
 
+  /**
+   * Removes the file or directory at `path`. If `path` is a file
+   * it will be removed. If `path` is a directory, it will be
+   * removed if it is empty, otherwise the callback will receive
+   * an error. In order to remove non-empty directories, use the
+   * `recursive=true` option.
+   */
   Shell.prototype.rm = function(path, options, callback) {
     var fs = this.fs;
     if(typeof options === 'function') {
@@ -308,6 +342,23 @@ define(function(require) {
     remove(path, callback);
   };
 
+  /**
+   * Gets the path to the temporary directory, creating it if not
+   * present. The directory used is the one specified in
+   * env.TMP. The callback receives (error, tempDirName).
+   */
+  Shell.prototype.tempDir = function(callback) {
+    var fs = this.fs;
+    var tmp = this.env.TMP;
+    callback = callback || function(){};
+
+    // Try and create it, and it will either work or fail
+    // but either way it's now there.
+    fs.mkdir(tmp, function(err) {
+      callback(null, tmp);
+    });
+  };
+
   return Shell;
 
 });
diff --git a/tests/lib/test-utils.js b/tests/lib/test-utils.js
index bca7658..94e1940 100644
--- a/tests/lib/test-utils.js
+++ b/tests/lib/test-utils.js
@@ -68,8 +68,8 @@ function(Filer, IndexedDBTestProvider, WebSQLTestProvider, MemoryTestProvider) {
     return _provider;
   }
 
-  function shell() {
-    return fs().Shell();
+  function shell(options) {
+    return fs().Shell(options);
   }
 
   function cleanup(callback) {
diff --git a/tests/spec/shell/env.spec.js b/tests/spec/shell/env.spec.js
new file mode 100644
index 0000000..af0c321
--- /dev/null
+++ b/tests/spec/shell/env.spec.js
@@ -0,0 +1,113 @@
+define(["Filer", "util"], function(Filer, util) {
+
+  describe('FileSystemShell.env', function() {
+    beforeEach(util.setup);
+    afterEach(util.cleanup);
+
+    it('should get default env options', function() {
+      var shell = util.shell();
+      expect(shell.env).to.exist;
+      expect(shell.env.TMP).to.equal('/tmp');
+      expect(shell.env.PATH).to.equal('');
+      expect(shell.env.PWD).to.equal('/');
+    });
+
+    it('should be able to specify env options', function() {
+      var options = {
+        env: {
+          TMP: '/tempdir',
+          PATH: '/dir'
+        }
+      };
+      var shell = util.shell(options);
+      expect(shell.env).to.exist;
+      expect(shell.env.TMP).to.equal('/tempdir');
+      expect(shell.env.PATH).to.equal('/dir');
+      expect(shell.env.PWD).to.equal('/');
+    });
+
+    it('should fail when dirs argument is absent', function(done) {
+      var fs = util.fs();
+      var shell = fs.Shell();
+
+      shell.cat(null, function(error, list) {
+        expect(error).to.exist;
+        expect(list).not.to.exist;
+        done();
+      });
+    });
+
+    it('should update the value of env.PWD when cwd changes', function(done) {
+      var fs = util.fs();
+      var shell = fs.Shell();
+
+      fs.mkdir('/dir', function(err) {
+        if(err) throw err;
+
+        expect(shell.cwd).to.equal('/');
+        expect(shell.env.PWD).to.equal('/');
+
+        shell.cd('/dir', function(err) {
+          expect(err).not.to.exist;
+          expect(shell.cwd).to.equal('/dir');
+          expect(shell.env.PWD).to.equal('/dir');
+          done();
+        });
+      });
+    });
+
+    it('should create/return the default tmp dir', function(done) {
+      var fs = util.fs();
+      var shell = fs.Shell();
+
+      expect(shell.env.TMP).to.equal('/tmp');
+      shell.tempDir(function(err, tmp) {
+        expect(err).not.to.exist;
+        shell.cd(tmp, function(err) {
+          expect(err).not.to.exist;
+          expect(shell.cwd).to.equal('/tmp');
+          expect(shell.env.PWD).to.equal('/tmp');
+          done();
+        });
+      });
+    });
+
+    it('should create/return the tmp dir specified in env.TMP', function(done) {
+      var fs = util.fs();
+      var shell = fs.Shell({
+        env: {
+          TMP: '/tempdir'
+        }
+      });
+
+      expect(shell.env.TMP).to.equal('/tempdir');
+      shell.tempDir(function(err, tmp) {
+        expect(err).not.to.exist;
+        shell.cd(tmp, function(err) {
+          expect(err).not.to.exist;
+          expect(shell.cwd).to.equal('/tempdir');
+          expect(shell.env.PWD).to.equal('/tempdir');
+          done();
+        });
+      });
+    });
+
+    it('should allow repeated calls to tempDir()', function(done) {
+      var fs = util.fs();
+      var shell = fs.Shell();
+
+      expect(shell.env.TMP).to.equal('/tmp');
+      shell.tempDir(function(err, tmp) {
+        expect(err).not.to.exist;
+        expect(tmp).to.equal('/tmp');
+
+        shell.tempDir(function(err, tmp) {
+          expect(err).not.to.exist;
+          expect(tmp).to.equal('/tmp');
+          done();
+        });
+      });
+    });
+
+  });
+});
diff --git a/tests/test-manifest.js b/tests/test-manifest.js
index 55cd181..3b903a6 100644
--- a/tests/test-manifest.js
+++ b/tests/test-manifest.js
@@ -49,6 +49,7 @@ define([
   "spec/shell/cat.spec",
   "spec/shell/ls.spec",
   "spec/shell/rm.spec",
+  "spec/shell/env.spec",
 
   // Ported node.js tests (filenames match names in https://github.com/joyent/node/tree/master/test)
   "spec/node-js/simple/test-fs-mkdir",

From dd87117ff8e68911082b2b44d632642f03d33992 Mon Sep 17 00:00:00 2001
From: "David Humphrey (:humph) david.humphrey@senecacollege.ca"
 <david.humphrey@senecacollege.ca>
Date: Wed, 19 Feb 2014 15:22:12 -0500
Subject: [PATCH 11/17] Update docs for shell changes

---
 README.md    | 274 ++++++++++++++++++++++++++++++++++++++++++++++++++-
 src/shell.js |   1 +
 2 files changed, 272 insertions(+), 3 deletions(-)

diff --git a/README.md b/README.md
index fd8c9f2..ef365da 100644
--- a/README.md
+++ b/README.md
@@ -36,7 +36,7 @@ Errors are passed to callbacks through the first parameter.  As with node.js,
 there is no guarantee that file system operations will be executed in the order
 they are invoked. Ensure proper ordering by chaining operations in callbacks.
 
-### Example
+### Overview
 
 To create a new file system or open an existing one, create a new `FileSystem`
 instance.  By default, a new [IndexedDB](https://developer.mozilla.org/en/docs/IndexedDB)
@@ -58,6 +58,15 @@ fs.open('/myfile', 'w+', function(err, fd) {
 });
 ```
 
+For a complete list of `FileSystem` methods and examples, see the [FileSystem Instance Methods](#FileSystemMethods)
+section below.
+
+Filer also supports node's Path module. See the [Filer.Path](#FilerPath) section below.
+
+In addition, common shell operations (e.g., rm, touch, cat, etc.) are supported via the
+`FileSystemShell` object, which can be used with a `FileSystem`.  See the[Filer.FileSystemShell](#FileSystemShell)
+section below.
+
 ### API Reference
 
 Like node.js, callbacks for methods that accept them are optional but suggested (i.e., if
@@ -162,7 +171,7 @@ var fs = new FileSystem({ provider: compressionAdapter });
 You can also write your own adapter if you need to add new capabilities to the providers. Adapters share the same
 interface as providers.  See the code in `src/providers` and `src/adapters` for many examples.
 
-####Filer.Path
+####Filer.Path<a name="FilerPath"></a>
 
 The node.js [path module](http://nodejs.org/api/path.html) is available via the `Filer.Path` object. It is
 identical to the node.js version with the following differences:
@@ -195,7 +204,7 @@ For more info see the docs in the [path module](http://nodejs.org/api/path.html)
 * `path.sep`
 * `path.delimiter`
 
-###FileSystem Instance Methods
+###FileSystem Instance Methods<a name="FileSystemMethods"></a>
 
 Once a `FileSystem` is created, it has the following methods. NOTE: code examples below assume
 a `FileSystem` instance named `fs` has been created like so:
@@ -911,3 +920,262 @@ fs.open('/myfile', 'r', function(err, fd) {
   fs.close(fd);
 });
 ```
+
+### Filer.FileSystemShell<a name="FileSystemShell"></a>
+
+Many common file system shell operations are available by using a `FileSystemShell` object.
+The `FileSystemShell` is used in conjuction with a `FileSystem`, and provides augmented
+features. Many separate `FileSystemShell` objects can exist per `FileSystem`, but each
+`FileSystemShell` is bound to a single instance of a `FileSystem` for its lifetime.
+
+There are two ways to create a `FileSystemShell` object:
+
+```javascript
+// Method 1: obtain a shell from an existing fs
+var fs = new Filer.FileSystem();
+var sh = fs.Shell(options);
+
+// Method 2: create a shell, passing in an existing fs
+var fs = new Filer.FileSystem();
+var sh = new Filer.FileSystemShell(fs, options);
+```
+
+The `FileSystemShell` can take an optional `options` object. The `options` object
+can include `env`, which is a set of environment variables. Currently support variables
+include `TMP` (the path to the temporary directory), and `PATH` (the list of known paths):
+
+```javascript
+var fs = new Filer.FileSystem();
+var sh = fs.Shell({
+  env: {
+    TMP: '/tempdir',
+    PATH: '/one:/two'
+  }
+});
+```
+
+NOTE: unless otherwise stated, all `FileSystemShell` methods can take relative or absolute
+paths. Relative paths are resolved relative to the shell's current working directory (`sh.cwd`).
+This is different from the `FileSystem`, which requires absolute paths, and has no notion
+of a current working directory.
+
+#### FileSystemShell Properties
+
+A `FileSystemShell` has a number of properties, including:
+* `fs` - (readonly) a reference to the bound `FileSystem`
+* `cwd` - (readonly) the current working directory (changed with `cd()`)
+* `env` - (readonly) the shell's environment. At runtime it will have an
+added `PWD` property, which is the same as `cwd`.
+
+Example:
+
+```javascript
+var fs = new Filer.FileSystem();
+var sh = fs.Shell();
+// Store the current location
+var before = sh.env.PWD;
+var after;
+sh.cd('/newdir', function(err) {
+  if(err) throw err;
+  // Get the new location
+  after = sh.env.PWD;
+});
+```
+
+#### FileSystemShell Instance Methods
+
+Once a `FileSystemShell` object is created, it has the following methods. NOTE: code
+examples below assume a `FileSystemShell` instance named `sh` has been created like so:
+
+```javascript
+var fs = new Filer.FileSystem();
+var sh = fs.Shell();
+```
+
+* [sh.cd(path, callback)](#cd)
+* [sh.ls(dir, [options], callback)](#ls)
+* [sh.exec(path, [options], callback)][#exec)
+* [sh.touch(path, [options], callback)[#touch)
+* [sh.cat(files, callback)](#cat)
+* [sh.rm(path, [options], callback)](#rm)
+* [sh.tempDir(callback)](#tempDir)
+
+#### sh.cd(path, callback)<a name="cd"></a>
+
+Changes the current working directory to directory at `path`. The callback returns
+an error if `path` does not exist, or is not a directory. Once the callback occurs
+the shell's `cwd` property is updated to the new path (as well as `sh.env.PWD`).
+
+Example:
+
+```javascript
+sh.cd('/dir1', function(err) {
+  if(err) throw err;
+  // sh.cwd is now '/dir1'
+});
+
+#### sh.ls(dir, [options], callback)<a name="ls"></a>
+
+Get the listing of a directory, returning an array of directory entries
+in the following form:
+```
+{
+  path: <String> the basename of the directory entry
+  links: <Number> the number of links to the entry
+  size: <Number> the size in bytes of the entry
+  modified: <Number> the last modified date/time
+  type: <String> the type of the entry
+  contents: <Array> an optional array of child entries, if this entry is itself a directory
+}
+```
+
+By default `sh.ls()` gives a shallow listing. If you want to follow
+directories as they are encountered, use the `recursive=true` option. NOTE:
+you should not count on the order of the returned entries always being the same.
+
+Example:
+
+```javascript
+/**
+ * Given a dir structure of:
+ *
+ * /dir
+ *  file1
+ *  file2
+ *  dir2/
+ *   file3
+ */
+
+// Shallow listing
+sh.ls('/dir', function(err, entries) {
+  if(err) throw err;
+  // entries is now an array of 3 file/dir entries under /dir
+});
+
+// Deep listing
+sh.ls('/dir', { recursive: true }, function(err, entries) {
+  if(err) throw err;
+  // entries is now an array of 3 file/dir entries under /dir.
+  // The entry object for '/dir2' also includes a `contents` property,
+  // which is an array of 1 entry element for `file3`.
+});
+```
+
+#### sh.exec(path, [options], callback)<a name="exec"></a>
+
+Attempts to Execute the .js command located at `path`. Such commands
+should be written so as to assume the existence of 3 global variables,
+which will be defined at runtime:
+* `options` - <Object> an object containing any arguments, data, etc.
+* `fs` - <FileSystem> the `FileSystem` object bound to this shell.
+* `callback` - <Function> a callback function(error, result) to call when done.
+
+The .js command's contents should be the body of a function that
+looks like this:
+
+```javascript
+function(fs, options, callback) {
+//-------------------------commmand code here---------
+// ...
+//----------------------------------------------------
+ }
+```
+
+Example:
+
+```javascript
+// Simple command to delete a file.
+var cmd = "fs.unlink(options.path, callback);"
+
+// Write the file to the filesystem
+fs.writeFile('/cmd.js', cmd, callback(err) {
+  if(err) throw err;
+
+  // Execute the command
+  sh.exec('/cmd.js', { path: '/file' }, function(err, result) {
+    if(err) throw err;
+  });
+});
+
+#### sh.touch(path, [options], callback)<a name="touch"></a>
+
+Create a file if it does not exist, or update the access and modified
+times if it does. Valid options include:
+* updateOnly - <Boolean> whether to create the file if it is missing (defaults to `false`)
+* date - <Date> a date to use instead of the current date and time when updating
+access and modified dates.
+
+Example:
+
+```javascript
+sh.touch('/newfile', function(err) {
+  if(err) throw err;
+
+  fs.exists('/newfile', function(exists) {
+    // exists is now true.
+  }
+});
+```
+
+#### sh.cat(files, callback)<a name="cat"></a>
+
+Concatenates multiple files into a single string, with each file
+separated by a newline character. The `files` argument should be
+a String (i.e., path to a single file) or an Array of Strings (i.e.,
+multiple paths for multiple files).
+
+Example:
+
+```javascript
+sh.cat([ './file1', '../file2' ], function(err, data) {
+  if(err) throw err;
+  // data is now the contents of file1 and file2 joined
+});
+```
+
+#### sh.rm(path, [options], callback)<a name="rm"></a>
+
+Removes (deletes) the file or directory at `path`. If `path` is a file, it will
+be removed. If `path` is a directory, it will be removed if it is empty, otherwise
+the callback will receive an error. In order to remove non-empty directories,
+use the `recursive=true` option.
+
+Example:
+
+```javascript
+sh.rm('./file', function(err) {
+  if(err) throw err;
+  // ./file is now removed
+});
+
+sh.rm('/dir', { recursive: true }, function(err) {
+  if(err) throw err;
+  // /dir and all its children are now removed
+});
+```
+
+#### sh.tempDir(callback)<a name="tempDir"></a>
+
+Gets the path to the shell's temporary directory, creating it if it
+does not already exist. The temp directory to use is specified in the
+`env.TMP` environment variable. The callback receives an error
+and the `tempDir` path. NOTE: it is safe to call this many times (i.e.,
+the temp dir will only be created once). No effort is made to clean-up
+the temp dir, and it is up to the caller to destroy it if desired.
+
+Example:
+
+```javascript
+// Default /tmp dir
+sh.tempDir(function(err, tmp) {
+  if(err) throw err;
+  // tmp is now '/tmp' by default, and /tmp exists
+});
+
+// Specify a tmp dir path
+sh.env.TMP = '/temporary'
+sh.tempDir(function(err, tmp) {
+  if(err) throw err;
+  // tmp is now '/temporary', and /temporary exists
+});
+```
diff --git a/src/shell.js b/src/shell.js
index b29a2f9..378536a 100644
--- a/src/shell.js
+++ b/src/shell.js
@@ -72,6 +72,7 @@ define(function(require) {
    * should assume the existence of 3 arguments, which will be
    * defined at runtime:
    *
+   *   * fs - the current shell's bound filesystem object
    *   * options - an object containing any arguments, data, etc.
    *   * callback - a callback function(error, result) to call when done.
    *

From 4308e2d9ca0d1a18c8a5d2136bd2f100a02c6843 Mon Sep 17 00:00:00 2001
From: "David Humphrey (:humph) david.humphrey@senecacollege.ca"
 <david.humphrey@senecacollege.ca>
Date: Wed, 19 Feb 2014 15:25:52 -0500
Subject: [PATCH 12/17] Readme fixes

---
 README.md | 9 +++++----
 1 file changed, 5 insertions(+), 4 deletions(-)

diff --git a/README.md b/README.md
index ef365da..0bcc323 100644
--- a/README.md
+++ b/README.md
@@ -941,7 +941,7 @@ var sh = new Filer.FileSystemShell(fs, options);
 ```
 
 The `FileSystemShell` can take an optional `options` object. The `options` object
-can include `env`, which is a set of environment variables. Currently support variables
+can include `env`, which is a set of environment variables. Currently supported variables
 include `TMP` (the path to the temporary directory), and `PATH` (the list of known paths):
 
 ```javascript
@@ -994,15 +994,15 @@ var sh = fs.Shell();
 
 * [sh.cd(path, callback)](#cd)
 * [sh.ls(dir, [options], callback)](#ls)
-* [sh.exec(path, [options], callback)][#exec)
-* [sh.touch(path, [options], callback)[#touch)
+* [sh.exec(path, [options], callback)](#exec)
+* [sh.touch(path, [options], callback)](#touch)
 * [sh.cat(files, callback)](#cat)
 * [sh.rm(path, [options], callback)](#rm)
 * [sh.tempDir(callback)](#tempDir)
 
 #### sh.cd(path, callback)<a name="cd"></a>
 
-Changes the current working directory to directory at `path`. The callback returns
+Changes the current working directory to the directory at `path`. The callback returns
 an error if `path` does not exist, or is not a directory. Once the callback occurs
 the shell's `cwd` property is updated to the new path (as well as `sh.env.PWD`).
 
@@ -1013,6 +1013,7 @@ sh.cd('/dir1', function(err) {
   if(err) throw err;
   // sh.cwd is now '/dir1'
 });
+```
 
 #### sh.ls(dir, [options], callback)<a name="ls"></a>
 

From 80300fc92d1ba04945ea43feaac4bb6af379629d Mon Sep 17 00:00:00 2001
From: "David Humphrey (:humph) david.humphrey@senecacollege.ca"
 <david.humphrey@senecacollege.ca>
Date: Wed, 19 Feb 2014 15:27:58 -0500
Subject: [PATCH 13/17] More Readme fixes

---
 README.md | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/README.md b/README.md
index 0bcc323..fc05724 100644
--- a/README.md
+++ b/README.md
@@ -1064,12 +1064,13 @@ sh.ls('/dir', { recursive: true }, function(err, entries) {
 
 #### sh.exec(path, [options], callback)<a name="exec"></a>
 
-Attempts to Execute the .js command located at `path`. Such commands
+Attempts to execute the .js command located at `path`. Such commands
 should be written so as to assume the existence of 3 global variables,
 which will be defined at runtime:
 * `options` - <Object> an object containing any arguments, data, etc.
 * `fs` - <FileSystem> the `FileSystem` object bound to this shell.
-* `callback` - <Function> a callback function(error, result) to call when done.
+* `callback` - <Function> a callback function of the form `function callback(error, result)`
+to call when done.
 
 The .js command's contents should be the body of a function that
 looks like this:
@@ -1097,6 +1098,7 @@ fs.writeFile('/cmd.js', cmd, callback(err) {
     if(err) throw err;
   });
 });
+```
 
 #### sh.touch(path, [options], callback)<a name="touch"></a>
 

From 8eac72b9d00278f95bcd0df161225d2b6810c68a Mon Sep 17 00:00:00 2001
From: "David Humphrey (:humph) david.humphrey@senecacollege.ca"
 <david.humphrey@senecacollege.ca>
Date: Wed, 19 Feb 2014 15:32:01 -0500
Subject: [PATCH 14/17] More README fixes

---
 README.md | 12 +++++++-----
 1 file changed, 7 insertions(+), 5 deletions(-)

diff --git a/README.md b/README.md
index fc05724..39188b4 100644
--- a/README.md
+++ b/README.md
@@ -1064,9 +1064,10 @@ sh.ls('/dir', { recursive: true }, function(err, entries) {
 
 #### sh.exec(path, [options], callback)<a name="exec"></a>
 
-Attempts to execute the .js command located at `path`. Such commands
-should be written so as to assume the existence of 3 global variables,
-which will be defined at runtime:
+Attempts to execute the .js command located at `path`. The `sh.exec` method
+enables apps to install larger programs into the file system and run them
+later without having to re-download.  Such commands should be written so as
+to assume the existence of 3 global variables, which will be defined at runtime:
 * `options` - <Object> an object containing any arguments, data, etc.
 * `fs` - <FileSystem> the `FileSystem` object bound to this shell.
 * `callback` - <Function> a callback function of the form `function callback(error, result)`
@@ -1104,8 +1105,9 @@ fs.writeFile('/cmd.js', cmd, callback(err) {
 
 Create a file if it does not exist, or update the access and modified
 times if it does. Valid options include:
-* updateOnly - <Boolean> whether to create the file if it is missing (defaults to `false`)
-* date - <Date> a date to use instead of the current date and time when updating
+* `updateOnly` - `true` if the file's access/modified dates are to be updated
+only (but missing file not to be)
+* `date` - a date to use instead of the current date and time when updating
 access and modified dates.
 
 Example:

From eadd4ec03cce9ebe55a8900daac139666219b7bb Mon Sep 17 00:00:00 2001
From: "David Humphrey (:humph) david.humphrey@senecacollege.ca"
 <david.humphrey@senecacollege.ca>
Date: Wed, 19 Feb 2014 17:29:11 -0500
Subject: [PATCH 15/17] Review fixes

---
 README.md                    | 47 +++++++++++++++++++++---------------
 src/constants.js             |  7 +++++-
 src/environment.js           | 20 +++++++++++++++
 src/index.js                 |  1 -
 src/shell.js                 | 41 +++++++++++++------------------
 tests/spec/shell/cd.spec.js  | 26 ++++++++++----------
 tests/spec/shell/env.spec.js | 37 ++++++++++++++--------------
 7 files changed, 101 insertions(+), 78 deletions(-)
 create mode 100644 src/environment.js

diff --git a/README.md b/README.md
index 39188b4..8a7fdd4 100644
--- a/README.md
+++ b/README.md
@@ -64,8 +64,8 @@ section below.
 Filer also supports node's Path module. See the [Filer.Path](#FilerPath) section below.
 
 In addition, common shell operations (e.g., rm, touch, cat, etc.) are supported via the
-`FileSystemShell` object, which can be used with a `FileSystem`.  See the[Filer.FileSystemShell](#FileSystemShell)
-section below.
+`FileSystemShell` object, which can be obtained from, and used with a `FileSystem`.
+See the[FileSystemShell](#FileSystemShell) section below.
 
 ### API Reference
 
@@ -921,28 +921,27 @@ fs.open('/myfile', 'r', function(err, fd) {
 });
 ```
 
-### Filer.FileSystemShell<a name="FileSystemShell"></a>
+### FileSystemShell<a name="FileSystemShell"></a>
 
 Many common file system shell operations are available by using a `FileSystemShell` object.
-The `FileSystemShell` is used in conjuction with a `FileSystem`, and provides augmented
-features. Many separate `FileSystemShell` objects can exist per `FileSystem`, but each
-`FileSystemShell` is bound to a single instance of a `FileSystem` for its lifetime.
+The `FileSystemShell` is obtained from, and used in conjuction with a `FileSystem`,
+and provides augmented features. Many separate `FileSystemShell` objects can exist per
+`FileSystem`, but each `FileSystemShell` is bound to a single instance of a `FileSystem`
+for its lifetime.
 
-There are two ways to create a `FileSystemShell` object:
+A `FileSystemShell` is created using the `FileSystem.Shell()` function:
 
 ```javascript
-// Method 1: obtain a shell from an existing fs
 var fs = new Filer.FileSystem();
 var sh = fs.Shell(options);
-
-// Method 2: create a shell, passing in an existing fs
-var fs = new Filer.FileSystem();
-var sh = new Filer.FileSystemShell(fs, options);
+var sh2 = fs.Shell(options);
+// sh and sh2 are two separate shells, each bound to fs
 ```
 
 The `FileSystemShell` can take an optional `options` object. The `options` object
 can include `env`, which is a set of environment variables. Currently supported variables
-include `TMP` (the path to the temporary directory), and `PATH` (the list of known paths):
+include `TMP` (the path to the temporary directory), and `PATH` (the list of known paths) and
+others may be added in the future. You can also add your own, or update existing variables.
 
 ```javascript
 var fs = new Filer.FileSystem();
@@ -952,6 +951,8 @@ var sh = fs.Shell({
     PATH: '/one:/two'
   }
 });
+var tempPath = sh.env.get('TMP');
+sh.env.set('TMP', '/newtempdir');
 ```
 
 NOTE: unless otherwise stated, all `FileSystemShell` methods can take relative or absolute
@@ -963,22 +964,23 @@ of a current working directory.
 
 A `FileSystemShell` has a number of properties, including:
 * `fs` - (readonly) a reference to the bound `FileSystem`
-* `cwd` - (readonly) the current working directory (changed with `cd()`)
-* `env` - (readonly) the shell's environment. At runtime it will have an
-added `PWD` property, which is the same as `cwd`.
+* `env` - (readonly) the shell's environment. The shell's environemnt `env` object has `get(name)`
+and `set(name, value)` methods.
 
 Example:
 
 ```javascript
 var fs = new Filer.FileSystem();
 var sh = fs.Shell();
+var p = sh.env.get('PATH');
+
 // Store the current location
-var before = sh.env.PWD;
+var before = sh.pwd();
 var after;
 sh.cd('/newdir', function(err) {
   if(err) throw err;
   // Get the new location
-  after = sh.env.PWD;
+  after = sh.pwd();
 });
 ```
 
@@ -993,6 +995,7 @@ var sh = fs.Shell();
 ```
 
 * [sh.cd(path, callback)](#cd)
+* [sh.pwd()](#pwd)
 * [sh.ls(dir, [options], callback)](#ls)
 * [sh.exec(path, [options], callback)](#exec)
 * [sh.touch(path, [options], callback)](#touch)
@@ -1004,17 +1007,21 @@ var sh = fs.Shell();
 
 Changes the current working directory to the directory at `path`. The callback returns
 an error if `path` does not exist, or is not a directory. Once the callback occurs
-the shell's `cwd` property is updated to the new path (as well as `sh.env.PWD`).
+the shell's cwd is updated to the new path (you can access it via `sh.pwd()`).
 
 Example:
 
 ```javascript
 sh.cd('/dir1', function(err) {
   if(err) throw err;
-  // sh.cwd is now '/dir1'
+  // sh.pwd() is now '/dir1'
 });
 ```
 
+#### sh.pwd()<a name="pwd"></a>
+
+Returns the shell's current working directory. See [sh.cd()](#cd).
+
 #### sh.ls(dir, [options], callback)<a name="ls"></a>
 
 Get the listing of a directory, returning an array of directory entries
diff --git a/src/constants.js b/src/constants.js
index a8d8880..74871ae 100644
--- a/src/constants.js
+++ b/src/constants.js
@@ -62,7 +62,12 @@ define(function(require) {
     FS_PENDING: 'PENDING',
     FS_ERROR: 'ERROR',
 
-    SUPER_NODE_ID: '00000000-0000-0000-0000-000000000000'
+    SUPER_NODE_ID: '00000000-0000-0000-0000-000000000000',
+
+    ENVIRONMENT: {
+      TMP: '/tmp',
+      PATH: ''
+    }
   };
 
 });
\ No newline at end of file
diff --git a/src/environment.js b/src/environment.js
new file mode 100644
index 0000000..976e9e2
--- /dev/null
+++ b/src/environment.js
@@ -0,0 +1,20 @@
+define(function(require) {
+
+  var defaults = require('src/constants').ENVIRONMENT;
+
+  function Environment(env) {
+    env = env || {};
+    env.TMP = env.TMP || defaults.TMP;
+    env.PATH = env.PATH || defaults.PATH;
+
+    this.get = function(name) {
+      return env[name];
+    };
+
+    this.set = function(name, value) {
+      env[name] = value;
+    };
+  }
+
+  return Environment;
+});
diff --git a/src/index.js b/src/index.js
index f343bd6..017fbb2 100644
--- a/src/index.js
+++ b/src/index.js
@@ -4,7 +4,6 @@ define(function(require) {
 
   return {
     FileSystem: require('src/fs'),
-    FileSystemShell: require('src/shell'),
     Path: require('src/path')
   };
 
diff --git a/src/shell.js b/src/shell.js
index 378536a..d936a28 100644
--- a/src/shell.js
+++ b/src/shell.js
@@ -3,15 +3,13 @@ define(function(require) {
 
   var Path = require('src/path');
   var FilerError = require('src/error');
+  var Environment = require('src/environment');
   var async = require('async');
 
   function Shell(fs, options) {
     options = options || {};
 
-    var env = options.env || {};
-    env.TMP = env.TMP || '/tmp';
-    env.PATH = env.PATH || '';
-
+    var env = new Environment(options.env);
     var cwd = '/';
 
     /**
@@ -22,33 +20,21 @@ define(function(require) {
       enumerable: true
     });
 
-    /**
-     * The current working directory (changed with `cd()`)
-     */
-    Object.defineProperty(this, 'cwd', {
-      get: function() { return cwd; },
-      enumerable: true
-    });
-
-    /**
-     * Support bash's $PWD on the env
-     */
-    Object.defineProperty(env, 'PWD', {
-      get: function() { return cwd; },
-      enumerable: true
-    });
-
     /**
      * The shell's environment (e.g., for things like
-     * path, tmp, and other env vars)
+     * path, tmp, and other env vars). Use env.get()
+     * and env.set() to work with variables.
      */
     Object.defineProperty(this, 'env', {
       get: function() { return env; },
       enumerable: true
     });
 
-    // We include `cd` on the this vs. proto so that
-    // we can access cwd without exposing it externally.
+    /**
+     * Change the current working directory. We
+     * include `cd` on the `this` vs. proto so that
+     * we can access cwd without exposing it externally.
+     */
     this.cd = function(path, callback) {
       path = Path.resolve(this.cwd, path);
       // Make sure the path actually exists, and is a dir
@@ -65,6 +51,13 @@ define(function(require) {
         }
       });
     };
+
+    /**
+     * Get the current working directory (changed with `cd()`)
+     */
+    this.pwd = function() {
+      return cwd;
+    };
   }
 
   /**
@@ -350,7 +343,7 @@ define(function(require) {
    */
   Shell.prototype.tempDir = function(callback) {
     var fs = this.fs;
-    var tmp = this.env.TMP;
+    var tmp = this.env.get('TMP');
     callback = callback || function(){};
 
     // Try and create it, and it will either work or fail
diff --git a/tests/spec/shell/cd.spec.js b/tests/spec/shell/cd.spec.js
index 151b703..02bb90b 100644
--- a/tests/spec/shell/cd.spec.js
+++ b/tests/spec/shell/cd.spec.js
@@ -11,7 +11,7 @@ define(["Filer", "util"], function(Filer, util) {
 
     it('should default to a cwd of /', function() {
       var shell = util.shell();
-      expect(shell.cwd).to.equal('/');
+      expect(shell.pwd()).to.equal('/');
     });
 
     it('should allow changing the path to a valid dir', function(done) {
@@ -21,10 +21,10 @@ define(["Filer", "util"], function(Filer, util) {
       fs.mkdir('/dir', function(err) {
         if(err) throw err;
 
-        expect(shell.cwd).to.equal('/');
+        expect(shell.pwd()).to.equal('/');
         shell.cd('/dir', function(err) {
           expect(err).not.to.exist;
-          expect(shell.cwd).to.equal('/dir');
+          expect(shell.pwd()).to.equal('/dir');
           done();
         });
       });
@@ -37,11 +37,11 @@ define(["Filer", "util"], function(Filer, util) {
       fs.mkdir('/dir', function(err) {
         if(err) throw err;
 
-        expect(shell.cwd).to.equal('/');
+        expect(shell.pwd()).to.equal('/');
         shell.cd('/nodir', function(err) {
           expect(err).to.exist;
           expect(err.name).to.equal('ENotDirectory');
-          expect(shell.cwd).to.equal('/');
+          expect(shell.pwd()).to.equal('/');
           done();
         });
       });
@@ -54,11 +54,11 @@ define(["Filer", "util"], function(Filer, util) {
       fs.writeFile('/file', 'file', function(err) {
         if(err) throw err;
 
-        expect(shell.cwd).to.equal('/');
+        expect(shell.pwd()).to.equal('/');
         shell.cd('/file', function(err) {
           expect(err).to.exist;
           expect(err.name).to.equal('ENotDirectory');
-          expect(shell.cwd).to.equal('/');
+          expect(shell.pwd()).to.equal('/');
           done();
         });
       });
@@ -71,10 +71,10 @@ define(["Filer", "util"], function(Filer, util) {
       fs.mkdir('/dir', function(err) {
         if(err) throw err;
 
-        expect(shell.cwd).to.equal('/');
+        expect(shell.pwd()).to.equal('/');
         shell.cd('./dir', function(err) {
           expect(err).not.to.exist;
-          expect(shell.cwd).to.equal('/dir');
+          expect(shell.pwd()).to.equal('/dir');
           done();
         });
       });
@@ -87,13 +87,13 @@ define(["Filer", "util"], function(Filer, util) {
       fs.mkdir('/dir', function(err) {
         if(err) throw err;
 
-        expect(shell.cwd).to.equal('/');
+        expect(shell.pwd()).to.equal('/');
         shell.cd('./dir', function(err) {
           expect(err).not.to.exist;
-          expect(shell.cwd).to.equal('/dir');
+          expect(shell.pwd()).to.equal('/dir');
           shell.cd('..', function(err) {
             expect(err).not.to.exist;
-            expect(shell.cwd).to.equal('/');
+            expect(shell.pwd()).to.equal('/');
             done();
           });
         });
@@ -112,7 +112,7 @@ define(["Filer", "util"], function(Filer, util) {
           var shell = fs.Shell();
           shell.cd('link', function(error) {
             expect(error).not.to.exist;
-            expect(shell.cwd).to.equal('/link');
+            expect(shell.pwd()).to.equal('/link');
             done();
           });
         });
diff --git a/tests/spec/shell/env.spec.js b/tests/spec/shell/env.spec.js
index af0c321..05d8960 100644
--- a/tests/spec/shell/env.spec.js
+++ b/tests/spec/shell/env.spec.js
@@ -7,9 +7,9 @@ define(["Filer", "util"], function(Filer, util) {
     it('should get default env options', function() {
       var shell = util.shell();
       expect(shell.env).to.exist;
-      expect(shell.env.TMP).to.equal('/tmp');
-      expect(shell.env.PATH).to.equal('');
-      expect(shell.env.PWD).to.equal('/');
+      expect(shell.env.get('TMP')).to.equal('/tmp');
+      expect(shell.env.get('PATH')).to.equal('');
+      expect(shell.pwd()).to.equal('/');
     });
 
     it('should be able to specify env options', function() {
@@ -21,9 +21,13 @@ define(["Filer", "util"], function(Filer, util) {
       };
       var shell = util.shell(options);
       expect(shell.env).to.exist;
-      expect(shell.env.TMP).to.equal('/tempdir');
-      expect(shell.env.PATH).to.equal('/dir');
-      expect(shell.env.PWD).to.equal('/');
+      expect(shell.env.get('TMP')).to.equal('/tempdir');
+      expect(shell.env.get('PATH')).to.equal('/dir');
+      expect(shell.pwd()).to.equal('/');
+
+      expect(shell.env.get('FOO')).not.to.exist;
+      shell.env.set('FOO', 1);
+      expect(shell.env.get('FOO')).to.equal(1);
     });
 
     it('should fail when dirs argument is absent', function(done) {
@@ -37,20 +41,17 @@ define(["Filer", "util"], function(Filer, util) {
       });
     });
 
-    it('should update the value of env.PWD when cwd changes', function(done) {
+    it('should give new value for shell.pwd() when cwd changes', function(done) {
       var fs = util.fs();
       var shell = fs.Shell();
 
       fs.mkdir('/dir', function(err) {
         if(err) throw err;
 
-        expect(shell.cwd).to.equal('/');
-        expect(shell.env.PWD).to.equal('/');
-
+        expect(shell.pwd()).to.equal('/');
         shell.cd('/dir', function(err) {
           expect(err).not.to.exist;
-          expect(shell.cwd).to.equal('/dir');
-          expect(shell.env.PWD).to.equal('/dir');
+          expect(shell.pwd()).to.equal('/dir');
           done();
         });
       });
@@ -60,13 +61,12 @@ define(["Filer", "util"], function(Filer, util) {
       var fs = util.fs();
       var shell = fs.Shell();
 
-      expect(shell.env.TMP).to.equal('/tmp');
+      expect(shell.env.get('TMP')).to.equal('/tmp');
       shell.tempDir(function(err, tmp) {
         expect(err).not.to.exist;
         shell.cd(tmp, function(err) {
           expect(err).not.to.exist;
-          expect(shell.cwd).to.equal('/tmp');
-          expect(shell.env.PWD).to.equal('/tmp');
+          expect(shell.pwd()).to.equal('/tmp');
           done();
         });
       });
@@ -80,13 +80,12 @@ define(["Filer", "util"], function(Filer, util) {
         }
       });
 
-      expect(shell.env.TMP).to.equal('/tempdir');
+      expect(shell.env.get('TMP')).to.equal('/tempdir');
       shell.tempDir(function(err, tmp) {
         expect(err).not.to.exist;
         shell.cd(tmp, function(err) {
           expect(err).not.to.exist;
-          expect(shell.cwd).to.equal('/tempdir');
-          expect(shell.env.PWD).to.equal('/tempdir');
+          expect(shell.pwd()).to.equal('/tempdir');
           done();
         });
       });
@@ -96,7 +95,7 @@ define(["Filer", "util"], function(Filer, util) {
       var fs = util.fs();
       var shell = fs.Shell();
 
-      expect(shell.env.TMP).to.equal('/tmp');
+      expect(shell.env.get('TMP')).to.equal('/tmp');
       shell.tempDir(function(err, tmp) {
         expect(err).not.to.exist;
         expect(tmp).to.equal('/tmp');

From a7a1f4b82e3dfd5feb9ab28880de6f83f4fedc58 Mon Sep 17 00:00:00 2001
From: "David Humphrey (:humph) david.humphrey@senecacollege.ca"
 <david.humphrey@senecacollege.ca>
Date: Wed, 19 Feb 2014 17:36:26 -0500
Subject: [PATCH 16/17] Change sh.exec to take a list vs. object for passed
 args

---
 README.md                     | 16 ++++++++--------
 src/shell.js                  | 18 +++++++++---------
 tests/spec/shell/exec.spec.js |  4 ++--
 3 files changed, 19 insertions(+), 19 deletions(-)

diff --git a/README.md b/README.md
index 8a7fdd4..1b3b4a4 100644
--- a/README.md
+++ b/README.md
@@ -997,7 +997,7 @@ var sh = fs.Shell();
 * [sh.cd(path, callback)](#cd)
 * [sh.pwd()](#pwd)
 * [sh.ls(dir, [options], callback)](#ls)
-* [sh.exec(path, [options], callback)](#exec)
+* [sh.exec(path, [args], callback)](#exec)
 * [sh.touch(path, [options], callback)](#touch)
 * [sh.cat(files, callback)](#cat)
 * [sh.rm(path, [options], callback)](#rm)
@@ -1069,22 +1069,22 @@ sh.ls('/dir', { recursive: true }, function(err, entries) {
 });
 ```
 
-#### sh.exec(path, [options], callback)<a name="exec"></a>
+#### sh.exec(path, [args], callback)<a name="exec"></a>
 
 Attempts to execute the .js command located at `path`. The `sh.exec` method
 enables apps to install larger programs into the file system and run them
 later without having to re-download.  Such commands should be written so as
 to assume the existence of 3 global variables, which will be defined at runtime:
-* `options` - <Object> an object containing any arguments, data, etc.
-* `fs` - <FileSystem> the `FileSystem` object bound to this shell.
-* `callback` - <Function> a callback function of the form `function callback(error, result)`
+* `fs` - [FileSystem] the `FileSystem` object bound to this shell.
+* `args` - [Array] a list of any arguments for the command, or the empty list
+* `callback` - [Function] a callback function of the form `function callback(error, result)`
 to call when done.
 
 The .js command's contents should be the body of a function that
 looks like this:
 
 ```javascript
-function(fs, options, callback) {
+function(fs, args, callback) {
 //-------------------------commmand code here---------
 // ...
 //----------------------------------------------------
@@ -1095,14 +1095,14 @@ Example:
 
 ```javascript
 // Simple command to delete a file.
-var cmd = "fs.unlink(options.path, callback);"
+var cmd = "fs.unlink(args[0], callback);"
 
 // Write the file to the filesystem
 fs.writeFile('/cmd.js', cmd, callback(err) {
   if(err) throw err;
 
   // Execute the command
-  sh.exec('/cmd.js', { path: '/file' }, function(err, result) {
+  sh.exec('/cmd.js', [ '/file' ], function(err, result) {
     if(err) throw err;
   });
 });
diff --git a/src/shell.js b/src/shell.js
index d936a28..a691196 100644
--- a/src/shell.js
+++ b/src/shell.js
@@ -66,23 +66,23 @@ define(function(require) {
    * defined at runtime:
    *
    *   * fs - the current shell's bound filesystem object
-   *   * options - an object containing any arguments, data, etc.
+   *   * args - a list of arguments for the command, or an empty list if none
    *   * callback - a callback function(error, result) to call when done.
    *
    * The .js command's contents should be the body of a function
    * that looks like this:
    *
-   * function(fs, options, callback) {
+   * function(fs, args, callback) {
    *   // .js code here
    * }
    */
-  Shell.prototype.exec = function(path, options, callback) {
+  Shell.prototype.exec = function(path, args, callback) {
     var fs = this.fs;
-    if(typeof options === 'function') {
-      callback = options;
-      options = {};
+    if(typeof args === 'function') {
+      callback = args;
+      args = [];
     }
-    options = options || {};
+    args = args || [];
     callback = callback || function(){};
     path = Path.resolve(this.cwd, path);
 
@@ -92,8 +92,8 @@ define(function(require) {
         return;
       }
       try {
-        var cmd = new Function('fs', 'options', 'callback', data);
-        cmd(fs, options, callback);
+        var cmd = new Function('fs', 'args', 'callback', data);
+        cmd(fs, args, callback);
       } catch(e) {
         callback(e);
       }
diff --git a/tests/spec/shell/exec.spec.js b/tests/spec/shell/exec.spec.js
index 6f325a0..fbbecb9 100644
--- a/tests/spec/shell/exec.spec.js
+++ b/tests/spec/shell/exec.spec.js
@@ -12,12 +12,12 @@ define(["Filer", "util"], function(Filer, util) {
     it('should be able to execute a command .js file from the filesystem', function(done) {
       var fs = util.fs();
       var shell = fs.Shell();
-      var cmdString = "fs.writeFile(options.path, options.data, callback);";
+      var cmdString = "fs.writeFile(args[0], args[1], callback);";
 
       fs.writeFile('/cmd.js', cmdString, function(error) {
         if(error) throw error;
 
-        shell.exec('/cmd.js', {path: '/test', data: 'hello world'}, function(error, result) {
+        shell.exec('/cmd.js', ['/test', 'hello world'], function(error, result) {
           if(error) throw error;
 
           fs.readFile('/test', 'utf8', function(error, data) {

From 64a52b7d00321e0a59c5910366bab763198c7f1a Mon Sep 17 00:00:00 2001
From: "David Humphrey (:humph) david.humphrey@senecacollege.ca"
 <david.humphrey@senecacollege.ca>
Date: Wed, 19 Feb 2014 17:55:56 -0500
Subject: [PATCH 17/17] Share code from lib/async.js instead of inlining
 nextTick in Memory provider

---
 src/providers/memory.js | 21 +--------------------
 1 file changed, 1 insertion(+), 20 deletions(-)

diff --git a/src/providers/memory.js b/src/providers/memory.js
index 40524c1..38104e2 100644
--- a/src/providers/memory.js
+++ b/src/providers/memory.js
@@ -1,26 +1,7 @@
 define(function(require) {
   var FILE_SYSTEM_NAME = require('src/constants').FILE_SYSTEM_NAME;
 
-  // Based on https://github.com/caolan/async/blob/master/lib/async.js
-  var nextTick = (function() {
-    if (typeof process === 'undefined' || !(process.nextTick)) {
-      if (typeof setImmediate === 'function') {
-        return function (fn) {
-          // not a direct alias for IE10 compatibility
-          setImmediate(fn);
-        };
-      } else {
-        return function (fn) {
-          setTimeout(fn, 0);
-        };
-      }
-    }
-    return process.nextTick;
-  }());
-
-  function asyncCallback(callback) {
-    nextTick(callback);
-  }
+  var asyncCallback = require('async').nextTick;
 
   function MemoryContext(db, readOnly) {
     this.readOnly = readOnly;