TypeScript Command.version方法代碼示例

const createProgramAndRegister = (script: Scripts) => {
	const program = new Command();

	registeredPrograms[script] = program;
	program.version(TOOLS_PKG.version);

	return program;
};

    execute: async (programArgs:string[]) => {

      const program = new Command();

      // Callback for command success
      let onResolve:any;

      // Callback for command rejection
      let onReject:any = () => Promise.reject(Error("Uninitilized rejection throw"));

      // Command execution promise
      const currentCommand = new Promise((resolve, reject) => {
        onResolve = resolve;
        onReject = reject;
      });

      program
        .version(pjson.version)
        .usage('<command> [options]')

        .option('--home <path>', 'Path to Duniter HOME (defaults to "$HOME/.config/duniter").')
        .option('-d, --mdb <name>', 'Database name (defaults to "duniter_default").')

        .option('--autoconf', 'With `config` and `init` commands, will guess the best network and key options witout asking for confirmation')
        .option('--addep <endpoint>', 'With `config` command, add given endpoint to the list of endpoints of this node')
        .option('--remep <endpoint>', 'With `config` command, remove given endpoint to the list of endpoints of this node')

        .option('--cpu <percent>', 'Percent of CPU usage for proof-of-work computation', parsePercent)

        .option('-c, --currency <name>', 'Name of the currency managed by this node.')

        .option('--nostdout', 'Disable stdout printing for `export-bc` command')
        .option('--noshuffle', 'Disable peers shuffling for `sync` command')

        .option('--timeout <milliseconds>', 'Timeout to use when contacting peers', parseInt)
        .option('--httplogs', 'Enable HTTP logs')
        .option('--nohttplogs', 'Disable HTTP logs')
        .option('--isolate', 'Avoid the node to send peering or status informations to the network')
        .option('--forksize <size>', 'Maximum size of fork window', parseInt)
        .option('--memory', 'Memory mode')
      ;

      for (const opt of options) {
        program
          .option(opt.optFormat, opt.optDesc, opt.optParser);
      }

      for (const cmd of commands) {
        program
          .command(cmd.command.name)
          .description(cmd.command.desc)
          .action(async function() {
            const args = Array.from(arguments);
            try {
              const resOfExecution = await cmd.executionCallback.apply(null, [program].concat(args));
              onResolve(resOfExecution);
            } catch (e) {
              onReject(e);
            }
          });
      }

      program
        .on('*', function (cmd:any) {
          console.log("Unknown command '%s'. Try --help for a listing of commands & options.", cmd);
          onResolve();
        });

      program.parse(programArgs);

      if (programArgs.length <= 2) {
        onReject('No command given.');
      }
      return currentCommand;
    }

///<reference path="../typings/yamljs/yamljs.d.ts"/>
import * as Commander from "commander";
import * as Promptly from "promptly";
import * as YAML from "yamljs";

import { JsonConfigurationFileWriter } from "./json-configuration-file-writer";
import { JsonSchemaReader } from "./json-schema-reader";
import { ConfigGenerator } from "./config-generator";

import * as FileSystem from "fs";

let configWriter = new JsonConfigurationFileWriter();

let configurit = new Commander.Command();

configurit
  .version("")
  //.option("-v, --verbose", "Find out what's happening")
  .option("-s, --schema-location [location]", "Where is that schema")
  .option("-o, --output-file [location]", "Where it's gonna be")
  .option("-y, --yaml [location]", "I wants YAML")
  .option("-p, --pretty [location]", "It should be purtteh")
  .parse(process.argv);

let generator = new ConfigGenerator();

let getDetails = (currentConfig?: any) => {
  generator.getUserInput(currentConfig, true, true).then((config: any) => {
    let fileText = "";
    let prettySpacing = 0;

    if (configurit["pretty"]) {

import * as Commander from "commander";
import * as FileSystem from "fs";
import { SemanticVersion } from "./semantic-version";

const semverter = new Commander.Command();

const semverterVersion = FileSystem.readFileSync("./package.json").toJSON().version;

semverter
  .version(semverterVersion)
  .option("-p, --patch", "Iterate the patch version number")
  .parse(process.argv);


let packageJson = FileSystem.readFileSync("./package.json").toJSON();

const version = new SemanticVersion(packageJson.version);

if (semverter["patch"]) {
  version.patch++;
}

packageJson.version = version.toString();

FileSystem.writeFileSync("./package.json2", JSON.stringify(packageJson, null, 3));

const program = new Command();

// TODO
// bootstrap:
// Check whether config.json exists
// If config.json exists, import it
// Ask which categories in .runtimeconfig.json should be imported
//   - Ask which new categories (names) should be created
//   - Ask for the slug for each category
//   - Add name/slug objects to .runtimeconfig.json
// Save .runtimeconfig.json

console.log(`Gettin' spooky 👻  with ${chalk.hex('#fedc5d').bold('poltergeist')}`);

program.version('0.0.0', '-v, --version');

program
  .command('bootstrap [destination]')
  .description('bootstrap project')
  .action(bootstrap);

program
  .command('configure')
  .description('configure project')
  .action(configure);

program
  .command('backup [destination]')
  .option('--firestore', 'backup Firestore')
  .option('--storage', 'backup storage')

async function main() {
    let argv = process.argv;

    let path = require("path");
    let configDir = path.join(process.cwd(), "dist-client/config");
    let gmeConfig = require(configDir);
    let config = gmeConfig.config;
    let MongoURI = require("mongo-uri");
    let Command = require("commander").Command;
    let webgme = require("webgme");

    let logger = webgme.Logger.create("gme:bin:runplugin", config.bin.log);

    let program = new Command();
    let STORAGE_CONSTANTS = webgme.requirejs("common/storage/constants");
    let PluginCliManager = webgme.PluginCliManager;

    webgme.addToRequireJsPaths(config);
    program
        .version("2.2.0")
        .arguments("<pluginName> <projectName>")
        .option("-b, --branchName [string]", "Name of the branch to load and save to.", "master")
        .option("-c, --commitHash [string]", "Commit hash to run from, if set branch will only be used for update.")
        .option("-a, --activeNode [string]", "ID/Path to active node.", "")
        .option("-s, --activeSelection [string]", "IDs/Paths of selected nodes (comma separated with no spaces).",
        (val: string) => {
            return val ? val.split(",") : [];
        })
        .option("-n, --namespace [string]",
        "Namespace the plugin should run under.", "")
        .option("-m, --mongo-database-uri [url]",
        "URI of the MongoDB [default from the configuration file]", config.mongo.uri)
        .option("-u, --user [string]", "the user of the command [if not given we use the default user]",
        config.authentication.guestAccount)
        .option("-o, --owner [string]", "the owner of the project [by default, the user is the owner]")
        .option("-j, --pluginConfigPath [string]",
        "Path to json file with plugin options that should be overwritten.", "")

        .on("--help", () => {
            let env = process.env.NODE_ENV || "default";
            console.log("  Examples:");
            console.log();
            console.log("    $ node run_plugin.js PluginGenerator TestProject");
            console.log("    $ node run_plugin.js PluginGenerator TestProject -b branch1 -j pluginConfig.json");
            console.log("    $ node run_plugin.js MinimalWorkingExample TestProject -a /1/b");
            console.log("    $ node run_plugin.js MinimalWorkingExample TestProject -s /1,/1/c,/d");
            console.log("    $ node run_plugin.js MinimalWorkingExample TestProject -c #123..");
            console.log("    $ node run_plugin.js MinimalWorkingExample TestProject -b b1 -c " +
                "#def8861ca16237e6756ee22d27678d979bd2fcde");
            console.log();
            console.log("  Plugin paths using " + configDir + path.sep + "config." + env + ".js :");
            console.log();
            for (let path of config.plugin.basePaths) {
                console.log(`    "${path}"`);
            }
        })
        .parse(argv);

    if (program.args.length < 2) {
        program.help();
        return Promise.reject(new Error("A project and pluginName must be specified."));
    }

    // this line throws a TypeError for invalid databaseConnectionString
    MongoURI.parse(program.mongoDatabaseUri);

    config.mongo.uri = program.mongoDatabaseUri;

    let pluginName = program.args[0];
    let projectName = program.args[1];
    logger.info(`Executing ${pluginName} plugin on ${projectName} in branch ${program.branchName}`);

    let pluginConfig = {};
    if (program.pluginConfigPath) {
        try {
            pluginConfig = require(path.resolve(program.pluginConfigPath));
        } catch (e) {
            return Promise.reject(e);
        }
    }

    let gmeAuth: any = undefined;
    try {
        gmeAuth = await webgme.getGmeAuth(config);
    } catch (_err) {
        throw new Error("problem with authorization");
    }
    let storage = await webgme.getStorage(logger, config, gmeAuth);
    await storage.openDatabase();

    let params = {
        projectId: "",
        username: program.user
    };
    logger.info("Database is opened.");

    if (program.owner) {
        params.projectId = program.owner + STORAGE_CONSTANTS.PROJECT_ID_SEP + projectName;
    } else {
        params.projectId = program.user + STORAGE_CONSTANTS.PROJECT_ID_SEP + projectName;
//.........這裏部分代碼省略.........