Fix failing tests for src/filesystem/* issues, all tests pass now

src/filesystem/implementation.js

@@ -1440,19 +1440,11 @@ define(function(require) {
     return true;
   }
 
-  // node.js supports a calling pattern that leaves off a callback.
-  function maybeCallback(callback) {
-    if(typeof callback === "function") {
-      return callback;
-    }
-    return function(err) {
-      if(err) {
-        throw err;
-      }
-    };
-  }
 
-  function open(fs, context, path, flags, callback) {
+  function open(fs, context, path, flags, mode, callback) {
+    // NOTE: we support the same signature as node with a `mode` arg,
+    // but ignore it.
+    callback = arguments[arguments.length - 1];
     if(!pathCheck(path, callback)) return;
 
     function check_result(error, fileNode) {
@@ -1479,7 +1471,7 @@ define(function(require) {
     open_file(context, path, flags, check_result);
   }
 
-  function close(fs, fd, callback) {
+  function close(fs, context, fd, callback) {
     if(!_(fs.openFiles).has(fd)) {
       callback(new Errors.EBADF());
     } else {
@@ -1488,24 +1480,26 @@ define(function(require) {
     }
   }
 
-  function mkdir(context, path, callback) {
+  function mkdir(fs, context, path, mode, callback) {
+    // NOTE: we support passing a mode arg, but we ignore it internally for now.
+    callback = arguments[arguments.length - 1];
     if(!pathCheck(path, callback)) return;
     make_directory(context, path, standard_check_result_cb(callback));
   }
 
-  function rmdir(context, path, callback) {
+  function rmdir(fs, context, path, callback) {
     if(!pathCheck(path, callback)) return;
     remove_directory(context, path, standard_check_result_cb(callback));
   }
 
-  function stat(context, name, path, callback) {
+  function stat(fs, context, path, callback) {
     if(!pathCheck(path, callback)) return;
 
     function check_result(error, result) {
       if(error) {
         callback(error);
       } else {
-        var stats = new Stats(result, name);
+        var stats = new Stats(result, fs.name);
         callback(null, stats);
       }
     }
@@ -1531,20 +1525,27 @@ define(function(require) {
     }
   }
 
-  function link(context, oldpath, newpath, callback) {
+  function link(fs, context, oldpath, newpath, callback) {
     if(!pathCheck(oldpath, callback)) return;
     if(!pathCheck(newpath, callback)) return;
     link_node(context, oldpath, newpath, standard_check_result_cb(callback));
   }
 
-  function unlink(context, path, callback) {
+  function unlink(fs, context, path, callback) {
     if(!pathCheck(path, callback)) return;
     unlink_node(context, path, standard_check_result_cb(callback));
   }
 
   function read(fs, context, fd, buffer, offset, length, position, callback) {
+    // Follow how node.js does this
+    function wrapped_cb(err, bytesRead) {
+      // Retain a reference to buffer so that it can't be GC'ed too soon.
+      callback(err, bytesRead || 0, buffer);
+    }
+
     offset = (undefined === offset) ? 0 : offset;
     length = (undefined === length) ? buffer.length - offset : length;
+    callback = arguments[arguments.length - 1];
 
     var ofd = fs.openFiles[fd];
     if(!ofd) {
@@ -1552,11 +1553,12 @@ define(function(require) {
     } else if(!_(ofd.flags).contains(O_READ)) {
       callback(new Errors.EBADF('descriptor does not permit reading'));
     } else {
-      read_data(context, ofd, buffer, offset, length, position, standard_check_result_cb(callback));
+      read_data(context, ofd, buffer, offset, length, position, standard_check_result_cb(wrapped_cb));
     }
   }
 
   function readFile(fs, context, path, options, callback) {
+    callback = arguments[arguments.length - 1];
     options = validate_file_options(options, null, 'r');
 
     if(!pathCheck(path, callback)) return;
@@ -1601,6 +1603,7 @@ define(function(require) {
   }
 
   function write(fs, context, fd, buffer, offset, length, position, callback) {
+    callback = arguments[arguments.length - 1];
     offset = (undefined === offset) ? 0 : offset;
     length = (undefined === length) ? buffer.length - offset : length;
 
@@ -1617,6 +1620,7 @@ define(function(require) {
   }
 
   function writeFile(fs, context, path, data, options, callback) {
+    callback = arguments[arguments.length - 1];
     options = validate_file_options(options, 'utf8', 'w');
 
     if(!pathCheck(path, callback)) return;
@@ -1652,6 +1656,7 @@ define(function(require) {
   }
 
   function appendFile(fs, context, path, data, options, callback) {
+    callback = arguments[arguments.length - 1];
     options = validate_file_options(options, 'utf8', 'a');
 
     if(!pathCheck(path, callback)) return;
@@ -1686,14 +1691,14 @@ define(function(require) {
     });
   }
 
-  function exists(context, name, path, callback) {
+  function exists(fs, context, path, callback) {
     function cb(err, stats) {
       callback(err ? false : true);
     }
-    stat(context, name, path, cb);
+    stat(fs, context, path, cb);
   }
 
-  function getxattr(context, path, name, callback) {
+  function getxattr(fs, context, path, name, callback) {
     if (!pathCheck(path, callback)) return;
     getxattr_file(context, path, name, standard_check_result_cb(callback));
   }
@@ -1708,12 +1713,22 @@ define(function(require) {
     }
   }
 
-  function setxattr(context, path, name, value, flag, callback) {
+  function setxattr(fs, context, path, name, value, flag, callback) {
+    if(typeof flag === 'function') {
+      callback = flag;
+      flag = null;
+    }
+
     if (!pathCheck(path, callback)) return;
     setxattr_file(context, path, name, value, flag, standard_check_result_cb(callback));
   }
 
   function fsetxattr(fs, context, fd, name, value, flag, callback) {
+    if(typeof flag === 'function') {
+      callback = flag;
+      flag = null;
+    }
+
     var ofd = fs.openFiles[fd];
     if (!ofd) {
       callback(new Errors.EBADF());
@@ -1726,7 +1741,7 @@ define(function(require) {
     }
   }
 
-  function removexattr(context, path, name, callback) {
+  function removexattr(fs, context, path, name, callback) {
     if (!pathCheck(path, callback)) return;
     removexattr_file(context, path, name, standard_check_result_cb(callback));
   }
@@ -1784,12 +1799,12 @@ define(function(require) {
     }
   }
 
-  function readdir(context, path, callback) {
+  function readdir(fs, context, path, callback) {
     if(!pathCheck(path, callback)) return;
     read_directory(context, path, standard_check_result_cb(callback));
   }
 
-  function utimes(context, path, atime, mtime, callback) {
+  function utimes(fs, context, path, atime, mtime, callback) {
     if(!pathCheck(path, callback)) return;
 
     var currentTime = Date.now();
@@ -1814,7 +1829,7 @@ define(function(require) {
     }
   }
 
-  function rename(context, oldpath, newpath, callback) {
+  function rename(fs, context, oldpath, newpath, callback) {
     if(!pathCheck(oldpath, callback)) return;
     if(!pathCheck(newpath, callback)) return;
 
@@ -1829,13 +1844,15 @@ define(function(require) {
     link_node(context, oldpath, newpath, unlink_old_node);
   }
 
-  function symlink(context, srcpath, dstpath, callback) {
+  function symlink(fs, context, srcpath, dstpath, type, callback) {
+    // NOTE: we support passing the `type` arg, but ignore it.
+    callback = arguments[arguments.length - 1];
     if(!pathCheck(srcpath, callback)) return;
     if(!pathCheck(dstpath, callback)) return;
     make_symbolic_link(context, srcpath, dstpath, standard_check_result_cb(callback));
   }
 
-  function readlink(context, path, callback) {
+  function readlink(fs, context, path, callback) {
     if(!pathCheck(path, callback)) return;
     read_link(context, path, standard_check_result_cb(callback));
   }
@@ -1855,12 +1872,20 @@ define(function(require) {
     lstat_file(context, path, check_result);
   }
 
-  function truncate(context, path, length, callback) {
+  function truncate(fs, context, path, length, callback) {
+    // NOTE: length is optional
+    callback = arguments[arguments.length - 1];
+    length = length || 0;
+
     if(!pathCheck(path, callback)) return;
     truncate_file(context, path, length, standard_check_result_cb(callback));
   }
 
   function ftruncate(fs, context, fd, length, callback) {
+    // NOTE: length is optional
+    callback = arguments[arguments.length - 1];
+    length = length || 0;
+
     var ofd = fs.openFiles[fd];
     if(!ofd) {
       callback(new Errors.EBADF());

src/filesystem/interface.js

@@ -10,8 +10,6 @@ define(function(require) {
   var FS_READY = require('src/constants').FS_READY;
   var FS_PENDING = require('src/constants').FS_PENDING;
   var FS_ERROR = require('src/constants').FS_ERROR;
-  var FS_NOMTIME = require('src/constants').FS_NOMTIME;
-  var FS_NOCTIME = require('src/constants').FS_NOCTIME;
 
   var providers = require('src/providers/providers');
   var adapters = require('src/adapters/adapters');
@@ -36,7 +34,7 @@ define(function(require) {
     };
   }
 
-  /*
+  /**
    * FileSystem
    *
    * A FileSystem takes an `options` object, which can specify a number of,
@@ -65,9 +63,10 @@ define(function(require) {
     options = options || {};
     callback = callback || nop;
 
-    var name = options.name || FILE_SYSTEM_NAME;
     var flags = options.flags;
-    var provider = options.provider || new providers.Default(name);
+    var provider = options.provider || new providers.Default(options.name || FILE_SYSTEM_NAME);
+    // If we're given a provider, match its name unless we get an explicit name
+    var name = options.name || provider.name;
     var forceFormatting = _(flags).contains(FS_FORMAT);
 
     var fs = this;
@@ -211,497 +210,79 @@ define(function(require) {
   // Expose adatpers on FileSystem constructor
   FileSystem.adapters = adapters;
 
-
   /**
    * Public API for FileSystem
    */
+  [
+    'open',
+    'close',
+    'mkdir',
+    'rmdir',
+    'stat',
+    'fstat',
+    'link',
+    'unlink',
+    'read',
+    'readFile',
+    'write',
+    'writeFile',
+    'appendFile',
+    'exists',
+    'lseek',
+    'readdir',
+    'rename',
+    'readlink',
+    'symlink',
+    'lstat',
+    'truncate',
+    'ftruncate',
+    'utimes',
+    'futimes',
+    'setxattr',
+    'getxattr',
+    'fsetxattr',
+    'fgetxattr',
+    'removexattr',
+    'fremovexattr'
+  ].forEach(function(methodName) {
+    FileSystem.prototype[methodName] = function() {
+      var fs = this;
+      var args = Array.prototype.slice.call(arguments, 0);
+      var lastArgIndex = args.length - 1;
 
-  FileSystem.prototype.open = function(path, flags, mode, callback) {
+      // We may or may not get a callback, and since node.js supports
-    // We support the same signature as node with a `mode` arg, but
+      // fire-and-forget style fs operations, we have to dance a bit here.
-    // ignore it. Find the callback.
+      var missingCallback = typeof args[lastArgIndex] !== 'function';
-    callback = maybeCallback(arguments[arguments.length - 1]);
+      var callback = maybeCallback(args[lastArgIndex]);
-    var fs = this;
+
-    var error = fs.queueOrRun(
+      var error = fs.queueOrRun(function() {
-      function() {
         var context = fs.provider.openReadWriteContext();
+
+        // Wrap the callback so we can explicitly close the context
         function complete() {
           context.close();
           callback.apply(fs, arguments);
         }
-        impl.open(fs, context, path, flags, complete);
+
+        // Either add or replace the callback with our wrapper complete()
+        if(missingCallback) {
+          args.push(complete);
+        } else {
+          args[lastArgIndex] = complete;
         }
-    );
+
-    if(error) callback(error);
+        // Forward this call to the impl's version, using the following
-  };
+        // call signature, with complete() as the callback/last-arg now:
-  FileSystem.prototype.close = function(fd, callback) {
+        // fn(fs, context, arg0, arg1, ... , complete);
-    callback = maybeCallback(callback);
+        var fnArgs = [fs, context].concat(args);
-    var fs = this;
+        impl[methodName].apply(null, fnArgs);
-    var error = fs.queueOrRun(
+      });
-      function() {
-        var context = fs.provider.openReadWriteContext();
-        function complete() {
-          context.close();
-          callback.apply(fs, arguments);
-        }
-        impl.close(fs, fd, complete);
-      }
-    );
-    if(error) callback(error);
-  };
-  FileSystem.prototype.mkdir = function(path, mode, callback) {
-    // Support passing a mode arg, but we ignore it internally for now.
-    if(typeof mode === 'function') {
-      callback = mode;
-    }
-    callback = maybeCallback(callback);
-    var fs = this;
-    var error = fs.queueOrRun(
-      function() {
-        var context = fs.provider.openReadWriteContext();
-        function complete() {
-          context.close();
-          callback.apply(fs, arguments);
-        }
-        impl.mkdir(context, path, complete);
-      }
-    );
-    if(error) callback(error);
-  };
-  FileSystem.prototype.rmdir = function(path, callback) {
-    callback = maybeCallback(callback);
-    var fs = this;
-    var error = fs.queueOrRun(
-      function() {
-        var context = fs.provider.openReadWriteContext();
-        function complete() {
-          context.close();
-          callback.apply(fs, arguments);
-        }
-        impl.rmdir(context, path, complete);
-      }
-    );
-    if(error) callback(error);
-  };
-  FileSystem.prototype.stat = function(path, callback) {
-    callback = maybeCallback(callback);
-    var fs = this;
-    var error = fs.queueOrRun(
-      function() {
-        var context = fs.provider.openReadWriteContext();
-        function complete() {
-          context.close();
-          callback.apply(fs, arguments);
-        }
-        impl.stat(context, fs.name, path, complete);
-      }
-    );
-    if(error) callback(error);
-  };
-  FileSystem.prototype.fstat = function(fd, callback) {
-    callback = maybeCallback(callback);
-    var fs = this;
-    var error = fs.queueOrRun(
-      function() {
-        var context = fs.provider.openReadWriteContext();
-        function complete() {
-          context.close();
-          callback.apply(fs, arguments);
-        }
-        impl.fstat(fs, context, fd, complete);
-      }
-    );
-    if(error) callback(error);
-  };
-  FileSystem.prototype.link = function(oldpath, newpath, callback) {
-    callback = maybeCallback(callback);
-    var fs = this;
-    var error = fs.queueOrRun(
-      function() {
-        var context = fs.provider.openReadWriteContext();
-        function complete() {
-          context.close();
-          callback.apply(fs, arguments);
-        }
-        impl.link(context, oldpath, newpath, complete);
-      }
-    );
-    if(error) callback(error);
-  };
-  FileSystem.prototype.unlink = function(path, callback) {
-    callback = maybeCallback(callback);
-    var fs = this;
-    var error = fs.queueOrRun(
-      function() {
-        var context = fs.provider.openReadWriteContext();
-        function complete() {
-          context.close();
-          callback.apply(fs, arguments);
-        }
-        impl.unlink(context, path, complete);
-      }
-    );
-    if(error) callback(error);
-  };
-  FileSystem.prototype.read = function(fd, buffer, offset, length, position, callback) {
-    // Follow how node.js does this
-    callback = maybeCallback(callback);
-    function wrapper(err, bytesRead) {
-      // Retain a reference to buffer so that it can't be GC'ed too soon.
-      callback(err, bytesRead || 0, buffer);
-    }
-    var fs = this;
-    var error = fs.queueOrRun(
-      function() {
-        var context = fs.provider.openReadWriteContext();
-        function complete() {
-          context.close();
-          wrapper.apply(this, arguments);
-        }
-        impl.read(fs, context, fd, buffer, offset, length, position, complete);
-      }
-    );
-    if(error) callback(error);
-  };
-  FileSystem.prototype.readFile = function(path, options, callback_) {
-    var callback = maybeCallback(arguments[arguments.length - 1]);
-    var fs = this;
-    var error = fs.queueOrRun(
-      function() {
-        var context = fs.provider.openReadWriteContext();
-        function complete() {
-          context.close();
-          callback.apply(fs, arguments);
-        }
-        impl.readFile(fs, context, path, options, complete);
-      }
-    );
-    if(error) callback(error);
-  };
-  FileSystem.prototype.write = function(fd, buffer, offset, length, position, callback) {
-    callback = maybeCallback(callback);
-    var fs = this;
-    var error = fs.queueOrRun(
-      function() {
-        var context = fs.provider.openReadWriteContext();
-        function complete() {
-          context.close();
-          callback.apply(fs, arguments);
-        }
-        impl.write(fs, context, fd, buffer, offset, length, position, complete);
-      }
-    );
-    if(error) callback(error);
-  };
-  FileSystem.prototype.writeFile = function(path, data, options, callback_) {
-    var callback = maybeCallback(arguments[arguments.length - 1]);
-    var fs = this;
-    var error = fs.queueOrRun(
-      function() {
-        var context = fs.provider.openReadWriteContext();
-        function complete() {
-          context.close();
-          callback.apply(fs, arguments);
-        }
-        impl.writeFile(fs, context, path, data, options, complete);
-      }
-    );
-    if(error) callback(error);
-  };
-  FileSystem.prototype.appendFile = function(path, data, options, callback_) {
-    var callback = maybeCallback(arguments[arguments.length - 1]);
-    var fs = this;
-    var error = fs.queueOrRun(
-      function() {
-        var context = fs.provider.openReadWriteContext();
-        function complete() {
-          context.close();
-          callback.apply(fs, arguments);
-        }
-        impl.appendFile(fs, context, path, data, options, complete);
-      }
-    );
-    if(error) callback(error);
-  };
-  FileSystem.prototype.exists = function(path, callback_) {
-    var callback = maybeCallback(arguments[arguments.length - 1]);
-    var fs = this;
-    var error = fs.queueOrRun(
-      function() {
-        var context = fs.provider.openReadWriteContext();
-        function complete() {
-          context.close();
-          callback.apply(fs, arguments);
-        }
-        impl.exists(context, fs.name, path, complete);
-      }
-    );
-    if(error) callback(error);
-  };
-  FileSystem.prototype.lseek = function(fd, offset, whence, callback) {
-    callback = maybeCallback(callback);
-    var fs = this;
-    var error = fs.queueOrRun(
-      function() {
-        var context = fs.provider.openReadWriteContext();
-        function complete() {
-          context.close();
-          callback.apply(fs, arguments);
-        }
-        impl.lseek(fs, context, fd, offset, whence, complete);
-      }
-    );
-    if(error) callback(error);
-  };
-  FileSystem.prototype.readdir = function(path, callback) {
-    callback = maybeCallback(callback);
-    var fs = this;
-    var error = fs.queueOrRun(
-      function() {
-        var context = fs.provider.openReadWriteContext();
-        function complete() {
-          context.close();
-          callback.apply(fs, arguments);
-        }
-        impl.readdir(context, path, complete);
-      }
-    );
-    if(error) callback(error);
-  };
-  FileSystem.prototype.rename = function(oldpath, newpath, callback) {
-    callback = maybeCallback(callback);
-    var fs = this;
-    var error = fs.queueOrRun(
-      function() {
-        var context = fs.provider.openReadWriteContext();
-        function complete() {
-          context.close();
-          callback.apply(fs, arguments);
-        }
-        impl.rename(context, oldpath, newpath, complete);
-      }
-    );
-    if(error) callback(error);
-  };
-  FileSystem.prototype.readlink = function(path, callback) {
-    callback = maybeCallback(callback);
-    var fs = this;
-    var error = fs.queueOrRun(
-      function() {
-        var context = fs.provider.openReadWriteContext();
-        function complete() {
-          context.close();
-          callback.apply(fs, arguments);
-        }
-        impl.readlink(context, path, complete);
-      }
-    );
-    if(error) callback(error);
-  };
-  FileSystem.prototype.symlink = function(srcpath, dstpath, type, callback_) {
-    // Follow node.js in allowing the `type` arg to be passed, but we ignore it.
-    var callback = maybeCallback(arguments[arguments.length - 1]);
-    var fs = this;
-    var error = fs.queueOrRun(
-      function() {
-        var context = fs.provider.openReadWriteContext();
-        function complete() {
-          context.close();
-          callback.apply(fs, arguments);
-        }
-        impl.symlink(context, srcpath, dstpath, complete);
-      }
-    );
-    if(error) callback(error);
-  };
-  FileSystem.prototype.lstat = function(path, callback) {
-    callback = maybeCallback(callback);
-    var fs = this;
-    var error = fs.queueOrRun(
-      function() {
-        var context = fs.provider.openReadWriteContext();
-        function complete() {
-          context.close();
-          callback.apply(fs, arguments);
-        }
-        impl.lstat(fs, context, path, complete);
-      }
-    );
-    if(error) callback(error);
-  };
-  FileSystem.prototype.truncate = function(path, length, callback) {
-    // Follow node.js in allowing the `length` to be optional
-    if(typeof length === 'function') {
-      callback = length;
-      length = 0;
-    }
-    callback = maybeCallback(callback);
-    length = typeof length === 'number' ? length : 0;
-    var fs = this;
-    var error = fs.queueOrRun(
-      function() {
-        var context = fs.provider.openReadWriteContext();
-        function complete() {
-          context.close();
-          callback.apply(fs, arguments);
-        }
-        impl.truncate(context, path, length, complete);
-      }
-    );
-    if(error) callback(error);
-  };
-  FileSystem.prototype.ftruncate = function(fd, length, callback) {
-    callback = maybeCallback(callback);
-    var fs = this;
-    var error = fs.queueOrRun(
-      function() {
-        var context = fs.provider.openReadWriteContext();
-        function complete() {
-          context.close();
-          callback.apply(fs, arguments);
-        }
-        impl.ftruncate(fs, context, fd, length, complete);
-      }
-    );
-    if(error) callback(error);
-  };
-  FileSystem.prototype.utimes = function(path, atime, mtime, callback) {
-    callback = maybeCallback(callback);
-    var fs = this;
-    var error = fs.queueOrRun(
-      function () {
-        var context = fs.provider.openReadWriteContext();
-        function complete() {
-          context.close();
-          callback.apply(fs, arguments);
-        }
-        impl.utimes(context, path, atime, mtime, complete);
-      }
-    );
-    if (error) {
-      callback(error);
-    }
-  };
-  FileSystem.prototype.futimes = function(fd, atime, mtime, callback) {
-    callback = maybeCallback(callback);
-    var fs = this;
-    var error = fs.queueOrRun(
-      function () {
-        var context = fs.provider.openReadWriteContext();
-        function complete() {
-          context.close();
-          callback.apply(fs, arguments);
-        }
-        impl.futimes(fs, context, fd, atime, mtime, complete);
-      }
-    );
-    if (error) {
-      callback(error);
-    }
-  };
-  FileSystem.prototype.setxattr = function (path, name, value, flag, callback) {
-    callback = maybeCallback(arguments[arguments.length - 1]);
-    var _flag = (typeof flag != 'function') ? flag : null;
-    var fs = this;
-    var error = fs.queueOrRun(
-      function () {
-        var context = fs.provider.openReadWriteContext();
-        function complete() {
-          context.close();
-          callback.apply(fs, arguments);
-        }
-        impl.setxattr(context, path, name, value, _flag, complete);
-      }
-    );
-    if (error) {
-      callback(error);
-    }
-  };
-  FileSystem.prototype.getxattr = function (path, name, callback) {
-    callback = maybeCallback(callback);
-    var fs = this;
-    var error = fs.queueOrRun(
-      function () {
-        var context = fs.provider.openReadWriteContext();
-        function complete() {
-          context.close();
-          callback.apply(fs, arguments);
-        }
-        impl.getxattr(context, path, name, complete);
-      }
-    );
-    if (error) {
-      callback(error);
-    }
-  };
-  FileSystem.prototype.fsetxattr = function (fd, name, value, flag, callback) {
-    callback = maybeCallback(arguments[arguments.length - 1]);
-    var _flag = (typeof flag != 'function') ? flag : null;
-    var fs = this;
-    var error = fs.queueOrRun(
-      function () {
-        var context = fs.provider.openReadWriteContext();
-        function complete() {
-          context.close();
-          callback.apply(fs, arguments);
-        }
-        impl.fsetxattr(fs, context, fd, name, value, _flag, complete);
-      }
-    );
-    if (error) {
-      callback(error);
-    }
-  };
-  FileSystem.prototype.fgetxattr = function (fd, name, callback) {
-    callback = maybeCallback(callback);
-    var fs = this;
-    var error = fs.queueOrRun(
-      function () {
-        var context = fs.provider.openReadWriteContext();
-        function complete() {
-          context.close();
-          callback.apply(fs, arguments);
-        }
-        impl.fgetxattr(fs, context, fd, name, complete);
-      }
-    );
-    if (error) {
-      callback(error);
-    }
-  };
-  FileSystem.prototype.removexattr = function (path, name, callback) {
-    callback = maybeCallback(callback);
-    var fs = this;
-    var error = fs.queueOrRun(
-      function () {
-        var context = fs.provider.openReadWriteContext();
-        function complete() {
-          context.close();
-          callback.apply(fs, arguments);
-        }
-        impl.removexattr(context, path, name, complete);
-      }
-    );
-    if (error) {
-      callback(error);
-    }
-  };
-  FileSystem.prototype.fremovexattr = function (fd, name, callback) {
-    callback = maybeCallback(callback);
-    var fs = this;
-    var error = fs.queueOrRun(
-      function () {
-        var context = fs.provider.openReadWriteContext();
-        function complete() {
-          context.close();
-          callback.apply(fs, arguments);
-        }
-        impl.fremovexattr(fs, context, fd, name, complete);
-      }
-    );
       if(error) {
         callback(error);
       }
     };
+  });
+
   FileSystem.prototype.Shell = function(options) {
     return new Shell(this, options);
   };