@writ/command NPM

@writ/command

Mime, Command parameter parsing for building cli applications. 中文

Features

elegant command line parameter parsing
configure the build command line application

Install

install node.js, Now, install and use this project

   npm install @writ/command

Usage

Project Structure

   ├─ example/      `usage examples`
   ├─ index.js      `entry points`
   ├─ test/         `test code`
   ├─ .gitignore    `git ignore`
   ├─ .eslintrc.js  `eslint format config`
   ├─ license       `agreement that`
   ├─ package.json  `table of modules with npm`
   └─ README.md     `description`

Usage You can see my example here

Configuration using function types, You can do some work in the functions

   #! /usr/bin/env node
   const Command = require('@writ/command');

   new Command(function(command) {
      return require('../.clirc');
   }).start();

Configuration using object types

   #! /usr/bin/env node
   const Command = require('@writ/command');

   new Command({
      root: '.',
      order: {
         help: {
               param: [],
               alias: ['h', '-h']
         },
         version: {
               alias: [
                  'v',
                  'V',
                  '-v',
                  '--version'
               ]
         }
      },
      action: {
         help: require('../src/help'),
         version: require('../src/version')
      }
   }).start();

Configuration using string types

   #! /usr/bin/env node

   const Command = require('../../src');
   new Command('../example/.clirc.js').start();

Options example

options.rootstring your cli-app root dir
options.actionstring|object command handler, it is a dirname or an object

options.orderobject command detail info

   // for example: 
   module.exports = {
      root: '.',
      action: {
         example(param) {
               if (param.all) {
                  process.stdout.write(`All: ${param.all.join(' ')}\n`);
               }
               if (param.bail) {
                  process.stdout.write(`Bail: ${param.bail.join(' ')}\n`);
               }
               if (param.comment) {
                  process.stdout.write(`Comment: ${param.comment.join(' ')}\n`);
               }
         }
      },
      order: {
         // Declare the 'example` subcommand
         example: {
               // example's alias
               alias: [
                  'ex',
                  '-e'
               ],
               // command parameters, the rule is the '--' beginning refers to the full name of the parameter, the '-' beginning refers to the corresponding abbreviation
               // in a program, or will be converted to the full name, such as the '-a' convert 'param.all = []'
               param: [
                  '--all -a',
                  '--bail -b',
                  '--comment -c'
               ]
         }
      }
   }

The above configuration implements a child command <main-command-name> example param, a command only alias and param two properties, and are currently only supports arrays, param statement for eachparamter in the code: --<name> -<alias>, all will be used in the corresponding action, referred to as "only to belong to convenient

API intro In each action, this always points to your Command instances, So, you can use Command's methods and properties in each action.
- rootstring your cli-app's root dir
- actRootstring command handler file dir
- actionobject commamd handlers
- ordersobject command set
- runtimeobject currently executing command's infomation
- start(argv<array>) start loader
- whoami(enter<string>) find currently command's name
- parse(param<array|*>) parse currently command's options
- invalid() print invaild infomation