const migrateV6Plugins = async () => {
   if (!await fs.pathExists(pluginsDir)) return
   process.stderr.write('heroku: migrating plugins\n')
   try {
     const p = path.join(pluginsDir, 'user.json')
     if (await fs.pathExists(p)) {
       const {manifest} = await fs.readJSON(p)
       for (let plugin of Object.keys(manifest.plugins)) {
         process.stderr.write(`heroku-cli: migrating ${plugin}\n`)
         await exec('heroku', ['plugins:install', plugin])
       }
     }
   } catch (err) {
     this.warn(err)
   }
   try {
     const p = path.join(pluginsDir, 'link.json')
     if (await fs.pathExists(p)) {
       const {manifest} = await fs.readJSON(path.join(pluginsDir, 'link.json'))
       for (let {root} of Object.values(manifest.plugins) as any) {
         process.stderr.write(`heroku-cli: migrating ${root}\n`)
         await exec('heroku', ['plugins:link', root])
       }
     }
   } catch (err) {
     this.warn(err)
   }
   await fs.remove(pluginsDir)
   process.stderr.write('heroku: done migrating plugins\n')
 }

/**
 * For a given repo, generate a new package.json and write it to disk. This
 * is a testing-specific package.json manifest, which means that it will
 * include local references to dependencies that were also converted in the
 * workspace.
 */
async function writeTestingPackageJson(
    repo: WorkspaceRepo,
    localConversionMap: Map<string, string>,
    options: WorkspaceTestSettings) {
  const bowerPackageName = path.basename(repo.dir);
  const bowerJsonPath = path.join(repo.dir, 'bower.json');
  const bowerJson = await fse.readJSON(bowerJsonPath);
  const npmPackageName =
      lookupNpmPackageName(bowerJsonPath) || bowerPackageName;

  const packageJsonPath = path.join(repo.dir, 'package.json');
  const existingPackageJson =
      await readJsonIfExists<Partial<YarnConfig>>(packageJsonPath);

  const packageJson = generatePackageJson(
      bowerJson,
      {
        name: npmPackageName,
        version: options.packageVersion,
        flat: options.flat,
        private: options.private,
      },
      localConversionMap,
      existingPackageJson);
  writeJson(packageJson, packageJsonPath);
}

export async function readJsonIfExists<T>(filepath: string):
    Promise<T|undefined> {
  if (await fse.pathExists(filepath)) {
    return await fse.readJSON(filepath) as T;
  }
  return undefined;
}

export async function initializeFromJsonFile(jsonFilepath: string, debug?: boolean): Promise<void> {
    if (!await fse.pathExists(jsonFilepath)) {
        throw new Error(`The Json file '${jsonFilepath}' does not exist.`);
    }

    const { publisher, name, version, aiKey } = await fse.readJSON(jsonFilepath);
    initialize(`${publisher}.${name}`, version, aiKey, !!debug);
}

 export async function initilizeFromJsonFile(fsPath: string): Promise<void> {
     if (await fse.pathExists(fsPath)) {
         const { publisher, name, version, aiKey } = await fse.readJSON(fsPath);
         initilize(publisher, name, version, aiKey);
     } else {
         throw new Error(`The Json file '${fsPath}' does not exist.`);
     }
 }

export function prepareHTML(param: IPrepareHTMLOptions): Promise<string> {
    const filter = moveTo(param.target);

    return Promise.all([
        readFile(join(__dirname, '../src/index.html'), 'utf8'),
        readJSON(join(__dirname, '../package.json')),
        readJSON(join(__dirname, './meta.json'))
    ])
        .then((data) => {
            const [file, pack, meta] = data;
            const connectionTypes = ['mainnet', 'testnet'];

            if (!param.scripts) {
                const sourceFiles = getFilesFrom(join(__dirname, '../src'), '.js', function (name, path) {
                    return !name.includes('.spec') && !path.includes('/test/');
                });
                param.scripts = meta.vendors.map((i) => join(__dirname, '..', i)).concat(sourceFiles);
                param.scripts.push(join(__dirname, '../loginDaemon.js'));
            }

            if (!param.styles) {
                param.styles = meta.stylesheets.map((i) => join(__dirname, '..', i)).concat(getFilesFrom(join(__dirname, '../src'), '.less'));
            }

            const networks = connectionTypes.reduce((result, item) => {
                result[item] = meta.configurations[item];
                return result;
            }, Object.create(null));

            return compile(file)({
                pack: pack,
                domain: meta.domain,
                build: {
                    type: 'web'
                },
                network: networks[param.connection]
            });
        })
        .then((file) => {
            return replaceStyles(file, param.styles.map(filter).map(s => `/${s}`));
        }).then((file) => {
            return replaceScripts(file, param.scripts.map(filter));
        });
}

      read: async () => {
        const [data, stat] = await Promise.all([fs.readJSON(filepath), fs.stat(filepath)]);

        // Throw an error instead of returning stale data if the file has expired
        if (Date.now() - stat.mtimeMs > expiryInMin * 60 * 1000) {
          throw new CacheExpiredError('Cache expired', filepath, stat.mtimeMs);
        }

        return data;
      },

export async function fetchCache(cachePath: string, cacheDuration: number, options: any): Promise<Array<string>> {
  let cachePresent = fs.existsSync(cachePath)
  if (cachePresent && !_isStale(cachePath, cacheDuration)) {
    return fs.readJSON(cachePath)
  }
  const cache = await options.cacheFn()
  // TODO: move this to a fork
  await updateCache(cachePath, cache)
  return cache
}

export async function getBuildParams(param: IPrepareHTMLOptions) {
    const [pack, meta, themesConf] = await Promise.all([
        readJSON(join(__dirname, '../package.json')) as Promise<IPackageJSON>,
        readJSON(join(__dirname, './meta.json')) as Promise<IMetaJSON>,
        readJSON(join(__dirname, '../src/themeConfig/theme.json'))
    ]);

    const { themes } = themesConf;
    const { domain, analyticsIframe } = meta as any;
    const { connection, type, buildType, outerScripts = [] } = param;
    const config = meta.configurations[connection];

    const networks = ['mainnet', 'testnet'].reduce((result, connection) => {
        result[connection] = meta.configurations[connection];
        return result;
    }, Object.create(null));

    const scripts = getScripts(param, pack, meta).concat(outerScripts);
    const styles = getStyles(param, meta, themes);
    const isWeb = type === 'web';
    const isProduction = buildType && buildType === 'min';
    const matcherPriorityList = connection === 'mainnet' ? MAINNET_DATA : TESTNET_DATA;
    const { origin, oracle, feeConfigUrl, bankRecipient } = config;

    return {
        pack,
        isWeb,
        origin,
        analyticsIframe,
        oracle,
        domain,
        styles,
        scripts,
        isProduction,
        feeConfigUrl,
        bankRecipient,
        build: { type },
        matcherPriorityList,
        network: networks[connection],
        themesConf: themesConf,
        langList: meta.langList,
    };
}

export function validate<T>(data: T, schemaName: string): Promise<T> {
    const respath = path.join(path.dirname(__dirname), "res");
    return fs.readJSON(path.join(respath, schemaName + ".json")).then(function (schema) {
        const ajv = new Ajv({ schemaId: 'auto', allErrors: true });
        const metaschema = require('ajv/lib/refs/json-schema-draft-04.json');
        ajv.addMetaSchema(metaschema);
        if (!ajv.validate(schema, data)) {
            throw ("JSON schema errors: " + JSON.stringify(ajv.errors, null, 2));
        }
        return data;
    })
}

/** get_railroad loads the current railroad from the resources. */
function get_railroad(): Promise<IRailRoadImplem> {
    const filePath = path.join(RES_FOLDER, "railroad.json");
    return (fs.readJSON(filePath, { encoding: "UTF-8" }) as Promise<IRailRoadImplem>).then(
        data => validate(data, "IRailRoad").then(function(data) {
            for(let i=0; i< data.occupancy.length; i++) {
                data.occupancy[i].id = i;
            }
            return data;
        })
    ).catch(
        err => (console.log("Cannot proceed without railroad description file: " + err), process.exit(1)));
}

 return async (...args: any[]): Promise<any> => {
   let f = path.join(cacheDir, `${key}.json`)
   try {
     let fi = await fs.stat(f)
     if (fi && minutesAgo(20) < fi.mtime) {
       return await fs.readJSON(f)
     }
   } catch (err) {
     debug(err)
     submitError(err)
     await fs.remove(f)
   }
   let body = await fn(...args)
   await fs.outputJSON(f, body)
   return body
 }

  /**
   * parse manifest
   * @returns {Promise<void>}
   */
  async read() {
    const zip = new Node7z()
    await zip.extractFull(this.filename, this.tempDir)
    const manifestFile = path.join(this.tempDir, 'modpack.json')
    if (!await fs.pathExists(manifestFile)) {
      throw new Error('invalid modpack: modpack.json not found')
    }
    const manifest = await fs.readJSON(manifestFile)
    const validatorResult = validate(manifest, ModpackManifestSchema)
    if (!validatorResult.valid) {
      let err = new Error('invalid modpack: modpack.json format error')
      err['validate'] = validatorResult.errors
      throw err
    }

    this.manifest = manifest
  }

/** Reads a locomotive description file 
 * @param locoPath path to a folder containing a locomotive description.
 * @return a promise of locomotive description object.
 */
function read_locomotive(locoPath: string): Promise<ILocomotive> {
    const locoFile = path.join(locoPath, "loco.json");
    return (fs.readJSON(locoFile, { encoding: "UTF-8" }) as Promise<ILocomotive>).then(
        data => validate(data, "ILocomotive")
    ).then (
        function (loco) {
            
            const locoImgFile = path.join(locoPath, "image.jpg");
            if (loco.image) { return loco; }
            return fs.pathExists(locoImgFile).then(
                function (existsImage) {
                    console.log(locoImgFile + " => " + existsImage);
                    if (existsImage) {
                        loco.image = locoImgFile;
                    } else {
                        loco.image = path.join(path.dirname(__dirname), "res/loco.jpg");
                    }
                    return loco;
                });
        }).catch(
            function (err) { throw ("(" + locoPath + "): " + err); }
        );
}

/**
 * Convert a package-layout project to JavaScript modules & npm.
 */
export default async function convert(options: PackageConversionSettings) {
  const outDir = options.outDir;
  const npmPackageName = options.packageName;
  await setupOutDir(outDir, options.cleanOutDir);

  // Configure the analyzer and run an analysis of the package.
  const bowerJson =
      await fse.readJSON(path.join(options.inDir, 'bower.json')) as
      Partial<BowerConfig>;
  const bowerPackageName = bowerJson.name!;
  const analyzer = configureAnalyzer(options);
  const analysis = await analyzer.analyzePackage();
  await setupOutDir(options.outDir, !!options.cleanOutDir);

  // Create the url handler & converter.
  const urlHandler = new PackageUrlHandler(
      analyzer,
      bowerPackageName,
      npmPackageName,
      options.packageType,
      options.inDir);
  const conversionSettings = createDefaultConversionSettings(analysis, options);
  const converter =
      new ProjectConverter(analysis, urlHandler, conversionSettings);

  // Convert the package
  await converter.convertPackage(bowerPackageName);

  // Filter out external results before writing them to disk.
  const results = converter.getResults();
  for (const [newPath] of results) {
    if (!PackageUrlHandler.isUrlInternalToPackage(newPath)) {
      results.delete(newPath);
    }
  }
  await writeFileResults(outDir, results);

  // transform travis config
  await transformTravisConfig(options.inDir, options.outDir);

  // add `node_modules` to gitignore
  const gitIgnoreFile = path.join(options.inDir, '.gitignore');
  await ignoreNodeModules(gitIgnoreFile);

  const packageJsonPath = path.join(options.inDir, 'package.json');
  const existingPackageJson =
      await readJsonIfExists<Partial<YarnConfig>>(packageJsonPath);

  // Generate a new package.json, and write it to disk.
  const packageJson = generatePackageJson(
      bowerJson,
      {
        name: options.packageName,
        version: options.packageVersion,
        flat: options.flat,
        private: options.private,
      },
      undefined,
      existingPackageJson);
  writeJson(packageJson, packageJsonPath);

  // Delete files that were explicitly requested to be deleted.
  if (options.deleteFiles !== undefined) {
    await deleteGlobsSafe(options.deleteFiles, outDir);
  }

  // TODO(fks): create a new manifest.json, and write it to disk.
  // Currently blocked by the fact that package-url-handler treats all
  // dependencies as local/internal.
}

	// stub
});

fs.outputJsonSync(file, data);
fs.outputJSONSync(file, data);

fs.readJson(file).then(() => {
	// stub
});

fs.readJson(file, readOptions).then(() => {
	// stub
});
fs.readJson(file, (error: Error, jsonObject: any) => { });
fs.readJson(file, readOptions, (error: Error, jsonObject: any) => { });
fs.readJSON(file, (error: Error, jsonObject: any) => { });
fs.readJSON(file, readOptions, (error: Error, jsonObject: any) => { });

fs.readJsonSync(file, readOptions);
fs.readJSONSync(file, readOptions);

fs.remove(dir, errorCallback);
fs.remove(dir).then(() => {
	// stub
});
fs.removeSync(dir);

fs.writeJson(file, object).then(() => {
	// stub
});
fs.writeJSON(file, object).then(() => {

/** get_hardware returns values about the specific hardware settings (pins, i2c address, etc.)
 * @return a promise of an hardware structure.
 */
function get_hardware(): Promise<IHardware> {
    return (fs.readJSON(path.join(RES_FOLDER, "hardware.json"), { encoding: "UTF-8" }) as Promise<IHardware>).then(
        data => validate(data, "IHardware")).catch(
        err => (console.log("Cannot proceed without hardware description file: " + err), process.exit(1)));
}

 ].map((path) => {
     return readJSON(path).then((json) => {
         json.version = pack.version;
         return outputFile(path, JSON.stringify(json, null, 2));
     });
 });

export default async function run(options: CliOptions) {
  const inDir = path.resolve(options.in || process.cwd());
  const outDir = path.resolve(options.out);

  // Ok, we're updating a package in a directory not under our control.
  // We need to be sure it's safe.
  let stdout, stderr;
  let isRepo = true;
  try {
    ({stdout, stderr} = await exec(inDir, 'git', ['status', '-s']));
  } catch (e) {
    // Grab command execution results from exception info.
    ({stdout, stderr} = e);
    isRepo =
        stderr === undefined || stderr.indexOf('Not a git repository') === -1;
  }
  if (!isRepo) {
    console.warn(`Not a git repo, proceeding.`);
  }
  if (!options.force && isRepo && (stdout || stderr)) {
    console.error(
        `Git repo is dirty. Check all changes in to source control and ` +
        `then try again.`);
    process.exit(1);
  }

  for (const rawMapping of options['dependency-mapping']) {
    try {
      const [bowerName, npmName, npmSemver] =
          parseDependencyMappingInput(rawMapping);
      saveDependencyMapping(bowerName, npmName, npmSemver);
    } catch (err) {
      console.error(err.message);
      process.exit(1);
    }
  }

  // TODO: each file is not always needed, refactor to optimize loading
  let inBowerJson: {name: string, version: string, main: string}|undefined;
  let inPackageJson: {name: string, version: string}|undefined;
  let outPackageJson: {name: string, version: string}|undefined;
  try {
    outPackageJson = await fse.readJSON(path.join(outDir, 'package.json'));
  } catch (e) {
    // do nothing
  }
  try {
    if (options.in) {
      inPackageJson = await fse.readJson(path.join(inDir, 'package.json'));
    }
  } catch (e) {
    // do nothing
  }
  try {
    inBowerJson = await fse.readJson(path.join(inDir, 'bower.json'));
  } catch (e) {
    // do nothing
  }

  let npmPackageName = options['npm-name'] ||
      inPackageJson && inPackageJson.name ||
      outPackageJson && outPackageJson.name;
  let npmPackageVersion = options['npm-version'] ||
      inPackageJson && inPackageJson.version ||
      outPackageJson && outPackageJson.version;

  // Prompt user for new package name & version if none exists
  // TODO(fks) 07-19-2017: Add option to suppress prompts
  if (typeof npmPackageName !== 'string') {
    npmPackageName = (await inquirer.prompt([{
                       type: 'input',
                       name: 'npm-name',
                       message: 'npm package name?',
                       default: inBowerJson && `@polymer/${inBowerJson.name}`,
                     }]))['npm-name'] as string;
  }

  if (typeof npmPackageVersion !== 'string') {
    npmPackageVersion =
        (await inquirer.prompt([{
          type: 'input',
          name: 'npm-version',
          message: 'npm package version?',
          default: inBowerJson && semver.inc(inBowerJson.version, 'major'),
        }]))['npm-version'] as string;
  }

  logStep(1, 2, '🌀', `Converting Package...`);
  console.log(`Out directory: ${outDir}`);
  await convertPackage({
    inDir: inDir,
    outDir: outDir,
    excludes: options.exclude,
    deleteFiles: options['delete-files'],
    namespaces: options.namespace,
    npmImportStyle: options['import-style'],
    packageName: npmPackageName.toLowerCase(),
    packageVersion: npmPackageVersion,
    cleanOutDir: options.clean!!,
    addImportMeta: options['add-import-meta'],
//.........这里部分代码省略.........

  test('should allow cache file to be written', async () => {
    const cache = getCache<string>(CACHE_KEY);
    await cache.write('Some test data');

    await expect(fs.readJSON(CACHE_PATH)).resolves.toEqual('Some test data');
  });