@bemoje/cli 0.0.5 → 0.0.8

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
-  }
-}

package/src/arg/ArgumentValidatorSelector.test.ts

@@ -1,80 +0,0 @@
-/* eslint-disable @typescript-eslint/no-unused-vars */
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-import { ArgumentValidatorSelector } from './ArgumentValidatorSelector'
-import { CLI } from '../cmd/CLI'
-
-describe(ArgumentValidatorSelector.name, () => {
-  jest.spyOn(process, 'exit').mockImplementation((code?: number) => {
-    throw new Error('process.exit(' + code ?? '' + ') was called')
-  })
-
-  it('should validate string, number, integer', () => {
-    const run = CLI('t', (c) => {
-      c.argument('<str>', (a) => a.parser.string().validator.isString())
-      c.argument('<num>', (a) => a.parser.number().validator.isNumber())
-      c.argument('<int>', (a) => a.parser.integer().validator.isInteger())
-      c.action(() => {})
-    })
-    expect(() => run().parse(['str', '3.2', '3'], { from: 'user' })).not.toThrow()
-  })
-
-  it('should throw if invalid', () => {
-    const run = CLI('t', (c) => {
-      c.argument('<int>', (a) => a.parser.number().validator.isInteger())
-      c.action(() => {})
-      c.throwInsteadOfProcessExit()
-    })
-    expect(() => run().parse(['3.2'], { from: 'user' })).toThrow()
-  })
-
-  it('should validate delimited string, number, integer', () => {
-    const run = CLI('t', (c) => {
-      c.argument('<strs>', (a) => a.parser.delimitedStrings().validator.isStringArray())
-      c.argument('<nums>', (a) => a.parser.delimitedNumbers().validator.isNumberArray())
-      c.argument('<ints>', (a) => a.parser.delimitedIntegers().validator.isIntegerArray())
-      c.action(() => {})
-    })
-    expect(() => run().parse(['a,b', '3.1,4.1', '3,4,5'], { from: 'user' })).not.toThrow()
-  })
-
-  it('should validate variadic argument', () => {
-    const init = CLI('t', (c) => {
-      c.argument('<str>', (o) => o.validator.isString())
-      c.argument('<ints...>', (o) => o.parser.integer().validator.isIntegerArray())
-      c.action(() => {})
-    })
-    expect(() => init().parse('abc 3 4 5'.split(' '), { from: 'user' })).not.toThrow()
-  })
-
-  it('should throw if invalid', () => {
-    const run = CLI('t', (c) => {
-      c.argument('<ints>', (a) => a.parser.delimitedIntegers().validator.isIntegerArray())
-      c.action(() => {})
-      c.throwInsteadOfProcessExit()
-    })
-    expect(() => run().parse(['3,q,7'], { from: 'user' })).toThrow()
-  })
-
-  it('should validate with custom validator', () => {
-    const run = CLI('t', (c) => {
-      c.argument('<arg>', (a) => a.validator.custom((arg) => arg === 'abc'))
-      c.action(() => {})
-      c.throwInsteadOfProcessExit()
-    })
-    expect(() => run().parse(['ab'], { from: 'user' })).toThrow()
-  })
-
-  it('should validate with multiple validators', () => {
-    const run = CLI('t', (c) => {
-      c.argument('<arg>', (a) => {
-        a.validator.custom((arg: string) => arg !== 'abc')
-        a.validator.custom((arg: string) => arg.length >= 3)
-      })
-      c.action(() => {})
-      c.throwInsteadOfProcessExit()
-    })
-    expect(() => run().parse(['ab'], { from: 'user' })).toThrow()
-    expect(() => run().parse(['abc'], { from: 'user' })).toThrow()
-    expect(() => run().parse(['abcd'], { from: 'user' })).not.toThrow()
-  })
-})

package/src/arg/ArgumentValidatorSelector.ts

@@ -1,14 +0,0 @@
-import { ArgumentBuilder } from './ArgumentBuilder'
-import { arrLast } from '../util/array/arrLast'
-import type { TValidator } from '../util/types/TValidator'
-import { ValidatorSelector } from '../core/ValidatorSelector'
-
-export class ArgumentValidatorSelector extends ValidatorSelector<ArgumentBuilder> {
-  constructor(builder: ArgumentBuilder) {
-    super(builder)
-  }
-  custom<T>(validator: TValidator<T>) {
-    arrLast(this.builder.cmd.meta.argValidators).push(validator)
-    return this.builder
-  }
-}

package/src/cmd/CLI.test.ts

@@ -1,14 +0,0 @@
-import { CLI } from './CLI'
-
-describe(CLI.name, () => {
-  it('should not initialize immediately', () => {
-    let hasRun = false
-    const init = CLI('test', () => {
-      hasRun = true
-    })
-    expect(typeof init).toBe('function')
-    expect(hasRun).toBe(false)
-    init()
-    expect(hasRun).toBe(true)
-  })
-})

package/src/cmd/CLI.ts

@@ -1,13 +0,0 @@
-import { CommandBuilder } from './CommandBuilder'
-
-export function CLI(name: string, callback: (this: CommandBuilder, cmd: CommandBuilder) => void) {
-  return () => new CommandBuilder(name, callback).commander
-}
-
-/*
-
-TODO: should return a class that offers:
-- command
-- main
-- action
-*/