- added idbfs and nodefs

 - minor coding convention fixes

1 files changed, 234 insertions, 0 deletions

diff --git a/src/library_nodefs.js b/src/library_nodefs.js
new file mode 100644
index 00000000..d8df1689
--- /dev/null
+++ b/src/library_nodefs.js
@@ -0,0 +1,234 @@
+mergeInto(LibraryManager.library, {
+  $NODEFS__deps: ['$FS', '$PATH'],
+  $NODEFS__postset: 'if (ENVIRONMENT_IS_NODE) { var fs = require("fs"); }',
+  $NODEFS: {
+    mount: function (mount) {
+      assert(ENVIRONMENT_IS_NODE);
+      return NODEFS.createNode(null, '/', NODEFS.getMode(mount.opts.root), 0);
+    },
+    createNode: function (parent, name, mode, dev) {
+      if (!FS.isDir(mode) && !FS.isFile(mode) && !FS.isLink(mode)) {
+        throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
+      }
+      var node = FS.createNode(parent, name, mode);
+      node.node_ops = NODEFS.node_ops;
+      node.stream_ops = NODEFS.stream_ops;
+      return node;
+    },
+    getMode: function (path) {
+      var stat;
+      try {
+        stat = fs.lstatSync(path);
+      } catch (e) {
+        if (!e.code) throw e;
+        throw new FS.ErrnoError(ERRNO_CODES[e.code]);
+      }
+      return stat.mode;
+    },
+    realPath: function (node) {
+      var parts = [];
+      while (node.parent !== node) {
+        parts.push(node.name);
+        node = node.parent;
+      }
+      parts.push(node.mount.opts.root);
+      parts.reverse();
+      return PATH.join.apply(null, parts);
+    },
+    node_ops: {
+      getattr: function(node) {
+        var path = NODEFS.realPath(node);
+        var stat;
+        try {
+          stat = fs.lstatSync(path);
+        } catch (e) {
+          if (!e.code) throw e;
+          throw new FS.ErrnoError(ERRNO_CODES[e.code]);
+        }
+        return {
+          dev: stat.dev,
+          ino: stat.ino,
+          mode: stat.mode,
+          nlink: stat.nlink,
+          uid: stat.uid,
+          gid: stat.gid,
+          rdev: stat.rdev,
+          size: stat.size,
+          atime: stat.atime,
+          mtime: stat.mtime,
+          ctime: stat.ctime,
+          blksize: stat.blksize,
+          blocks: stat.blocks
+        };
+      },
+      setattr: function(node, attr) {
+        var path = NODEFS.realPath(node);
+        try {
+          if (attr.mode !== undefined) {
+            fs.chmodSync(path, attr.mode);
+            // update the common node structure mode as well
+            node.mode = attr.mode;
+          }
+          if (attr.timestamp !== undefined) {
+            var date = new Date(attr.timestamp);
+            fs.utimesSync(path, date, date);
+          }
+          if (attr.size !== undefined) {
+            fs.truncateSync(path, attr.size);
+          }
+        } catch (e) {
+          if (!e.code) throw e;
+          throw new FS.ErrnoError(ERRNO_CODES[e.code]);
+        }
+      },
+      lookup: function (parent, name) {
+        var path = PATH.join(NODEFS.realPath(parent), name);
+        var mode = NODEFS.getMode(path);
+        return NODEFS.createNode(parent, name, mode);
+      },
+      mknod: function (parent, name, mode, dev) {
+        var node = NODEFS.createNode(parent, name, mode, dev);
+        // create the backing node for this in the fs root as well
+        var path = NODEFS.realPath(node);
+        try {
+          if (FS.isDir(node.mode)) {
+            fs.mkdirSync(path, node.mode);
+          } else {
+            fs.writeFileSync(path, '', { mode: node.mode });
+          }
+        } catch (e) {
+          if (!e.code) throw e;
+          throw new FS.ErrnoError(ERRNO_CODES[e.code]);
+        }
+        return node;
+      },
+      rename: function (oldNode, newDir, newName) {
+        var oldPath = NODEFS.realPath(oldNode);
+        var newPath = PATH.join(NODEFS.realPath(newDir), newName);
+        try {
+          fs.renameSync(oldPath, newPath);
+        } catch (e) {
+          if (!e.code) throw e;
+          throw new FS.ErrnoError(ERRNO_CODES[e.code]);
+        }
+      },
+      unlink: function(parent, name) {
+        var path = PATH.join(NODEFS.realPath(parent), name);
+        try {
+          fs.unlinkSync(path);
+        } catch (e) {
+          if (!e.code) throw e;
+          throw new FS.ErrnoError(ERRNO_CODES[e.code]);
+        }
+      },
+      rmdir: function(parent, name) {
+        var path = PATH.join(NODEFS.realPath(parent), name);
+        try {
+          fs.rmdirSync(path);
+        } catch (e) {
+          if (!e.code) throw e;
+          throw new FS.ErrnoError(ERRNO_CODES[e.code]);
+        }
+      },
+      readdir: function(node) {
+        var path = NODEFS.realPath(node);
+        try {
+          return fs.readdirSync(path);
+        } catch (e) {
+          if (!e.code) throw e;
+          throw new FS.ErrnoError(ERRNO_CODES[e.code]);
+        }
+      },
+      symlink: function(parent, newName, oldPath) {
+        var newPath = PATH.join(NODEFS.realPath(parent), newName);
+        try {
+          fs.symlinkSync(oldPath, newPath);
+        } catch (e) {
+          if (!e.code) throw e;
+          throw new FS.ErrnoError(ERRNO_CODES[e.code]);
+        }
+      },
+      readlink: function(node) {
+        var path = NODEFS.realPath(node);
+        try {
+          return fs.readlinkSync(path);
+        } catch (e) {
+          if (!e.code) throw e;
+          throw new FS.ErrnoError(ERRNO_CODES[e.code]);
+        }
+      },
+    },
+    stream_ops: {
+      open: function (stream) {
+        var path = NODEFS.realPath(stream.node);
+        try {
+          if (FS.isFile(stream.node.mode)) {
+            stream.nfd = fs.openSync(path, stream.flags);
+          }
+        } catch (e) {
+          if (!e.code) throw e;
+          throw new FS.ErrnoError(ERRNO_CODES[e.code]);
+        }
+      },
+      close: function (stream) {
+        try {
+          if (FS.isFile(stream.node.mode)) {
+            fs.closeSync(stream.nfd);
+          }
+        } catch (e) {
+          if (!e.code) throw e;
+          throw new FS.ErrnoError(ERRNO_CODES[e.code]);
+        }
+      },
+      read: function (stream, buffer, offset, length, position) {
+        // FIXME this is terrible.
+        var nbuffer = new Buffer(length);
+        var res;
+        try {
+          res = fs.readSync(stream.nfd, nbuffer, 0, length, position);
+        } catch (e) {
+          throw new FS.ErrnoError(ERRNO_CODES[e.code]);
+        }
+        if (res > 0) {
+          for (var i = 0; i < res; i++) {
+            buffer[offset + i] = nbuffer[i];
+          }
+        }
+        return res;
+      },
+      write: function (stream, buffer, offset, length, position) {
+        // FIXME this is terrible.
+        var nbuffer = new Buffer(buffer.subarray(offset, offset + length));
+        var res;
+        try {
+          res = fs.writeSync(stream.nfd, nbuffer, 0, length, position);
+        } catch (e) {
+          throw new FS.ErrnoError(ERRNO_CODES[e.code]);
+        }
+        return res;
+      },
+      llseek: function (stream, offset, whence) {
+        var position = offset;
+        if (whence === 1) {  // SEEK_CUR.
+          position += stream.position;
+        } else if (whence === 2) {  // SEEK_END.
+          if (FS.isFile(stream.node.mode)) {
+            try {
+              var stat = fs.fstatSync(stream.nfd);
+              position += stat.size;
+            } catch (e) {
+              throw new FS.ErrnoError(ERRNO_CODES[e.code]);
+            }
+          }
+        }
+
+        if (position < 0) {
+          throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
+        }
+
+        stream.position = position;
+        return position;
+      }
+    }
+  }
+});
\ No newline at end of file