Don’t post-process HasteMap and remove one caching layer.

Runtime now directly operates with the data structure from the HasteMap. Workers now read directly from `jest-haste-map`’s cache.

Author: cpojer

packages/jest-haste-map/src/index.js

@@ -73,12 +73,19 @@ class HasteMap {
   build() {
     if (!this._buildPromise) {
       this._buildPromise = this._buildFileMap()
-        .then(data => this._buildHasteMap(data))
-        .then(data => this._persist(data));
+        .then(data => this._buildHasteMap(data));
     }
     return this._buildPromise;
   }
 
+  persist(data) {
+    return writeFile(this._cachePath, JSON.stringify(data)).then(() => data);
+  }
+
+  read() {
+    return this._parse(fs.readFileSync(this._cachePath, 'utf-8'));
+  }
+
   matchFiles(pattern) {
     if (!(pattern instanceof RegExp)) {
       pattern = new RegExp(pattern);
@@ -95,11 +102,10 @@ class HasteMap {
   }
 
   _buildFileMap() {
-    const dataPromise = this._options.resetCache
-      ? Promise.resolve(this._createEmptyMap())
-      : readFile(this._cachePath, 'utf-8').then(data => this._parse(data));
+    const read = this._options.resetCache ? this._createEmptyMap : this.read;
 
-    return dataPromise
+    return Promise.resolve()
+      .then(() => read.call(this))
       .catch(() => this._createEmptyMap())
       .then(data => this._crawl(data));
   }
@@ -159,17 +165,12 @@ class HasteMap {
 
   _parse(data) {
     data = JSON.parse(data);
-    Object.setPrototypeOf(data.clocks, null);
-    Object.setPrototypeOf(data.files, null);
-    Object.setPrototypeOf(data.map, null);
+    for (const key in data) {
+      Object.setPrototypeOf(data[key], null);
+    }
     return data;
   }
 
-  _persist(data) {
-    return writeFile(this._cachePath, JSON.stringify(data))
-      .then(() => data);
-  }
-
   _crawl(data) {
     const crawl =
       (canUseWatchman && this._options.useWatchman) ? watchmanCrawl : nodeCrawl;

src/Runtime/Runtime.js

@@ -8,6 +8,8 @@
 
 'use strict';
 
+const HasteMap = require('jest-haste-map');
+
 const constants = require('../constants');
 const fs = require('graceful-fs');
 const moduleMocker = require('jest-mock');
@@ -43,9 +45,9 @@ class Runtime {
 
     this._shouldAutoMock = config.automock;
     this._extensions = config.moduleFileExtensions.map(ext => '.' + ext);
+    this._defaultPlatform = config.haste.defaultPlatform;
 
-    this._modules = moduleMap.modules;
-    this._packages = moduleMap.packages;
+    this._modules = moduleMap.map;
     this._mocks = moduleMap.mocks;
 
     if (config.collectCoverage) {
@@ -437,12 +439,25 @@ class Runtime {
     );
   }
 
-  _getModule(name) {
-    return this._modules[name];
+  _getModule(name, type) {
+    if (!type) {
+      type = 'module';
+    }
+
+    const map = this._modules[name];
+    if (map) {
+      const module =
+        map[this._defaultPlatform] || map[HasteMap.GENERIC_PLATFORM];
+      if (module && module.type == type) {
+        return module.path;
+      }
+    }
+
+    return null;
   }
 
   _getPackage(name) {
-    return this._packages[name];
+    return this._getModule(name, 'package');
   }
 
   _getMockModule(name) {

src/TestRunner.js

@@ -12,7 +12,6 @@ const Test = require('./Test');
 
 const fs = require('graceful-fs');
 const getCacheFilePath = require('jest-haste-map').getCacheFilePath;
-const getCacheKey = require('./lib/getCacheKey');
 const mkdirp = require('mkdirp');
 const path = require('path');
 const promisify = require('./lib/promisify');
@@ -391,18 +390,9 @@ class TestRunner {
     );
   }
 
-  _persistModuleMap(moduleMap) {
-    const cacheFile = getCacheFilePath(
-      this._config.cacheDirectory,
-      getCacheKey('jest-module-map', this._config)
-    );
-    return promisify(fs.writeFile)(cacheFile, JSON.stringify(moduleMap));
-  }
-
   _createParallelTestRun(testPaths, onTestResult, onRunFailure) {
     const config = this._config;
     return this._resolver.getHasteMap()
-      .then(moduleMap => this._persistModuleMap(moduleMap))
       .then(() => {
         const farm = workerFarm({
           autoStart: true,

src/TestWorker.js

@@ -15,9 +15,7 @@ process.on('uncaughtException', err => {
 
 const Test = require('./Test');
 
-const fs = require('graceful-fs');
-const getCacheFilePath = require('jest-haste-map').getCacheFilePath;
-const getCacheKey = require('./lib/getCacheKey');
+const createHasteMap = require('./lib/createHasteMap');
 
 const formatError = error => {
   if (typeof error === 'string') {
@@ -40,11 +38,7 @@ let moduleMap;
 module.exports = (data, callback) => {
   try {
     if (!moduleMap) {
-      const cacheFile = getCacheFilePath(
-        data.config.cacheDirectory,
-        getCacheKey('jest-module-map', data.config)
-      );
-      moduleMap = JSON.parse(fs.readFileSync(cacheFile));
+      moduleMap = createHasteMap(data.config).read();
     }
 
     new Test(data.path, data.config, moduleMap)

src/lib/createHasteMap.js

@@ -0,0 +1,31 @@
+/**
+ * Copyright (c) 2014-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 HasteMap = require('jest-haste-map');
+
+module.exports = function createHasteMap(config, options) {
+  const extensions = Array.from(new Set(
+    config.moduleFileExtensions.concat(config.testFileExtensions)
+  ));
+  const ignorePattern = new RegExp(
+    [config.cacheDirectory].concat(config.modulePathIgnorePatterns).join('|')
+  );
+
+  return new HasteMap({
+    cacheDirectory: config.cacheDirectory,
+    extensions,
+    ignorePattern,
+    providesModuleNodeModules: config.haste.providesModuleNodeModules,
+    platforms: config.haste.platforms || ['ios', 'android'],
+    resetCache: options && options.resetCache,
+    roots: config.testPathDirs,
+    useWatchman: config.watchman,
+  });
+};

src/resolvers/HasteResolver.js

@@ -8,8 +8,7 @@
 
 'use strict';
 
-const HasteMap = require('jest-haste-map');
-
+const createHasteMap = require('../lib/createHasteMap');
 const path = require('path');
 
 /* eslint-disable max-len */
@@ -19,36 +18,23 @@ const REQUIRE_EXTENSIONS_PATTERN = /(\b(?:require\s*?\.\s*?(?:requireActual|requ
 class HasteResolver {
 
   constructor(config, options) {
-    const extensions = Array.from(new Set(
-      config.moduleFileExtensions.concat(config.testFileExtensions)
-    ));
-    const ignorePattern = new RegExp(
-      [config.cacheDirectory].concat(config.modulePathIgnorePatterns).join('|')
-    );
-
+    this._map = createHasteMap(config, options);
     this._defaultPlatform = config.haste.defaultPlatform;
     this._mocksPattern = new RegExp(config.mocksPattern);
-
     this._mappedModuleNames = Object.create(null);
     if (config.moduleNameMapper.length) {
       config.moduleNameMapper.forEach(
         map => this._mappedModuleNames[map[1]] = new RegExp(map[0])
       );
     }
 
-    this._map = new HasteMap({
-      cacheDirectory: options.cacheDirectory,
-      extensions,
-      ignorePattern,
-      providesModuleNodeModules: config.haste.providesModuleNodeModules,
-      platforms: config.haste.platforms || ['ios', 'android'],
-      resetCache: options.resetCache,
-      roots: config.testPathDirs,
-      useWatchman: config.watchman,
-    });
-
-    // warm-up
-    this._map.build();
+    // warm-up and cache mocks
+    this._hasteMapPromise = this._map.build().then(data =>
+      this._getAllMocks().then(mocks => {
+        data.mocks = mocks;
+        return this._map.persist(data);
+      })
+    );
 
     /*extractRequires: code => {
       const data = HasteMap.extractRequires(code);
@@ -84,32 +70,7 @@ class HasteResolver {
   }
 
   getHasteMap() {
-    if (this._mapPromise) {
-      return this._mapPromise;
-    }
-
-    return this._mapPromise = Promise.all([
-      this._map.build(),
-      this._getAllMocks(),
-    ]).then(data => this._getModuleMap(data[0].map, data[1]));
-  }
-
-  _getModuleMap(map, mocks) {
-    const modules = Object.create(null);
-    const packages = Object.create(null);
-    for (const name in map) {
-      const module =
-        map[name][this._defaultPlatform] ||
-        map[name][HasteMap.GENERIC_PLATFORM];
-      if (module) {
-        if (module.type == 'package') {
-          packages[name] = module.path;
-        } else {
-          modules[name] = module.path;
-        }
-      }
-    }
-    return {modules, mocks, packages};
+    return this._hasteMapPromise;
   }
 
   _getAllMocks() {