Izmjenjena struktura, dodan backand

web/node_modules/jest-runtime/build/ScriptTransformer.js

@@ -0,0 +1,415 @@
+'use strict'; /**
+               * 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.
+               *
+               * 
+               */
+
+
+
+
+
+
+
+
+const crypto = require('crypto');
+const path = require('path');
+const vm = require('vm');var _require =
+require('jest-util');const createDirectory = _require.createDirectory;
+const fs = require('graceful-fs');var _require2 =
+require('jest-haste-map');const getCacheFilePath = _require2.getCacheFilePath;
+const stableStringify = require('json-stable-stringify');
+const slash = require('slash');
+
+const VERSION = require('../package.json').version;
+const shouldInstrument = require('./shouldInstrument');
+
+
+
+
+
+
+
+
+
+const cache = new Map();
+const configToJsonMap = new Map();
+// Cache regular expressions to test whether the file needs to be preprocessed
+const ignoreCache = new WeakMap();
+
+class ScriptTransformer {
+
+
+
+
+  constructor(config) {
+    this._config = config;
+    this._transformCache = new Map();
+  }
+
+  _getCacheKey(
+  fileData,
+  filename,
+  instrument,
+  mapCoverage)
+  {
+    if (!configToJsonMap.has(this._config)) {
+      // We only need this set of config options that can likely influence
+      // cached output instead of all config options.
+      configToJsonMap.set(this._config, stableStringify(this._config));
+    }
+    const configString = configToJsonMap.get(this._config) || '';
+    const transformer = this._getTransformer(filename, this._config);
+
+    if (transformer && typeof transformer.getCacheKey === 'function') {
+      return transformer.getCacheKey(fileData, filename, configString, {
+        instrument });
+
+    } else {
+      return crypto.
+      createHash('md5').
+      update(fileData).
+      update(configString).
+      update(instrument ? 'instrument' : '').
+      update(mapCoverage ? 'mapCoverage' : '').
+      digest('hex');
+    }
+  }
+
+  _getFileCachePath(
+  filename,
+  content,
+  instrument,
+  mapCoverage)
+  {
+    const baseCacheDir = getCacheFilePath(
+    this._config.cacheDirectory,
+    'jest-transform-cache-' + this._config.name,
+    VERSION);
+
+    const cacheKey = this._getCacheKey(
+    content,
+    filename,
+    instrument,
+    mapCoverage);
+
+    // Create sub folders based on the cacheKey to avoid creating one
+    // directory with many files.
+    const cacheDir = path.join(baseCacheDir, cacheKey[0] + cacheKey[1]);
+    const cachePath = slash(
+    path.join(
+    cacheDir,
+    path.basename(filename, path.extname(filename)) + '_' + cacheKey));
+
+
+    createDirectory(cacheDir);
+
+    return cachePath;
+  }
+
+  _getTransformPath(filename) {
+    for (let i = 0; i < this._config.transform.length; i++) {
+      if (new RegExp(this._config.transform[i][0]).test(filename)) {
+        return this._config.transform[i][1];
+      }
+    }
+    return null;
+  }
+
+  _getTransformer(filename) {
+    let transform;
+    if (!this._config.transform || !this._config.transform.length) {
+      return null;
+    }
+
+    const transformPath = this._getTransformPath(filename);
+    if (transformPath) {
+      const transformer = this._transformCache.get(transformPath);
+      if (transformer != null) {
+        return transformer;
+      }
+
+      // $FlowFixMe
+      transform = require(transformPath);
+      if (typeof transform.process !== 'function') {
+        throw new TypeError(
+        'Jest: a transform must export a `process` function.');
+
+      }
+      if (typeof transform.createTransformer === 'function') {
+        transform = transform.createTransformer();
+      }
+      this._transformCache.set(transformPath, transform);
+    }
+    return transform;
+  }
+
+  _instrumentFile(filename, content) {
+    // Keeping these requires inside this function reduces a single run
+    // time by 2sec if not running in `--coverage` mode
+    const babel = require('babel-core');
+    const babelPluginIstanbul = require('babel-plugin-istanbul').default;
+
+    return babel.transform(content, {
+      auxiliaryCommentBefore: ' istanbul ignore next ',
+      babelrc: false,
+      filename,
+      plugins: [
+      [
+      babelPluginIstanbul,
+      {
+        // files outside `cwd` will not be instrumented
+        cwd: this._config.rootDir,
+        exclude: [],
+        useInlineSourceMaps: false }]],
+
+
+
+      retainLines: true }).
+    code;
+  }
+
+  transformSource(
+  filename,
+  content,
+  instrument,
+  mapCoverage)
+  {
+    const transform = this._getTransformer(filename);
+    const cacheFilePath = this._getFileCachePath(
+    filename,
+    content,
+    instrument,
+    mapCoverage);
+
+    let sourceMapPath = cacheFilePath + '.map';
+    // Ignore cache if `config.cache` is set (--no-cache)
+    let code = this._config.cache ?
+    readCacheFile(filename, cacheFilePath) :
+    null;
+
+    if (code) {
+      return {
+        code,
+        sourceMapPath };
+
+    }
+
+    let transformed = {
+      code: content,
+      map: null };
+
+
+    if (transform && shouldTransform(filename, this._config)) {
+      const processed = transform.process(content, filename, this._config, {
+        instrument });
+
+
+      if (typeof processed === 'string') {
+        transformed.code = processed;
+      } else {
+        transformed = processed;
+      }
+    }
+
+    if (mapCoverage) {
+      if (!transformed.map) {
+        const convert = require('convert-source-map');
+        const inlineSourceMap = convert.fromSource(transformed.code);
+        if (inlineSourceMap) {
+          transformed.map = inlineSourceMap.toJSON();
+        }
+      }
+    } else {
+      transformed.map = null;
+    }
+
+    // That means that the transform has a custom instrumentation
+    // logic and will handle it based on `config.collectCoverage` option
+    const transformDidInstrument = transform && transform.canInstrument;
+
+    if (!transformDidInstrument && instrument) {
+      code = this._instrumentFile(filename, transformed.code);
+    } else {
+      code = transformed.code;
+    }
+
+    if (instrument && transformed.map && mapCoverage) {
+      const sourceMapContent = typeof transformed.map === 'string' ?
+      transformed.map :
+      JSON.stringify(transformed.map);
+      writeCacheFile(sourceMapPath, sourceMapContent);
+    } else {
+      sourceMapPath = null;
+    }
+
+    writeCacheFile(cacheFilePath, code);
+
+    return {
+      code,
+      sourceMapPath };
+
+  }
+
+  _transformAndBuildScript(
+  filename,
+  options,
+  instrument,
+  fileSource)
+  {
+    const isInternalModule = !!(options && options.isInternalModule);
+    const content = stripShebang(
+    fileSource || fs.readFileSync(filename, 'utf8'));
+
+    let wrappedCode;
+    let sourceMapPath = null;
+    const willTransform =
+    !isInternalModule && (
+    shouldTransform(filename, this._config) || instrument);
+
+    try {
+      if (willTransform) {
+        const transformedSource = this.transformSource(
+        filename,
+        content,
+        instrument,
+        !!(options && options.mapCoverage));
+
+
+        wrappedCode = wrap(transformedSource.code);
+        sourceMapPath = transformedSource.sourceMapPath;
+      } else {
+        wrappedCode = wrap(content);
+      }
+
+      return {
+        script: new vm.Script(wrappedCode, { displayErrors: true, filename }),
+        sourceMapPath };
+
+    } catch (e) {
+      if (e.codeFrame) {
+        e.stack = e.codeFrame;
+      }
+
+      throw e;
+    }
+  }
+
+  transform(
+  filename,
+  options,
+  fileSource)
+  {
+    const instrument = shouldInstrument(filename, options, this._config);
+    const scriptCacheKey = getScriptCacheKey(
+    filename,
+    this._config,
+    instrument);
+
+    let result = cache.get(scriptCacheKey);
+    if (result) {
+      return result;
+    } else {
+      result = this._transformAndBuildScript(
+      filename,
+      options,
+      instrument,
+      fileSource);
+
+      cache.set(scriptCacheKey, result);
+      return result;
+    }
+  }}
+
+
+const removeFile = path => {
+  try {
+    fs.unlinkSync(path);
+  } catch (e) {}
+};
+
+const stripShebang = content => {
+  // If the file data starts with a shebang remove it. Leaves the empty line
+  // to keep stack trace line numbers correct.
+  if (content.startsWith('#!')) {
+    return content.replace(/^#!.*/, '');
+  } else {
+    return content;
+  }
+};
+
+const writeCacheFile = (cachePath, fileData) => {
+  try {
+    fs.writeFileSync(cachePath, fileData, 'utf8');
+  } catch (e) {
+    e.message =
+    'jest: failed to cache transform results in: ' +
+    cachePath +
+    '\nFailure message: ' +
+    e.message;
+    removeFile(cachePath);
+    throw e;
+  }
+};
+
+const readCacheFile = (filename, cachePath) => {
+  if (!fs.existsSync(cachePath)) {
+    return null;
+  }
+
+  let fileData;
+  try {
+    fileData = fs.readFileSync(cachePath, 'utf8');
+  } catch (e) {
+    e.message = 'jest: failed to read cache file: ' + cachePath;
+    removeFile(cachePath);
+    throw e;
+  }
+
+  if (fileData == null) {
+    // We must have somehow created the file but failed to write to it,
+    // let's delete it and retry.
+    removeFile(cachePath);
+  }
+  return fileData;
+};
+
+const getScriptCacheKey = (filename, config, instrument) => {
+  const mtime = fs.statSync(filename).mtime;
+  return filename + '_' + mtime.getTime() + (instrument ? '_instrumented' : '');
+};
+
+const shouldTransform = (filename, config) => {
+  if (!ignoreCache.has(config)) {
+    if (!config.transformIgnorePatterns) {
+      ignoreCache.set(config, null);
+    } else {
+      ignoreCache.set(
+      config,
+      new RegExp(config.transformIgnorePatterns.join('|')));
+
+    }
+  }
+
+  const ignoreRegexp = ignoreCache.get(config);
+  const isIgnored = ignoreRegexp ? ignoreRegexp.test(filename) : false;
+  return (
+    !!config.transform &&
+    !!config.transform.length && (
+    !config.transformIgnorePatterns.length || !isIgnored));
+
+};
+
+const wrap = content =>
+'({"' +
+ScriptTransformer.EVAL_RESULT_VARIABLE +
+'":function(module,exports,require,__dirname,__filename,global,jest){' +
+content +
+'\n}});';
+
+ScriptTransformer.EVAL_RESULT_VARIABLE = 'Object.<anonymous>';
+
+module.exports = ScriptTransformer;

web/node_modules/jest-runtime/build/cli/args.js

@@ -0,0 +1,44 @@
+'use strict'; /**
+               * Copyright (c) 2014, 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.
+               *
+               * 
+               */
+
+const usage = 'Usage: $0 [--config=<pathToConfigFile>] <file>';
+
+const options = {
+  cache: {
+    default: true,
+    description: 'Whether to use the preprocessor cache. Disable ' +
+    'the cache using --no-cache.',
+    type: 'boolean' },
+
+  config: {
+    alias: 'c',
+    description: 'The path to a Jest config file.',
+    type: 'string' },
+
+  debug: {
+    description: 'Print debugging info about your jest config.',
+    type: 'boolean' },
+
+  version: {
+    alias: 'v',
+    description: 'Print the version and exit',
+    type: 'boolean' },
+
+  watchman: {
+    default: true,
+    description: 'Whether to use watchman for file crawling. Disable using ' +
+    '--no-watchman.',
+    type: 'boolean' } };
+
+
+
+module.exports = {
+  options,
+  usage };

web/node_modules/jest-runtime/build/cli/index.js

@@ -0,0 +1,91 @@
+'use strict'; /**
+              * Copyright (c) 2014, 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.
+              *
+              * 
+              */
+
+
+
+
+const os = require('os');
+const path = require('path');
+const chalk = require('chalk');
+const yargs = require('yargs');var _require =
+
+require('jest-util');const Console = _require.Console,setGlobal = _require.setGlobal,validateCLIOptions = _require.validateCLIOptions;var _require2 =
+require('jest-config');const readConfig = _require2.readConfig;
+const VERSION = require('../../package.json').version;
+const Runtime = require('../');
+const args = require('./args');
+
+function run(cliArgv, cliInfo) {
+  let argv;
+  if (cliArgv) {
+    argv = cliArgv;
+  } else {
+    argv = yargs.usage(args.usage).options(args.options).argv;
+
+    validateCLIOptions(argv, args.options);
+  }
+
+  if (argv.help) {
+    yargs.showHelp();
+    process.on('exit', () => process.exit(1));
+    return;
+  }
+
+  if (argv.version) {
+    console.log(`v${VERSION}\n`);
+    return;
+  }
+
+  if (!argv._.length) {
+    console.log('Please provide a path to a script. (See --help for details)');
+    process.on('exit', () => process.exit(1));
+    return;
+  }
+
+  const root = process.cwd();
+  const filePath = path.resolve(root, argv._[0]);
+
+  if (argv.debug) {
+    const info = cliInfo ? ', ' + cliInfo.join(', ') : '';
+    console.log(`Using Jest Runtime v${VERSION}${info}`);
+  }
+  const options = readConfig(argv, root);
+  const globalConfig = options.globalConfig;
+  // Always disable automocking in scripts.
+  const config = Object.assign({}, options.config, {
+    automock: false,
+    unmockedModulePathPatterns: null });
+
+  Runtime.createContext(config, {
+    maxWorkers: os.cpus().length - 1,
+    watchman: globalConfig.watchman }).
+
+  then(hasteMap => {
+    /* $FlowFixMe */
+    const Environment = require(config.testEnvironment);
+    const environment = new Environment(config);
+    setGlobal(
+    environment.global,
+    'console',
+    new Console(process.stdout, process.stderr));
+
+    environment.global.jestProjectConfig = config;
+    environment.global.jestGlobalConfig = globalConfig;
+
+    const runtime = new Runtime(config, environment, hasteMap.resolver);
+    runtime.requireModule(filePath);
+  }).
+  catch(e => {
+    console.error(chalk.red(e));
+    process.on('exit', () => process.exit(1));
+  });
+}
+
+exports.run = run;

web/node_modules/jest-runtime/build/index.js

@@ -0,0 +1,765 @@
+'use strict';var _slicedToArray = function () {function sliceIterator(arr, i) {var _arr = [];var _n = true;var _d = false;var _e = undefined;try {for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) {_arr.push(_s.value);if (i && _arr.length === i) break;}} catch (err) {_d = true;_e = err;} finally {try {if (!_n && _i["return"]) _i["return"]();} finally {if (_d) throw _e;}}return _arr;}return function (arr, i) {if (Array.isArray(arr)) {return arr;} else if (Symbol.iterator in Object(arr)) {return sliceIterator(arr, i);} else {throw new TypeError("Invalid attempt to destructure non-iterable instance");}};}();
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+const path = require('path'); /**
+                               * 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.
+                               *
+                               * 
+                               */const HasteMap = require('jest-haste-map');const Resolver = require('jest-resolve');var _require = require('jest-util');const createDirectory = _require.createDirectory;var _require2 = require('jest-regex-util');const escapePathForRegex = _require2.escapePathForRegex;const fs = require('graceful-fs');const stripBOM = require('strip-bom');const ScriptTransformer = require('./ScriptTransformer');
+const shouldInstrument = require('./shouldInstrument');
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+const NODE_MODULES = path.sep + 'node_modules' + path.sep;
+const SNAPSHOT_EXTENSION = 'snap';
+
+const getModuleNameMapper = config => {
+  if (
+  Array.isArray(config.moduleNameMapper) &&
+  config.moduleNameMapper.length)
+  {
+    return config.moduleNameMapper.map((_ref) => {var _ref2 = _slicedToArray(_ref, 2);let regex = _ref2[0],moduleName = _ref2[1];
+      return { moduleName, regex: new RegExp(regex) };
+    });
+  }
+  return null;
+};
+
+const mockParentModule = {
+  exports: {},
+  filename: 'mock.js',
+  id: 'mockParent' };
+
+
+const unmockRegExpCache = new WeakMap();
+
+class Runtime {
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+  constructor(
+  config,
+  environment,
+  resolver,
+  cacheFS,
+  coverageOptions)
+  {
+    this._cacheFS = cacheFS || Object.create(null);
+    this._config = config;
+    this._coverageOptions = coverageOptions || {
+      collectCoverage: false,
+      collectCoverageFrom: [],
+      collectCoverageOnlyFrom: null,
+      mapCoverage: false };
+
+    this._currentlyExecutingModulePath = '';
+    this._environment = environment;
+    this._explicitShouldMock = Object.create(null);
+    this._internalModuleRegistry = Object.create(null);
+    this._isCurrentlyExecutingManualMock = null;
+    this._mockFactories = Object.create(null);
+    this._mockRegistry = Object.create(null);
+    this._moduleMocker = this._environment.moduleMocker;
+    this._moduleRegistry = Object.create(null);
+    this._resolver = resolver;
+    this._scriptTransformer = new ScriptTransformer(config);
+    this._shouldAutoMock = config.automock;
+    this._sourceMapRegistry = Object.create(null);
+    this._virtualMocks = Object.create(null);
+
+    this._mockMetaDataCache = Object.create(null);
+    this._shouldMockModuleCache = Object.create(null);
+    this._shouldUnmockTransitiveDependenciesCache = Object.create(null);
+    this._transitiveShouldMock = Object.create(null);
+
+    this._unmockList = unmockRegExpCache.get(config);
+    if (!this._unmockList && config.unmockedModulePathPatterns) {
+      this._unmockList = new RegExp(
+      config.unmockedModulePathPatterns.join('|'));
+
+      unmockRegExpCache.set(config, this._unmockList);
+    }
+
+    if (config.automock) {
+      config.setupFiles.forEach(filePath => {
+        if (filePath && filePath.includes(NODE_MODULES)) {
+          const moduleID = this._resolver.getModuleID(
+          this._virtualMocks,
+          filePath);
+
+          this._transitiveShouldMock[moduleID] = false;
+        }
+      });
+    }
+
+    this.resetModules();
+
+    if (config.setupFiles.length) {
+      for (let i = 0; i < config.setupFiles.length; i++) {
+        this.requireModule(config.setupFiles[i]);
+      }
+    }
+  }
+
+  static shouldInstrument(
+  filename,
+  options,
+  config)
+  {
+    return shouldInstrument(
+    filename,
+    {
+      collectCoverage: options.collectCoverage,
+      collectCoverageFrom: options.collectCoverageFrom,
+      collectCoverageOnlyFrom: options.collectCoverageOnlyFrom,
+      mapCoverage: options.mapCoverage },
+
+    config);
+
+  }
+
+  static createContext(
+  config,
+  options)
+
+
+
+
+
+  {
+    createDirectory(config.cacheDirectory);
+    const instance = Runtime.createHasteMap(config, {
+      console: options.console,
+      maxWorkers: options.maxWorkers,
+      resetCache: !config.cache,
+      watch: options.watch,
+      watchman: options.watchman });
+
+    return instance.build().then(
+    hasteMap => ({
+      config,
+      hasteFS: hasteMap.hasteFS,
+      moduleMap: hasteMap.moduleMap,
+      resolver: Runtime.createResolver(config, hasteMap.moduleMap) }),
+
+    error => {
+      throw error;
+    });
+
+  }
+
+  static createHasteMap(
+  config,
+  options)
+  {
+    const ignorePattern = new RegExp(
+    [config.cacheDirectory].concat(config.modulePathIgnorePatterns).join('|'));
+
+
+    return new HasteMap({
+      cacheDirectory: config.cacheDirectory,
+      console: options && options.console,
+      extensions: [SNAPSHOT_EXTENSION].concat(config.moduleFileExtensions),
+      hasteImplModulePath: config.haste.hasteImplModulePath,
+      ignorePattern,
+      maxWorkers: options && options.maxWorkers || 1,
+      mocksPattern: escapePathForRegex(path.sep + '__mocks__' + path.sep),
+      name: config.name,
+      platforms: config.haste.platforms || ['ios', 'android'],
+      providesModuleNodeModules: config.haste.providesModuleNodeModules,
+      resetCache: options && options.resetCache,
+      retainAllFiles: false,
+      roots: config.roots,
+      useWatchman: options && options.watchman,
+      watch: options && options.watch });
+
+  }
+
+  static createResolver(config, moduleMap) {
+    return new Resolver(moduleMap, {
+      browser: config.browser,
+      defaultPlatform: config.haste.defaultPlatform,
+      extensions: config.moduleFileExtensions.map(extension => '.' + extension),
+      hasCoreModules: true,
+      moduleDirectories: config.moduleDirectories,
+      moduleNameMapper: getModuleNameMapper(config),
+      modulePaths: config.modulePaths,
+      platforms: config.haste.platforms,
+      resolver: config.resolver });
+
+  }
+
+  static runCLI(args, info) {
+    return require('./cli').run(args, info);
+  }
+
+  static getCLIOptions() {
+    return require('./cli/args').options;
+  }
+
+  requireModule(
+  from,
+  moduleName,
+  options)
+  {
+    const moduleID = this._resolver.getModuleID(
+    this._virtualMocks,
+    from,
+    moduleName);
+
+    let modulePath;
+
+    const moduleRegistry = !options || !options.isInternalModule ?
+    this._moduleRegistry :
+    this._internalModuleRegistry;
+
+    // Some old tests rely on this mocking behavior. Ideally we'll change this
+    // to be more explicit.
+    const moduleResource = moduleName && this._resolver.getModule(moduleName);
+    const manualMock =
+    moduleName && this._resolver.getMockModule(from, moduleName);
+    if (
+    (!options || !options.isInternalModule) &&
+    !moduleResource &&
+    manualMock &&
+    manualMock !== this._isCurrentlyExecutingManualMock &&
+    this._explicitShouldMock[moduleID] !== false)
+    {
+      modulePath = manualMock;
+    }
+
+    if (moduleName && this._resolver.isCoreModule(moduleName)) {
+      // $FlowFixMe
+      return require(moduleName);
+    }
+
+    if (!modulePath) {
+      modulePath = this._resolveModule(from, moduleName);
+    }
+
+    if (!moduleRegistry[modulePath]) {
+      // We must register the pre-allocated module object first so that any
+      // circular dependencies that may arise while evaluating the module can
+      // be satisfied.
+      const localModule = {
+        exports: {},
+        filename: modulePath,
+        id: modulePath };
+
+      moduleRegistry[modulePath] = localModule;
+      if (path.extname(modulePath) === '.json') {
+        localModule.exports = this._environment.global.JSON.parse(
+        stripBOM(fs.readFileSync(modulePath, 'utf8')));
+
+      } else if (path.extname(modulePath) === '.node') {
+        // $FlowFixMe
+        localModule.exports = require(modulePath);
+      } else {
+        this._execModule(localModule, options);
+      }
+    }
+    return moduleRegistry[modulePath].exports;
+  }
+
+  requireInternalModule(from, to) {
+    return this.requireModule(from, to, { isInternalModule: true });
+  }
+
+  requireMock(from, moduleName) {
+    const moduleID = this._resolver.getModuleID(
+    this._virtualMocks,
+    from,
+    moduleName);
+
+
+    if (this._mockRegistry[moduleID]) {
+      return this._mockRegistry[moduleID];
+    }
+
+    if (moduleID in this._mockFactories) {
+      return this._mockRegistry[moduleID] = this._mockFactories[moduleID]();
+    }
+
+    let manualMock = this._resolver.getMockModule(from, moduleName);
+    let modulePath;
+    if (manualMock) {
+      modulePath = this._resolveModule(from, manualMock);
+    } else {
+      modulePath = this._resolveModule(from, moduleName);
+
+      // If the actual module file has a __mocks__ dir sitting immediately next
+      // to it, look to see if there is a manual mock for this file.
+      //
+      // subDir1/MyModule.js
+      // subDir1/__mocks__/MyModule.js
+      // subDir2/MyModule.js
+      // subDir2/__mocks__/MyModule.js
+      //
+      // Where some other module does a relative require into each of the
+      // respective subDir{1,2} directories and expects a manual mock
+      // corresponding to that particular MyModule.js file.
+      const moduleDir = path.dirname(modulePath);
+      const moduleFileName = path.basename(modulePath);
+      const potentialManualMock = path.join(
+      moduleDir,
+      '__mocks__',
+      moduleFileName);
+
+      if (fs.existsSync(potentialManualMock)) {
+        manualMock = true;
+        modulePath = potentialManualMock;
+      }
+    }
+
+    if (manualMock) {
+      const localModule = {
+        exports: {},
+        filename: modulePath,
+        id: modulePath };
+
+      this._execModule(localModule);
+      this._mockRegistry[moduleID] = localModule.exports;
+    } else {
+      // Look for a real module to generate an automock from
+      this._mockRegistry[moduleID] = this._generateMock(from, moduleName);
+    }
+
+    return this._mockRegistry[moduleID];
+  }
+
+  requireModuleOrMock(from, moduleName) {
+    if (this._shouldMock(from, moduleName)) {
+      return this.requireMock(from, moduleName);
+    } else {
+      return this.requireModule(from, moduleName);
+    }
+  }
+
+  resetModules() {
+    this._mockRegistry = Object.create(null);
+    this._moduleRegistry = Object.create(null);
+
+    if (this._environment && this._environment.global) {
+      const envGlobal = this._environment.global;
+      Object.keys(envGlobal).forEach(key => {
+        const globalMock = envGlobal[key];
+        if (
+        typeof globalMock === 'object' && globalMock !== null ||
+        typeof globalMock === 'function')
+        {
+          globalMock._isMockFunction && globalMock.mockClear();
+        }
+      });
+
+      if (envGlobal.mockClearTimers) {
+        envGlobal.mockClearTimers();
+      }
+    }
+  }
+
+  getAllCoverageInfo() {
+    return this._environment.global.__coverage__;
+  }
+
+  getSourceMapInfo() {
+    return Object.keys(this._sourceMapRegistry).reduce((result, sourcePath) => {
+      if (fs.existsSync(this._sourceMapRegistry[sourcePath])) {
+        result[sourcePath] = this._sourceMapRegistry[sourcePath];
+      }
+      return result;
+    }, {});
+  }
+
+  setMock(
+  from,
+  moduleName,
+  mockFactory,
+  options)
+  {
+    if (options && options.virtual) {
+      const mockPath = this._resolver.getModulePath(from, moduleName);
+      this._virtualMocks[mockPath] = true;
+    }
+    const moduleID = this._resolver.getModuleID(
+    this._virtualMocks,
+    from,
+    moduleName);
+
+    this._explicitShouldMock[moduleID] = true;
+    this._mockFactories[moduleID] = mockFactory;
+  }
+
+  resetAllMocks() {
+    this._moduleMocker.resetAllMocks();
+  }
+
+  clearAllMocks() {
+    this._moduleMocker.clearAllMocks();
+  }
+
+  _resolveModule(from, to) {
+    return to ? this._resolver.resolveModule(from, to) : from;
+  }
+
+  _execModule(localModule, options) {
+    // If the environment was disposed, prevent this module from being executed.
+    if (!this._environment.global) {
+      return;
+    }
+
+    const isInternalModule = !!(options && options.isInternalModule);
+    const filename = localModule.filename;
+    const lastExecutingModulePath = this._currentlyExecutingModulePath;
+    this._currentlyExecutingModulePath = filename;
+    const origCurrExecutingManualMock = this._isCurrentlyExecutingManualMock;
+    this._isCurrentlyExecutingManualMock = filename;
+
+    const dirname = path.dirname(filename);
+    localModule.children = [];
+    localModule.parent = mockParentModule;
+    localModule.paths = this._resolver.getModulePaths(dirname);
+    localModule.require = this._createRequireImplementation(filename, options);
+
+    const transformedFile = this._scriptTransformer.transform(
+    filename,
+    {
+      collectCoverage: this._coverageOptions.collectCoverage,
+      collectCoverageFrom: this._coverageOptions.collectCoverageFrom,
+      collectCoverageOnlyFrom: this._coverageOptions.collectCoverageOnlyFrom,
+      isInternalModule,
+      mapCoverage: this._coverageOptions.mapCoverage },
+
+    this._cacheFS[filename]);
+
+
+    if (transformedFile.sourceMapPath) {
+      this._sourceMapRegistry[filename] = transformedFile.sourceMapPath;
+    }
+
+    const wrapper = this._environment.runScript(transformedFile.script)[
+    ScriptTransformer.EVAL_RESULT_VARIABLE];
+
+    wrapper.call(
+    localModule.exports, // module context
+    localModule, // module object
+    localModule.exports, // module exports
+    localModule.require, // require implementation
+    dirname, // __dirname
+    filename, // __filename
+    this._environment.global, // global object
+    this._createRuntimeFor(filename));
+
+
+    this._isCurrentlyExecutingManualMock = origCurrExecutingManualMock;
+    this._currentlyExecutingModulePath = lastExecutingModulePath;
+  }
+
+  _generateMock(from, moduleName) {
+    const modulePath = this._resolveModule(from, moduleName);
+
+    if (!(modulePath in this._mockMetaDataCache)) {
+      // This allows us to handle circular dependencies while generating an
+      // automock
+      this._mockMetaDataCache[modulePath] = this._moduleMocker.getMetadata(
+      {});
+
+
+      // In order to avoid it being possible for automocking to potentially
+      // cause side-effects within the module environment, we need to execute
+      // the module in isolation. This could cause issues if the module being
+      // mocked has calls into side-effectful APIs on another module.
+      const origMockRegistry = this._mockRegistry;
+      const origModuleRegistry = this._moduleRegistry;
+      this._mockRegistry = Object.create(null);
+      this._moduleRegistry = Object.create(null);
+
+      const moduleExports = this.requireModule(from, moduleName);
+
+      // Restore the "real" module/mock registries
+      this._mockRegistry = origMockRegistry;
+      this._moduleRegistry = origModuleRegistry;
+
+      const mockMetadata = this._moduleMocker.getMetadata(moduleExports);
+      if (mockMetadata == null) {
+        throw new Error(
+        `Failed to get mock metadata: ${modulePath}\n\n` +
+        `See: http://facebook.github.io/jest/docs/manual-mocks.html#content`);
+
+      }
+      this._mockMetaDataCache[modulePath] = mockMetadata;
+    }
+    return this._moduleMocker.generateFromMetadata(
+    this._mockMetaDataCache[modulePath]);
+
+  }
+
+  _shouldMock(from, moduleName) {
+    const mockPath = this._resolver.getModulePath(from, moduleName);
+    if (mockPath in this._virtualMocks) {
+      return true;
+    }
+
+    const explicitShouldMock = this._explicitShouldMock;
+    const moduleID = this._resolver.getModuleID(
+    this._virtualMocks,
+    from,
+    moduleName);
+
+    const key = from + path.delimiter + moduleID;
+
+    if (moduleID in explicitShouldMock) {
+      return explicitShouldMock[moduleID];
+    }
+
+    if (
+    !this._shouldAutoMock ||
+    this._resolver.isCoreModule(moduleName) ||
+    this._shouldUnmockTransitiveDependenciesCache[key])
+    {
+      return false;
+    }
+
+    if (moduleID in this._shouldMockModuleCache) {
+      return this._shouldMockModuleCache[moduleID];
+    }
+
+    let modulePath;
+    try {
+      modulePath = this._resolveModule(from, moduleName);
+    } catch (e) {
+      const manualMock = this._resolver.getMockModule(from, moduleName);
+      if (manualMock) {
+        this._shouldMockModuleCache[moduleID] = true;
+        return true;
+      }
+      throw e;
+    }
+
+    if (this._unmockList && this._unmockList.test(modulePath)) {
+      this._shouldMockModuleCache[moduleID] = false;
+      return false;
+    }
+
+    // transitive unmocking for package managers that store flat packages (npm3)
+    const currentModuleID = this._resolver.getModuleID(
+    this._virtualMocks,
+    from);
+
+    if (
+    this._transitiveShouldMock[currentModuleID] === false ||
+    from.includes(NODE_MODULES) &&
+    modulePath.includes(NODE_MODULES) && (
+    this._unmockList && this._unmockList.test(from) ||
+    explicitShouldMock[currentModuleID] === false))
+    {
+      this._transitiveShouldMock[moduleID] = false;
+      this._shouldUnmockTransitiveDependenciesCache[key] = true;
+      return false;
+    }
+
+    return this._shouldMockModuleCache[moduleID] = true;
+  }
+
+  _createRequireImplementation(from, options) {
+    const moduleRequire = options && options.isInternalModule ?
+    moduleName => this.requireInternalModule(from, moduleName) :
+    this.requireModuleOrMock.bind(this, from);
+    moduleRequire.cache = Object.create(null);
+    moduleRequire.extensions = Object.create(null);
+    moduleRequire.requireActual = this.requireModule.bind(this, from);
+    moduleRequire.requireMock = this.requireMock.bind(this, from);
+    moduleRequire.resolve = moduleName => this._resolveModule(from, moduleName);
+    return moduleRequire;
+  }
+
+  _createRuntimeFor(from) {
+    const disableAutomock = () => {
+      this._shouldAutoMock = false;
+      return runtime;
+    };
+    const enableAutomock = () => {
+      this._shouldAutoMock = true;
+      return runtime;
+    };
+    const unmock = moduleName => {
+      const moduleID = this._resolver.getModuleID(
+      this._virtualMocks,
+      from,
+      moduleName);
+
+      this._explicitShouldMock[moduleID] = false;
+      return runtime;
+    };
+    const deepUnmock = moduleName => {
+      const moduleID = this._resolver.getModuleID(
+      this._virtualMocks,
+      from,
+      moduleName);
+
+      this._explicitShouldMock[moduleID] = false;
+      this._transitiveShouldMock[moduleID] = false;
+      return runtime;
+    };
+    const mock = (
+    moduleName,
+    mockFactory,
+    options) =>
+    {
+      if (mockFactory !== undefined) {
+        return setMockFactory(moduleName, mockFactory, options);
+      }
+
+      const moduleID = this._resolver.getModuleID(
+      this._virtualMocks,
+      from,
+      moduleName);
+
+      this._explicitShouldMock[moduleID] = true;
+      return runtime;
+    };
+    const setMockFactory = (moduleName, mockFactory, options) => {
+      this.setMock(from, moduleName, mockFactory, options);
+      return runtime;
+    };
+    const clearAllMocks = () => {
+      this.clearAllMocks();
+      return runtime;
+    };
+    const resetAllMocks = () => {
+      this.resetAllMocks();
+      return runtime;
+    };
+    const useFakeTimers = () => {
+      this._environment.fakeTimers.useFakeTimers();
+      return runtime;
+    };
+    const useRealTimers = () => {
+      this._environment.fakeTimers.useRealTimers();
+      return runtime;
+    };
+    const resetModules = () => {
+      this.resetModules();
+      return runtime;
+    };
+    const fn = this._moduleMocker.fn.bind(this._moduleMocker);
+    const spyOn = this._moduleMocker.spyOn.bind(this._moduleMocker);
+
+    const runtime = {
+      addMatchers: matchers =>
+      this._environment.global.jasmine.addMatchers(matchers),
+
+      autoMockOff: disableAutomock,
+      autoMockOn: enableAutomock,
+      clearAllMocks,
+      clearAllTimers: () => this._environment.fakeTimers.clearAllTimers(),
+      deepUnmock,
+      disableAutomock,
+      doMock: mock,
+      dontMock: unmock,
+      enableAutomock,
+      fn,
+      genMockFn: fn,
+      genMockFromModule: moduleName =>
+      this._generateMock(from, moduleName),
+      genMockFunction: fn,
+      isMockFunction: this._moduleMocker.isMockFunction,
+
+      mock,
+      resetAllMocks,
+      resetModuleRegistry: resetModules,
+      resetModules,
+
+      runAllImmediates: () => this._environment.fakeTimers.runAllImmediates(),
+      runAllTicks: () => this._environment.fakeTimers.runAllTicks(),
+      runAllTimers: () => this._environment.fakeTimers.runAllTimers(),
+      runOnlyPendingTimers: () =>
+      this._environment.fakeTimers.runOnlyPendingTimers(),
+      runTimersToTime: msToRun =>
+      this._environment.fakeTimers.runTimersToTime(msToRun),
+
+      setMock: (moduleName, mock) =>
+      setMockFactory(moduleName, () => mock),
+      spyOn,
+
+      unmock,
+
+      useFakeTimers,
+      useRealTimers };
+
+    return runtime;
+  }}
+
+
+Runtime.ScriptTransformer = ScriptTransformer;
+module.exports = Runtime;

web/node_modules/jest-runtime/build/shouldInstrument.js

@@ -0,0 +1,78 @@
+'use strict'; /**
+               * 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.
+               *
+               * 
+               */
+
+
+
+
+const path = require('path');var _require =
+require('jest-regex-util');const escapePathForRegex = _require.escapePathForRegex;
+const micromatch = require('micromatch');
+
+const MOCKS_PATTERN = new RegExp(
+escapePathForRegex(path.sep + '__mocks__' + path.sep));
+
+
+const shouldInstrument = (
+filename,
+options,
+config) =>
+{
+  if (!options.collectCoverage) {
+    return false;
+  }
+
+  if (config.testRegex && filename.match(config.testRegex)) {
+    return false;
+  }
+
+  if (
+  config.testMatch &&
+  config.testMatch.length &&
+  micromatch.any(filename, config.testMatch))
+  {
+    return false;
+  }
+
+  if (
+  // This configuration field contains an object in the form of:
+  // {'path/to/file.js': true}
+  options.collectCoverageOnlyFrom &&
+  !options.collectCoverageOnlyFrom[filename])
+  {
+    return false;
+  }
+
+  if (
+  // still cover if `only` is specified
+  !options.collectCoverageOnlyFrom &&
+  options.collectCoverageFrom &&
+  !micromatch(
+  [path.relative(config.rootDir, filename)],
+  options.collectCoverageFrom).
+  length)
+  {
+    return false;
+  }
+
+  if (
+  config.coveragePathIgnorePatterns &&
+  config.coveragePathIgnorePatterns.some(pattern => filename.match(pattern)))
+  {
+    return false;
+  }
+
+  if (MOCKS_PATTERN.test(filename)) {
+    return false;
+  }
+
+  return true;
+};
+
+module.exports = shouldInstrument;