@bemoje/cli 0.0.4 → 0.0.6

package/src/arg/ArgumentBuilder.test.ts

@@ -0,0 +1,102 @@
+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

@@ -0,0 +1,47 @@
+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

@@ -0,0 +1,53 @@
+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

@@ -0,0 +1,14 @@
+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

@@ -0,0 +1,60 @@
+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

@@ -0,0 +1,33 @@
+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

@@ -0,0 +1,80 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+import { ArgumentValidatorSelector } from './ArgumentValidatorSelector'
+import { CommandBuilder } from '../cmd/CommandBuilder'
+
+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 = new CommandBuilder('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 = new CommandBuilder('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 = new CommandBuilder('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 run = new CommandBuilder('t', (c) => {
+      c.argument('<str>', (o) => o.validator.isString())
+      c.argument('<ints...>', (o) => o.parser.integer().validator.isIntegerArray())
+      c.action(() => {})
+    })
+    expect(() => run.$.parse('abc 3 4 5'.split(' '), { from: 'user' })).not.toThrow()
+  })
+
+  it('should throw if invalid', () => {
+    const run = new CommandBuilder('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 = new CommandBuilder('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 = new CommandBuilder('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

@@ -0,0 +1,14 @@
+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
+  }
+}