@bemoje/cli 0.0.6 → 0.0.8

package/src/_example/CommandBuilder.example.ts

@@ -1,92 +0,0 @@
-import { CommandBuilder } from '../cmd/CommandBuilder'
-import { isBoolean } from '../util/validation/isBoolean'
-import { parseBoolean } from '../util/string-parsers/parseBoolean'
-
-console.time('load')
-
-const cli = new CommandBuilder('demo', (c) => {
-  c.version('0.0.1')
-  c.description('A CLI example')
-  c.setRecommended()
-  // c.action(() => {})
-
-  c.command('hello', (h) => {
-    h.description('just prints hello')
-    h.argument('[name]')
-    h.action((name?: string) => {
-      console.log('hello ' + name)
-    })
-    h.preset('benja', {
-      description: 'Benjamin',
-      args: ['Benjamin'],
-    })
-    h.preset('thomas', {
-      description: 'Thomas',
-      args: ['Thomas'],
-    })
-  })
-
-  c.command('info', (i) => {
-    i.description('enter info about yourself')
-    i.argument('[name]', (a) => {
-      a.description('Your name')
-    })
-
-    i.argument('[friends]', (a) => {
-      a.description('Comma-delimited list of friends')
-      a.parser.delimitedStrings(',')
-      a.validator.isStringArray()
-    })
-
-    i.argument('[nums...]', (a) => {
-      a.description('Your favorite numbers between 0 and 4')
-      a.choices(['0', '1', '2', '3', '4'])
-      a.parser.integer()
-      a.validator.isIntegerArray()
-    })
-
-    i.option('--age [years]', (o) => {
-      o.description('Your age in years.')
-      o.parser.integer()
-      o.validator.isInteger()
-      o.validator.custom(function isAdult(age: unknown) {
-        return (age as number) >= 18
-      })
-    })
-
-    i.action((name, friends, nums, opts) => {
-      console.log({ name, friends, nums, ...opts })
-    })
-
-    i.config('inSchool', {
-      description: 'whether you are attending school',
-      defaultValue: true,
-      parse: parseBoolean,
-      validate: isBoolean,
-    })
-
-    i.preset('benjabob', {
-      description: 'Benjamin',
-      presets: ['old'],
-      args: ['Benjamin', ['Thomas', 'Lasse']],
-      options: { age: 35 },
-    })
-    i.preset('adult', {
-      description: 'Age is 18',
-      options: { age: 18 },
-    })
-    i.preset('old', {
-      description: 'Age is 35',
-      options: { age: 35 },
-    })
-  })
-
-  c.command('nothing', (n) => {
-    n
-  })
-})
-console.timeEnd('load')
-
-console.time('exec')
-cli.$.parse()
-console.timeEnd('exec')

package/src/_example/CommandBuilder.example2.ts

@@ -1,30 +0,0 @@
-import { CommandBuilder } from '../cmd/CommandBuilder'
-
-console.time('load')
-
-const cli = new CommandBuilder('demo', (c) => {
-  c.version('0.0.1')
-  c.description('A CLI example')
-  c.setRecommended()
-  c.command('nothing', function (this: CommandBuilder) {
-    this.features
-  })
-  c.option('--opt1', 'opt1')
-  c.option('--opt2', 'opt2')
-  c.action((opts, cmd) => {
-    cmd.db.appData.update('count1', (c: number) => c + 1)
-    console.log(cmd.db.appData.get())
-  })
-
-  c.appData('count1', { defaultValue: 0 })
-  c.appData('count2', { defaultValue: 0 })
-  console.log(c.dataFilepath)
-})
-console.timeEnd('load')
-
-console.time('init')
-console.timeEnd('init')
-
-console.time('exec')
-cli.$.parse()
-console.timeEnd('exec')

package/src/_example/bFindIn.ts

@@ -1,200 +0,0 @@
-import { CommandBuilder } from '../cmd/CommandBuilder'
-import { execInherit } from '../util/node/execInherit'
-import { strSplitCamelCase } from '../util/string/strSplitCamelCase'
-
-console.time('load')
-
-const cli = new CommandBuilder('bFindIn', (b) => {
-  b.setRecommended()
-  b.version('0.0.1')
-  b.description(
-    [
-      "Search for 'PATTERN' inside files in 'DIRPATH'.",
-      '  Can search inside zip and binary files - and more.',
-      '',
-      "This is a wrapper for 'ag' which needs to be installed.",
-      '  https://github.com/JFLarvoire/the_silver_searcher',
-      '',
-      'Example Usage:',
-      `  ${b.name} matches keyword ./src`,
-      `  ${b.name} paths keyword --depth=1`,
-      `  ${b.name} file keyword readme.md --ignore-case`,
-    ].join('\n')
-  )
-
-  b.argument('<pattern>', 'search pattern')
-  b.argument('[dirpath]', 'dirpath to search')
-  // pattern settings
-  b.option('-i, --ignore-case', 'Case-insensitive')
-  b.option('-s, --case-sensitive', 'Case-sensitive.')
-  b.option('-Q, --literal', 'Do not parse PATTERN as a regular expression')
-  b.option('-m, --max-count <NUM>', (o) => {
-    o.description('Skip the rest of a file after NUM matches.')
-    o.parser.integer()
-    o.default(10000)
-  })
-  b.option('-w, --word-regexp', 'Only match whole words')
-  b.option('--invert-match', 'Match anything except PATTERN')
-  // navigation patterns
-  b.option('--ignore <names>', (o) => {
-    o.description('Comma-delimited list of dirnames to ignore')
-    o.parser.delimitedStrings(',')
-  })
-  b.option('-U, --skip-vcs-ignores', 'Ignore VCS ignore files (.gitignore, .hgignore; still obey .ignore)')
-  // directory selection
-  b.option('--depth <n>', (o) => {
-    o.description('Max directory depth.')
-    o.parser.integer()
-    o.default(25)
-  })
-  b.option('-f, --follow', 'Follow symlinks')
-  b.option('--one-device', 'Do not follow links to other devices.')
-  b.option('--path-to-ignore <PATH>', 'Filepath to file with paths to ignore.')
-  // file selection
-  b.option(
-    '-u, --unrestricted',
-    'Search all files (ignore .ignore, .gitignore, etc.; searches binary and hidden files as well).'
-  )
-  b.option(
-    '-z, --search-zip',
-    'Search contents of compressed (e.g., gzip) files. Note that Windows zip files are not supported.'
-  )
-  b.option('-a, --all-types', 'Search all files (does not include hidden files or patterns from ignore files)')
-  b.option('-t, --all-text', 'Search all text files (does not include hidden files)')
-  b.option('--ext <file-extensions>', (o) => {
-    o.description('Comma-delimited list of file extensions to include.')
-    o.parser.custom((string: string) => {
-      const arr = string
-        .split(',')
-        .map((s) => s.trim())
-        .filter(Boolean)
-      if (arr.length === 1) return '"\\.' + arr[0] + '$"'
-      return '"\\.(' + arr.join('|') + ')$"'
-    })
-  })
-  // output modes
-  b.option('--files-with-matches', 'Only print filenames that contain matches (do not print the matching lines)')
-  b.option('--silent', 'Suppress all log messages, including errors')
-  b.option('--stats', 'Print stats (files scanned, time taken, etc.)')
-  b.option('--stats-only', 'Print stats and nothing else.')
-  // context
-  b.option('-B, --before <lines>', (o) => {
-    o.description('Print lines before match')
-    o.default(0)
-    o.parser.integer()
-  })
-  b.option('-A, --after <lines>', (o) => {
-    o.description('Print lines after match')
-    o.default(0)
-    o.parser.integer()
-  })
-  b.option('--nobreak', 'Disable printing newlines between matches in different files')
-  b.option('-W, --width <n>', (o) => {
-    o.description('Truncate match lines after n characters.')
-    o.parser.integer()
-  })
-  b.option('--column', 'Print column numbers in results')
-  b.option('--nonumbers', 'Print line numbers. Default is to omit line numbers when searching streams')
-  b.option('--filename', 'Print file names (Enabled unless searching a single file)')
-  b.option('--print-all-files', 'Print headings for all files searched, even those that do not contain matches')
-  b.option('-o, --only-matching', 'Prints only the matching part of the lines')
-  b.option('--print-long-lines', 'Print matches on very long lines (Default: >2k characters)')
-  b.option('-C, --context <lines>', (o) => {
-    o.description('Print lines before and after matches')
-    o.default(0)
-    o.parser.integer()
-  })
-  b.option('-H, --noheading', "Disable printing file names before each file's matches")
-  b.option('-c, --count', 'Only print file match counts. (Not always equal to matching lines count)')
-  // misc
-  b.option('-g, --filename-pattern <pattern>', 'Print filenames matching PATTERN')
-  b.option('-L, --files-without-matches', 'Only print filenames that do not contain matches')
-  b.option('--passthrough', 'When searching a stream, print all lines even if they do not match')
-  b.option('-0, --print0', "Separate filenames with null (for 'xargs -0')")
-  b.option('--ackmate', 'Print results in AckMate-parseable format')
-  b.option('--vimgrep', 'Print results like :vimgrep /pattern/g would in vim (reports every line match)')
-  // teminal colors
-  b.option('--nocolor', 'Disable printing color codes in results')
-  b.option('--color-line-number <cc>', (o) => {
-    o.description('Color codes for line numbers')
-    o.default('1;33')
-  })
-  b.option('--color-match <cc>', (o) => {
-    o.description('Color codes for result match numbers')
-    o.default('30;43')
-  })
-  b.option('--color-path <cc>', (o) => {
-    o.description('Color codes for path names')
-    o.default('1;32')
-  })
-  b.option('--color-win-ansi', 'Always use ANSI colors in Windows (except pager/pipe remain ANSI)')
-
-  ////////////////
-
-  b.action(async (pattern, dirpath, opts) => {
-    const args: string[] = []
-    for (const [k, value] of Object.entries(opts)) {
-      if (k === 'debug') continue
-      let key = strSplitCamelCase(k)
-        .map((s) => s.trim())
-        .join('-')
-        .toLowerCase()
-      if (key === 'ext') key = 'file-search-regex'
-
-      if (value == null || value === false) {
-        continue
-      }
-      if (b.options.find((o) => o.attributeName() === k)?.defaultValue === value) {
-        continue
-      }
-      if (value === true) {
-        args.push(`--${key}`)
-        continue
-      }
-      args.push(`--${key} "${value}"`)
-    }
-    const cmd = `ag ${args.join(' ')} ${pattern} ${dirpath || ''}`.trim()
-    console.log({ pattern, dirpath, opts, cmd })
-    await execInherit(cmd)
-  })
-
-  b.preset('#matches', {
-    description: 'Print matches found in each file',
-    options: { count: false, numbers: true, column: true, printLongLines: false, onlyMatching: true, width: 100 },
-  })
-  b.preset('#paths', {
-    description: 'Print only paths to files with matches',
-    options: { paths: true, maxCount: 1, silent: true },
-  })
-  b.preset('#bin', {
-    description: 'Search everything, including zipped, binary, and hidden files.',
-    options: {
-      unrestricted: true,
-      searchBinary: true,
-      searchZip: true,
-      hidden: true,
-      printLongLines: true,
-    },
-  })
-  b.preset('#text', {
-    description: 'Search all text files.',
-    options: {
-      allText: true,
-    },
-  })
-  b.preset('#ts', {
-    description: 'Search source code in a js/ts repository.',
-    args: [null, 'C:/Users/bemoj/repos'],
-    options: {
-      ext: '\\.(ts|tsx|json|js|jsx|md|css|html|txt)$',
-      ignore: 'node_modules',
-    },
-  })
-
-  ////////////////
-})
-console.timeEnd('load')
-
-console.time('exec')
-cli.$.parse()
-console.timeEnd('exec')

package/src/arg/ArgumentBuilder.test.ts

@@ -1,102 +0,0 @@
-import { Argument } from '@commander-js/extra-typings'
-import { ArgumentBuilder } from './ArgumentBuilder'
-import { ArgumentParserSelector } from './ArgumentParserSelector'
-import { ArgumentReader } from './ArgumentReader'
-import { ArgumentValidatorSelector } from './ArgumentValidatorSelector'
-import { CommandBuilder } from '../cmd/CommandBuilder'
-
-describe(ArgumentBuilder.name, () => {
-  it('should add commander argument to commander command instance', () => {
-    new CommandBuilder('t', (c) => {
-      const spy = jest.spyOn(c.$, 'addArgument')
-      c.argument('[arg]', (a) => {
-        expect(spy).toBeCalledWith(a.$)
-      })
-    })
-  })
-
-  describe('constructor', () => {
-    it('$ should return an Argument instance', () => {
-      const o = new ArgumentBuilder(new CommandBuilder('t'), '[arg]')
-      expect(o.$).toBeInstanceOf(Argument)
-    })
-
-    it('get should return an ArgumentReader instance', () => {
-      const o = new ArgumentBuilder(new CommandBuilder('t'), '[arg]')
-      expect(o.get).toBeInstanceOf(ArgumentReader)
-    })
-
-    it('name', () => {
-      new CommandBuilder('t', (c) => {
-        c.argument('[arg]', (a) => {
-          expect(a.$.name()).toBe('arg')
-        })
-      })
-    })
-  })
-
-  describe('description', () => {
-    it('set inside callback', () => {
-      new CommandBuilder('t', (c) => {
-        c.argument('[arg]', (a) => {
-          expect(a.description('abc')).toBe(a)
-          expect(a.$.description).toBe('abc')
-        })
-        const arg = c.arguments[0]
-        expect(arg.description).toBe('abc')
-      })
-    })
-
-    it('set as second argument', () => {
-      new CommandBuilder('t', (c) => {
-        c.argument('[arg]', 'abc')
-        const arg = c.arguments[0]
-        expect(arg.description).toBe('abc')
-      })
-    })
-
-    it('allow no description', () => {
-      new CommandBuilder('t', (c) => {
-        expect(() => c.argument('[arg]')).not.toThrow()
-      })
-    })
-  })
-
-  describe('default', () => {
-    it('should call commander default method', () => {
-      new CommandBuilder('t', (c) => {
-        c.argument('[arg]', (a) => {
-          const spy = jest.spyOn(a.$, 'default')
-          expect(a.default('abc')).toBe(a)
-          expect(spy).toHaveBeenCalledTimes(1)
-        })
-      })
-    })
-  })
-
-  describe('choices', () => {
-    it('should call commander choices method', () => {
-      new CommandBuilder('t', (c) => {
-        c.argument('[arg]', (a) => {
-          const spy = jest.spyOn(a.$, 'choices')
-          expect(a.choices(['a', 'b'])).toBe(a)
-          expect(spy).toHaveBeenCalledWith(['a', 'b'])
-        })
-      })
-    })
-  })
-
-  describe('parser', () => {
-    it('should return a ArgumentParserSelector instance', () => {
-      const arg = new ArgumentBuilder(new CommandBuilder('t'), '[arg]')
-      expect(arg.parser).toBeInstanceOf(ArgumentParserSelector)
-    })
-  })
-
-  describe('validator', () => {
-    it('should return a ArgumentValidatorSelector instance', () => {
-      const arg = new ArgumentBuilder(new CommandBuilder('t'), '[arg]')
-      expect(arg.validator).toBeInstanceOf(ArgumentValidatorSelector)
-    })
-  })
-})

package/src/arg/ArgumentBuilder.ts

@@ -1,47 +0,0 @@
-import { Argument } from '@commander-js/extra-typings'
-import { ArgumentParserSelector } from './ArgumentParserSelector'
-import { ArgumentReader } from './ArgumentReader'
-import { ArgumentValidatorSelector } from './ArgumentValidatorSelector'
-import { CommandBuilder } from '../cmd/CommandBuilder'
-import { realizeLazyProperty } from '../util/object/realizeLazyProperty'
-
-/**
- * Wrapper around the @see Argument class from 'commander'.
- */
-export class ArgumentBuilder {
-  readonly $: Argument
-  readonly index: number
-
-  constructor(readonly cmd: CommandBuilder, name: string) {
-    this.$ = new Argument(name)
-    this.index = cmd.meta.argValidators.length
-    cmd.meta.argValidators[this.index] = []
-  }
-
-  description(string: string) {
-    this.$.description = string
-    return this
-  }
-
-  default(value: unknown, description?: string) {
-    this.$.default(value, description)
-    return this
-  }
-
-  choices(values: readonly string[]) {
-    this.$.choices(values)
-    return this
-  }
-
-  get parser() {
-    return new ArgumentParserSelector(this)
-  }
-
-  get validator() {
-    return new ArgumentValidatorSelector(this)
-  }
-
-  get get() {
-    return realizeLazyProperty(this, 'get', new ArgumentReader(this))
-  }
-}

package/src/arg/ArgumentParserSelector.test.ts

@@ -1,53 +0,0 @@
-import { ArgumentParserSelector } from './ArgumentParserSelector'
-import { CommandBuilder } from '../cmd/CommandBuilder'
-
-describe(ArgumentParserSelector.name, () => {
-  it('should parse string, number, integer', () => {
-    const run = new CommandBuilder('t', (c) => {
-      c.argument('<str>', (a) => a.parser.string())
-      c.argument('<num>', (a) => a.parser.number())
-      c.argument('<int>', (a) => a.parser.integer())
-      c.action((str, num, int) => {
-        expect(str).toBe('str')
-        expect(num).toBe(3.2)
-        expect(int).toBe(3)
-      })
-    })
-    run.$.parse(['str', '3.2', '3'], { from: 'user' })
-  })
-
-  it('should parse variadic argument', () => {
-    const run = new CommandBuilder('t', (c) => {
-      c.argument('<str>', (o) => o.parser.string())
-      c.argument('<ints...>', (o) => o.parser.integer())
-      c.action((str, ints) => {
-        expect(ints).toEqual([3, 4, 5])
-      })
-    })
-    run.$.parse('abc 3 4 5'.split(' '), { from: 'user' })
-  })
-
-  it('should parse delimited string, number, integer', () => {
-    const run = new CommandBuilder('t', (c) => {
-      c.argument('<strs>', (a) => a.parser.delimitedStrings())
-      c.argument('<nums>', (a) => a.parser.delimitedNumbers())
-      c.argument('<ints>', (a) => a.parser.delimitedIntegers())
-      c.action((strs, nums, ints) => {
-        expect(strs).toEqual(['a', 'b'])
-        expect(nums).toEqual([3.1, 4.1])
-        expect(ints).toEqual([3, 4, 5])
-      })
-    })
-    run.$.parse(['a,b', '3.1,4.1', '3,4,5'], { from: 'user' })
-  })
-
-  it('should parse with custom parser', () => {
-    const run = new CommandBuilder('t', (c) => {
-      c.argument('<arg>', (a) => a.parser.custom((s) => s.split('')))
-      c.action((arg) => {
-        expect(arg).toEqual(['a', 'b', 'c'])
-      })
-    })
-    run.$.parse(['abc'], { from: 'user' })
-  })
-})

package/src/arg/ArgumentParserSelector.ts

@@ -1,14 +0,0 @@
-import { ArgumentBuilder } from './ArgumentBuilder'
-import type { JsonValue } from '../util/types/JsonValue'
-import { ParserSelector } from '../core/ParserSelector'
-import type { TStringParser } from '../util/types/TStringParser'
-
-export class ArgumentParserSelector extends ParserSelector<ArgumentBuilder> {
-  constructor(builder: ArgumentBuilder) {
-    super(builder)
-  }
-  custom<T extends JsonValue>(parser: TStringParser<T>) {
-    this.builder.cmd.meta.argParsers[this.builder.index] = parser
-    return this.builder
-  }
-}

package/src/arg/ArgumentReader.test.ts

@@ -1,60 +0,0 @@
-import { ArgumentBuilder } from './ArgumentBuilder'
-import { ArgumentReader } from './ArgumentReader'
-import { CommandBuilder } from '../cmd/CommandBuilder'
-
-describe(ArgumentReader.name, () => {
-  it('should return an ArgumentReader instance', () => {
-    const a = new ArgumentBuilder(new CommandBuilder('t'), '[arg]')
-    expect(a.get).toBeInstanceOf(ArgumentReader)
-  })
-
-  describe('properties', () => {
-    let a = new ArgumentBuilder(new CommandBuilder('t'), '[arg]')
-
-    beforeEach(() => {
-      a = new ArgumentBuilder(new CommandBuilder('t'), '[arg]')
-    })
-
-    it('$', () => {
-      expect(a.get.$).toBe(a.$)
-    })
-
-    it('argument', () => {
-      expect(a.get.argument).toBe(a.$)
-    })
-
-    it('name', () => {
-      const spy = jest.spyOn(a.$, 'name')
-      expect(spy).not.toHaveBeenCalled()
-      a.get.name
-      expect(spy).toHaveBeenCalled()
-    })
-
-    it('choices', () => {
-      a.choices(['a'])
-      expect(a.get.choices).toEqual(a.$.argChoices)
-    })
-
-    it('default', () => {
-      a.default('a')
-      expect(a.get.default).toBe(a.$.defaultValue)
-    })
-
-    it('description', () => {
-      a.description('a')
-      expect(a.get.description).toBe(a.$.description)
-    })
-
-    it('variadic', () => {
-      expect(a.get.variadic).toBe(a.$.variadic)
-    })
-
-    it('required', () => {
-      expect(a.get.required).toBe(a.$.required)
-    })
-
-    it('optional', () => {
-      expect(a.get.optional).toBe(!a.$.required)
-    })
-  })
-})

package/src/arg/ArgumentReader.ts

@@ -1,33 +0,0 @@
-import { ArgumentBuilder } from './ArgumentBuilder'
-
-export class ArgumentReader {
-  constructor(protected readonly parent: ArgumentBuilder) {}
-
-  get $() {
-    return this.parent.$
-  }
-  get argument() {
-    return this.$
-  }
-  get name() {
-    return this.$.name()
-  }
-  get choices() {
-    return this.$.argChoices
-  }
-  get default() {
-    return this.$.defaultValue
-  }
-  get description() {
-    return this.$.description
-  }
-  get variadic() {
-    return this.$.variadic
-  }
-  get required() {
-    return this.$.required
-  }
-  get optional() {
-    return !this.$.required
-  }
-}