Implement jest-haste-map instead of node-haste

Author: cpojer

package.json

@@ -11,14 +11,14 @@
     "istanbul": "^0.4.2",
     "jest-environment-jsdom": "^11.0.1",
     "jest-environment-node": "^11.0.1",
+    "jest-haste-map": "^11.0.0",
     "jest-jasmine1": "^11.0.1",
     "jest-jasmine2": "^11.0.1",
     "jest-mock": "^11.0.1",
     "jest-util": "^11.0.1",
     "json-stable-stringify": "^1.0.0",
     "lodash.template": "^4.2.4",
     "mkdirp": "^0.5.1",
-    "node-haste": "^2.5.0",
     "optimist": "^0.6.1",
     "resolve": "^1.1.6",
     "sane": "^1.2.0",

packages/jest-haste-map/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "jest-haste-map",
+  "version": "11.0.0",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/facebook/jest.git"
+  },
+  "license": "BSD-3-Clause",
+  "main": "src/index.js",
+  "dependencies": {
+    "denodeify": "^1.2.1",
+    "fb-watchman": "^1.9.0",
+    "graceful-fs": "^4.1.3",
+    "node-glob": "^1.2.0"
+  },
+  "jest": {
+    "unmockedModulePathPatterns": [
+      "denodeify"
+    ]
+  },
+  "scripts": {
+    "prepublish": "npm test",
+    "test": "node -e \"const spawn = require('child_process').spawn, path=require('path'); spawn('node', [path.resolve('../../bin/jest.js')], {stdio:'inherit'})\""
+  }
+}

packages/jest-haste-map/src/__mocks__/fs.js

@@ -0,0 +1,11 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+'use strict';
+
+module.exports = require('graceful-fs');

packages/jest-haste-map/src/__mocks__/graceful-fs.js

@@ -0,0 +1,211 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+'use strict';
+
+const fs = jest.genMockFromModule('fs');
+const noop = () => {};
+
+function asyncCallback(cb) {
+  return function() {
+    setImmediate(() => cb.apply(this, arguments));
+  };
+}
+
+const mtime = {
+  getTime: () => Math.ceil(Math.random() * 10000000),
+};
+
+fs.realpath.mockImpl((filepath, callback) => {
+  callback = asyncCallback(callback);
+  let node;
+  try {
+    node = getToNode(filepath);
+  } catch (e) {
+    return callback(e);
+  }
+  if (node && typeof node === 'object' && node.SYMLINK != null) {
+    return callback(null, node.SYMLINK);
+  }
+  callback(null, filepath);
+});
+
+fs.readdirSync.mockImpl(filepath => Object.keys(getToNode(filepath)));
+
+fs.readdir.mockImpl((filepath, callback) => {
+  callback = asyncCallback(callback);
+  let node;
+  try {
+    node = getToNode(filepath);
+    if (node && typeof node === 'object' && node.SYMLINK != null) {
+      node = getToNode(node.SYMLINK);
+    }
+  } catch (e) {
+    return callback(e);
+  }
+
+  if (!(node && typeof node === 'object' && node.SYMLINK == null)) {
+    return callback(new Error(filepath + ' is not a directory.'));
+  }
+
+  callback(null, Object.keys(node));
+});
+
+fs.readFile.mockImpl(function(filepath, encoding, callback) {
+  callback = asyncCallback(callback);
+  if (arguments.length === 2) {
+    callback = encoding;
+    encoding = null;
+  }
+
+  let node;
+  try {
+    node = getToNode(filepath);
+    // dir check
+    if (node && typeof node === 'object' && node.SYMLINK == null) {
+      callback(new Error('Error readFile a dir: ' + filepath));
+    }
+    return callback(null, node);
+  } catch (e) {
+    return callback(e);
+  }
+});
+
+fs.stat.mockImpl((filepath, callback) => {
+  callback = asyncCallback(callback);
+  let node;
+  try {
+    node = getToNode(filepath);
+  } catch (e) {
+    callback(e);
+    return;
+  }
+
+  if (node.SYMLINK) {
+    fs.stat(node.SYMLINK, callback);
+    return;
+  }
+
+  if (node && typeof node === 'object') {
+    callback(null, {
+      isDirectory: () => true,
+      isSymbolicLink: () => false,
+      mtime,
+    });
+  } else {
+    callback(null, {
+      isDirectory: () => false,
+      isSymbolicLink: () => false,
+      mtime,
+    });
+  }
+});
+
+fs.statSync.mockImpl(filepath => {
+  const node = getToNode(filepath);
+
+  if (node.SYMLINK) {
+    return fs.statSync(node.SYMLINK);
+  }
+
+  return {
+    isDirectory: () => node && typeof node === 'object',
+    isSymbolicLink: () => false,
+    mtime,
+  };
+});
+
+fs.lstatSync.mockImpl(filepath => {
+  const node = getToNode(filepath);
+
+  if (node.SYMLINK) {
+    return {
+      isDirectory: () => false,
+      isSymbolicLink: () => true,
+      mtime,
+    };
+  }
+
+  return {
+    isDirectory: () => node && typeof node === 'object',
+    isSymbolicLink: () => false,
+    mtime,
+  };
+});
+
+fs.open.mockImpl(function(path) {
+  const callback = arguments[arguments.length - 1] || noop;
+  let data, error, fd;
+  try {
+    data = getToNode(path);
+  } catch (e) {
+    error = e;
+  }
+
+  if (error || data == null) {
+    error = Error(`ENOENT: no such file or directory, open ${path}`);
+  }
+  if (data != null) {
+    /* global Buffer: true */
+    fd = {buffer: new Buffer(data, 'utf8'), position: 0};
+  }
+
+  callback(error, fd);
+});
+
+fs.read.mockImpl((fd, buffer, writeOffset, length, position, callback = noop) => {
+  let bytesWritten;
+  try {
+    if (position == null || position < 0) {
+      ({position} = fd);
+    }
+    bytesWritten = fd.buffer.copy(buffer, writeOffset, position, position + length);
+    fd.position = position + bytesWritten;
+  } catch (e) {
+    callback(Error('invalid argument'));
+    return;
+  }
+  callback(null, bytesWritten, buffer);
+});
+
+fs.close.mockImpl((fd, callback = noop) => {
+  try {
+    fd.buffer = fs.position = undefined;
+  } catch (e) {
+    callback(Error('invalid argument'));
+    return;
+  }
+  callback(null);
+});
+
+let filesystem;
+
+fs.__setMockFilesystem = object => filesystem = object;
+
+function getToNode(filepath) {
+  // Ignore the drive for Windows paths.
+  if (filepath.match(/^[a-zA-Z]:\\/)) {
+    filepath = filepath.substring(2);
+  }
+
+  const parts = filepath.split(/[\/\\]/);
+  if (parts[0] !== '') {
+    throw new Error('Make sure all paths are absolute.');
+  }
+  let node = filesystem;
+  parts.slice(1).forEach(part => {
+    if (node && node.SYMLINK) {
+      node = getToNode(node.SYMLINK);
+    }
+    node = node[part];
+  });
+
+  return node;
+}
+
+module.exports = fs;