How to use commander - 10 common examples

commander.scope = commander.args.find(el => el.endsWith(".json")) || "scope.json";
        commander.file = commander.args.find(el => el.endsWith(".html")) || "index.html";
    }
}

// Convert different options into an object
const options = {
    "contrib": commander.contribute
    // Might add other secondary options to this
};

const scope = JSON.parse(fs.readFileSync(commander.scope, "utf-8"));

if(!commander.html && !commander.css && !commander.url){
    // Let's parse the HTML
    htmlAnalyzer.analyzeFile(commander.file, scope, (e, d) => {
        if (e) {
            console.error(e);
            return false;
        }
        const report = d;
        console.log("HTML Report:");
        // report =[ {"browser " / "filename" / "line" / "column" / "featureName" / "minVer"]
        report.sort(reportHelpers.sortReport);
        report.map(reportHelpers.printReportLine);
    }, options);


    // Let's get the CSS inside the site
    cssExtracter.analyzeFile(commander.file, (e, acc) => {
        acc.map(async (block) => {
            cssAnalyzer.analyzeString(await block.content, scope, block.lineShift, block.fileName, (e, d) => {

const package = require('./package.json')

program
  .version(package.version)
  .option('-c, --connect ', 'Connect to a host, (Supports IP:port and hostname:port.)')
  .option('-l, --listen ', 'Automatically accept connections on this port.')
  .option('-i, --input [device-name]', 'Input device, (Leave empty to use the default recording device.)')
  .option('-o, --output [device-name]', 'Output device, (Leave empty to use the default playback device.)')
  .option('-a, --channels [count]', 'Number of channels 1=mono; 2=stereo (Leave empty to use 1.)',1)
  //.option('-s, --speaker-enabled', 'Speaker enabled initially. (true or false)', true)
  //.option('-m, --microphone-enabled', 'Microphone enabled initially. (true or false)', true)
  .parse(process.argv)

console.log('--connect: ' + program.connect)
console.log('--listen: ' + program.listen)
console.log('--input: ' + program.input)
console.log('--output: ' + program.output)

const mode = !program.connect ? 'listen' : 'connect'

let speakerConfig = { // | aplay -D plughw:NVidia,7
    //device: program.output, // -D plughw:NVidia,7
    channels: 2,
    bitDepth: 16,
    sampleRate: 44100,
    signed: true
}
if (program.output)
    speakerConfig.device = program.output

let micConfig = {       // arecord -D hw:0,0 -f S16_LE -r 44100 -c 2
    //device: program.input,    // -D hw:0,0

console.log('Account already created! Try starting the operator with `operator start`')
      return
    }
    // There are no accounts so create one!
    const newAccount = await createAccount(cmd.plaintext)
    if (newAccount === undefined) {
      return
    }
    console.log('Created new account with address:', newAccount.address.green)
    const keystorePath = path.join(keystoreDirectory, new Date().toISOString() + '--' + newAccount.address)
    console.log('Saving encrypted account to:', keystorePath.yellow)
    fs.writeFileSync(keystorePath, newAccount.keystoreFile)
    // Create new password file
  })

program
  .command('list')
  .description('list all accounts')
  .action((none, cmd) => {
    let counter = 0
    if (!fs.existsSync(keystoreDirectory)) {
      console.log('No accounts found!')
      return
    }
    fs.readdirSync(keystoreDirectory).forEach(file => {
      console.log('Account #' + counter++ + ':', file.split('--')[1])
    })
  })

async function createAccount (isPlaintext) {
  if (isPlaintext) {
    const newAccount = web3.eth.accounts.create()

// @flow
import ordinanceFormatJp, { format } from '../src/index'
import fs from 'fs'
import Program from 'commander'
import { version } from '../package.json'

let filePath
Program
  .version(version)
  .usage(' options')
  .action(function (path) {
     filePath = path
  })

Program
  .option('--nostyle', 'outputs only the HTML structure without the style tag')
  .option('--elementId ', 'id name of the top level div tag')

Program.parse(process.argv)

if (typeof filePath === 'undefined') {
   console.error('no filePath given!')
   process.exit(1)
}

let styled = !Program.nostyle,
    elementId = Program.elementId || 'corp-site-pp'
const markdownText = fs.readFileSync(filePath, 'utf8')
const html = format(markdownText, { standalone: styled, elementId: elementId })

console.log(html)

.action( (env, options) => {
    let config = readConfig(prog.config);
    let actions = new BaseAction(config);
    actions.init();
  });


/*
// handling undefined command
prog.command('*')
  .action(function(env){
    console.log('deploying "%s"', env);
  });
*/

prog.on('--help', function(){
  /*
  console.log('  Examples:');
  console.log('');
  console.log('    $ custom-help --help');
  console.log('    $ custom-help -h');
  console.log('');
  */
});
prog.parse(process.argv);

// vim:sw=2:ts=2:sts=2:et:filetype=typescript:

sslOptions: fileConfig.sslOptions,
                quiet: commander.quiet || fileConfig.quiet
            },
            extraVars
        );
    } catch (e) {
        if (e.code === 'ENOENT') {
            console.error("Cannot read file '" + e.path + "'.");
        } else {
            // TODO: This needs to improve
            throw e;
        }
        process.exit(1);
    }

    var port = commander.port || fileConfig.port || 3000;
    server.on('error', function (e) {
        if (e.code === 'EADDRINUSE') {
            console.error("Couldn't listen in port " + port + ", aborting.");
        }
    });
    server.listen(port, function() {
        if (commander.quiet) {
            return;
        }
        var protocol = fileConfig.secure ? "https" : "http";
        var adminUrl = protocol + "://localhost:" + port + "/robohydra-admin";
        console.log("RoboHydra ready on port %d - Admin URL: %s",
                    port, adminUrl);
    });
}());

process.exit(1);
}

const genesisBlock = require(genesis);

let extraConfig = {};
if (program.extraConfig) {
  // tslint:disable-next-line no-var-requires
  extraConfig = require(program.extraConfig);
}
let appConfig: AppConfig = extend(
  true,
  {},
  configCreator(
    program.config
      ? program.config
      : `${process.env.PWD}/etc/${program.net}/config.json`,
    modules
  ),
  extraConfig
);

if (program.port) {
  appConfig.port = parseInt(program.port, 10);
  if (isNaN(appConfig.port)) {
    console.error('Invalid port');
    process.exit(1);
  }
}
if (program.address) {
  appConfig.address = program.address;
}

/* eslint-disable no-console*/
require('epipebomb')();  // Allow piping to 'head'

var Command = require('commander').Command,
    storage = require('../src/server/storage/storage'),
    Logger = require('../src/server/logger'),
    Projects = require('../src/server/storage/projects'),
    logger = new Logger('netsblox:cli:persist'),
    program = new Command();

program
    .arguments(' ')
    .parse(process.argv);

if (!program.args.length === 2) {
    console.log('usage: netsblox persist  ');
    process.exit(1);
}

storage.connect()
    .then(() => {
        logger.trace('About to print projects for ' + program.args[0]);

        return Projects.get(program.args[0], program.args[1]);
    })

/* eslint-disable no-console*/
require('epipebomb')();  // Allow piping to 'head'

var Command = require('commander').Command,
    Logger = require('../src/server/logger'),
    Projects = require('../src/server/storage/projects'),
    logger = new Logger('netsblox:cli:export'),
    fs = require('fs'),
    program = new Command(),
    runWithStorage = require('./utils').runWithStorage;

program
    .arguments(' ')
    .parse(process.argv);

if (program.args.length !== 2) {
    console.log('usage: netsblox export-project  ');
    process.exit(1);
}

var [owner, name] = program.args;

async function exportProject(owner, projectName) {
    logger.trace(`About to get project: ${owner} ${projectName}`);
    const project = await Projects.get(owner, projectName);

console.log('');
  console.log('    $ pac -P install');
  console.log('    $ pac grunt');
  console.log('    $ pac -s bower install');
  console.log('    $ pac -s bower angular');
  console.log('');
});

program.parse(process.argv);

// Determine which strategy to use
var strategy;
if (program.strategy === 'bower') {
  strategy = new BowerStrategy({
    mode: program.production ? 'production' : 'develop',
    verbose: program.verbose ? true : false
  });
} else if (program.strategy === 'npm') {
  strategy = new NpmStrategy({
    mode: program.production ? 'production' : 'develop',
    verbose: program.verbose ? true : false
  });
} else {
  console.error('Specified strategy is not supported');
  process.exit(1);
}

if (program.install) {
  strategy.install();
} else {
  if (program.args >= 1) {
    program.args.forEach(function(module) {