@bemoje/cli 0.0.4 → 0.0.6

package/src/opt/OptionBuilder.test.ts

@@ -0,0 +1,229 @@
+/* eslint-disable @typescript-eslint/no-non-null-assertion */
+import { CommandBuilder } from '../cmd/CommandBuilder'
+import { Option } from '@commander-js/extra-typings'
+import { OptionArgumentParserSelector } from './OptionArgumentParserSelector'
+import { OptionArgumentValidatorSelector } from './OptionArgumentValidatorSelector'
+import { OptionBuilder } from './OptionBuilder'
+import { OptionHelpers } from './OptionHelpers'
+import { OptionReader } from './OptionReader'
+
+describe(OptionBuilder.name, () => {
+  it('should add commander option to commander command instance', () => {
+    new CommandBuilder('t', (c) => {
+      const spy = jest.spyOn(c.$, 'addOption')
+      c.option('-a, --alpha [arg]', (o) => {
+        expect(spy).toBeCalledWith(o.$)
+      })
+    })
+  })
+
+  describe('constructor', () => {
+    it('should set default to true if no arg and long is negated', () => {
+      expect(new OptionBuilder(new CommandBuilder('t'), '--alpha').$.defaultValue).not.toBe(true)
+      expect(new OptionBuilder(new CommandBuilder('t'), '--no-alpha').$.defaultValue).toBe(true)
+    })
+
+    it('$ should return an Option instance', () => {
+      const o = new OptionBuilder(new CommandBuilder('t'), '--alpha')
+      expect(o.$).toBeInstanceOf(Option)
+    })
+
+    it('get should return an OptionReader instance', () => {
+      const o = new OptionBuilder(new CommandBuilder('t'), '--alpha')
+      expect(o.get).toBeInstanceOf(OptionReader)
+    })
+
+    it('name', () => {
+      new CommandBuilder('t', (c) => {
+        c.option('-a, --alpha [arg]', (o) => {
+          c.option('-a, --alpha [arg]', (o) => {
+            expect(o.$.name()).toBe('alpha')
+          })
+        })
+      })
+    })
+  })
+
+  describe('description', () => {
+    it('set inside callback', () => {
+      new CommandBuilder('t', (c) => {
+        c.option('-a, --alpha [arg]', (o) => {
+          o.description('abc')
+          expect(o.$.description).toBe('abc')
+        })
+      })
+    })
+
+    it('set as second argument', () => {
+      new CommandBuilder('t', (c) => {
+        c.option('-a, --alpha [arg]', 'abc')
+        const o = c.options.find((o) => o.long === '--alpha')
+        expect(o!.description).toBe('abc')
+      })
+    })
+
+    it('allow no description', () => {
+      new CommandBuilder('t', (c) => {
+        expect(() => c.option('-a, --alpha [arg]')).not.toThrow()
+      })
+    })
+  })
+
+  it('mandatory', () => {
+    new CommandBuilder('t', (c) => {
+      c.option('--alpha', (o) => {
+        const spy = jest.spyOn(o.$, 'makeOptionMandatory')
+        expect(spy).not.toHaveBeenCalled()
+        expect(o.mandatory()).toBe(o)
+        o.mandatory(true)
+        o.mandatory(false)
+        expect(spy).toHaveBeenCalledTimes(3)
+      })
+    })
+  })
+
+  it('hideHelp', () => {
+    new CommandBuilder('t', (c) => {
+      c.option('--alpha', (o) => {
+        const spy = jest.spyOn(o.$, 'hideHelp')
+        expect(spy).not.toHaveBeenCalled()
+        expect(o.hideHelp()).toBe(o)
+        o.hideHelp(true)
+        o.hideHelp(false)
+        expect(spy).toHaveBeenCalledTimes(3)
+      })
+    })
+  })
+
+  it('hidden', () => {
+    new CommandBuilder('t', (c) => {
+      c.option('--alpha', (o) => {
+        expect(o.hidden(true)).toBe(o)
+        expect(o.$.hidden).toBe(true)
+      })
+    })
+  })
+
+  it('preset', () => {
+    new CommandBuilder('t', (c) => {
+      c.option('--alpha', (o) => {
+        const spy = jest.spyOn(o.$, 'preset')
+        expect(spy).not.toHaveBeenCalled()
+        expect(o.preset(true)).toBe(o)
+        expect(spy).toHaveBeenCalledTimes(1)
+      })
+    })
+  })
+
+  it('default', () => {
+    new CommandBuilder('t', (c) => {
+      c.option('-a, --alpha [arg]', (o) => {
+        const spy = jest.spyOn(o.$, 'default')
+        o.default('abc')
+        expect(o.default('abc', 'desc')).toBe(o)
+        expect(spy).toHaveBeenCalledTimes(2)
+      })
+    })
+  })
+
+  describe('choices', () => {
+    it('should call commander choices method', () => {
+      new CommandBuilder('t', (c) => {
+        c.option('-a, --alpha [arg]', (o) => {
+          const spy = jest.spyOn(o.$, 'choices')
+          o.choices(['a', 'b'])
+          expect(spy).toHaveBeenCalledWith(['a', 'b'])
+        })
+      })
+    })
+
+    it('should throw if has no argument', () => {
+      new CommandBuilder('t', (c) => {
+        c.option('-a, --alpha', (o) => {
+          expect(() => o.choices(['a', 'b'])).toThrow()
+        })
+      })
+    })
+  })
+
+  it('conflicts', () => {
+    new CommandBuilder('t', (c) => {
+      c.option('--alpha', (o) => {
+        const spy = jest.spyOn(o.$, 'conflicts')
+        expect(spy).not.toHaveBeenCalled()
+        o.conflicts('a')
+        expect(o.conflicts(['a'])).toBe(o)
+        expect(spy).toHaveBeenCalledTimes(2)
+      })
+    })
+  })
+
+  it('implies', () => {
+    new CommandBuilder('t', (c) => {
+      c.option('--alpha', (o) => {
+        const spy = jest.spyOn(o.$, 'implies')
+        expect(spy).not.toHaveBeenCalled()
+        expect(o.implies({ beta: true })).toBe(o)
+        expect(spy).toHaveBeenCalledTimes(1)
+      })
+    })
+  })
+
+  it('env', () => {
+    new CommandBuilder('t', (c) => {
+      c.option('--alpha', (o) => {
+        const spy = jest.spyOn(o.$, 'env')
+        expect(spy).not.toHaveBeenCalled()
+        expect(o.env('ENV_VAR')).toBe(o)
+        expect(spy).toHaveBeenCalledTimes(1)
+      })
+    })
+  })
+
+  it('short', () => {
+    new CommandBuilder('t', (c) => {
+      c.option('--alpha', (o) => {
+        const spy = jest.spyOn(OptionHelpers, 'setShort')
+        expect(spy).not.toHaveBeenCalled()
+        expect(o.short('a')).toBe(o)
+        expect(spy).toHaveBeenCalledWith(o.$, 'a')
+      })
+    })
+  })
+
+  describe('parser', () => {
+    it('should return a OptionArgumentParserSelector instance', () => {
+      new CommandBuilder('t', (c) => {
+        c.option('-a, --alpha <arg>', (o) => {
+          expect(o.parser).toBeInstanceOf(OptionArgumentParserSelector)
+        })
+      })
+    })
+
+    it('should throw if option has no argument', () => {
+      new CommandBuilder('t', (c) => {
+        c.option('-a, --alpha', (o) => {
+          expect(() => o.parser).toThrow()
+        })
+      })
+    })
+  })
+
+  describe('validator', () => {
+    it('should return a OptionArgumentValidatorSelector instance', () => {
+      new CommandBuilder('t', (c) => {
+        c.option('-a, --alpha <arg>', (o) => {
+          expect(o.validator).toBeInstanceOf(OptionArgumentValidatorSelector)
+        })
+      })
+    })
+
+    it('should throw if option has no argument', () => {
+      new CommandBuilder('t', (c) => {
+        c.option('-a, --alpha', (o) => {
+          expect(() => o.validator).toThrow()
+        })
+      })
+    })
+  })
+})

package/src/opt/OptionBuilder.ts

@@ -0,0 +1,85 @@
+import { CommandBuilder } from '../cmd/CommandBuilder'
+import { Option } from '@commander-js/extra-typings'
+import { OptionArgumentParserSelector } from './OptionArgumentParserSelector'
+import { OptionArgumentValidatorSelector } from './OptionArgumentValidatorSelector'
+import { OptionHelpers } from './OptionHelpers'
+import { OptionReader } from './OptionReader'
+import type { OptionValues } from '@commander-js/extra-typings'
+import { realizeLazyProperty } from '../util/object/realizeLazyProperty'
+
+/**
+ * Wrapper around the @see Option class, for more intuitive construction.
+ * @remarks Options are one of boolean, negated, required argument, or optional argument.
+ */
+export class OptionBuilder {
+  readonly $: Option
+
+  constructor(readonly cmd: CommandBuilder, flags: string) {
+    this.$ = new Option(flags)
+    if (!OptionHelpers.hasArgument(this.$) && this.$.long?.startsWith('--no-')) {
+      this.$.default(true)
+    }
+  }
+  description(string: string) {
+    this.$.description = string
+    return this
+  }
+  mandatory(mandatory = true) {
+    this.$.makeOptionMandatory(mandatory)
+    return this
+  }
+  hideHelp(hide = true) {
+    this.$.hideHelp(hide)
+    return this
+  }
+  hidden(hidden = true) {
+    this.$.hidden = hidden
+    return this
+  }
+  preset(arg: unknown) {
+    this.$.preset(arg)
+    return this
+  }
+  default(value: unknown, description?: string) {
+    this.$.default(value, description)
+    return this
+  }
+  choices(values: readonly string[]) {
+    if (!OptionHelpers.hasArgument(this.$)) {
+      throw new Error('Cannot set choices on option with no argument: ' + this.$.name())
+    }
+    this.$.choices(values)
+    return this
+  }
+  conflicts(names: string | string[]) {
+    this.$.conflicts(names)
+    return this
+  }
+  implies(optionValues: OptionValues) {
+    this.$.implies(optionValues)
+    return this
+  }
+  env(name: string) {
+    this.$.env(name)
+    return this
+  }
+  short(short: string) {
+    OptionHelpers.setShort(this.$, short)
+    return this
+  }
+  get parser() {
+    if (!OptionHelpers.hasArgument(this.$)) {
+      throw new Error('Cannot set parser on option with no argument: ' + this.$.attributeName())
+    }
+    return new OptionArgumentParserSelector(this)
+  }
+  get validator() {
+    if (!OptionHelpers.hasArgument(this.$)) {
+      throw new Error('Cannot set validator on option with no argument: ' + this.$.attributeName())
+    }
+    return new OptionArgumentValidatorSelector(this)
+  }
+  get get() {
+    return realizeLazyProperty(this, 'get', new OptionReader(this))
+  }
+}

package/src/opt/OptionHelpers.test.ts

@@ -0,0 +1,229 @@
+import { Option } from '@commander-js/extra-typings'
+import { OptionHelpers } from './OptionHelpers'
+
+describe(OptionHelpers.getArgumentName.name, () => {
+  const flags = '--alpha '
+  it('required arg', () => {
+    const arg = '<arg>'
+    expect(OptionHelpers.getArgumentName(new Option(flags + arg))).toBe(arg)
+  })
+  it('optional arg', () => {
+    const arg = '[arg]'
+    expect(OptionHelpers.getArgumentName(new Option(flags + arg))).toBe(arg)
+  })
+  it('required variadic arg', () => {
+    const arg = '<arg...>'
+    expect(OptionHelpers.getArgumentName(new Option(flags + arg))).toBe(arg)
+  })
+  it('optional variadic arg', () => {
+    const arg = '[arg...]'
+    expect(OptionHelpers.getArgumentName(new Option(flags + arg))).toBe(arg)
+  })
+  it('no arg', () => {
+    expect(OptionHelpers.getArgumentName(new Option(flags.trim()))).toBe(undefined)
+  })
+})
+
+describe(OptionHelpers.hasArgument.name, () => {
+  it('no argument - with short', () => {
+    const opt = new Option('-a, --alpha')
+    expect(OptionHelpers.hasArgument(opt)).toBe(false)
+  })
+  it('no argument - without short', () => {
+    const opt = new Option('--alpha')
+    expect(OptionHelpers.hasArgument(opt)).toBe(false)
+  })
+  it('has optional argument - with short', () => {
+    const opt = new Option('-a, --alpha [value]')
+    expect(OptionHelpers.hasArgument(opt)).toBe(true)
+  })
+  it('has optional argument - without short', () => {
+    const opt = new Option('--alpha [value]')
+    expect(OptionHelpers.hasArgument(opt)).toBe(true)
+  })
+  it('has required argument - with short', () => {
+    const opt = new Option('-a, --alpha <value>')
+    expect(OptionHelpers.hasArgument(opt)).toBe(true)
+  })
+  it('has required argument - without short', () => {
+    const opt = new Option('--alpha <value>')
+    expect(OptionHelpers.hasArgument(opt)).toBe(true)
+  })
+})
+
+describe(OptionHelpers.renderFlags.name, () => {
+  describe('should render correctly when provided', () => {
+    it('short', () => {
+      const flags = '-a'
+      expect(OptionHelpers.renderFlags(new Option(flags))).toBe(flags)
+    })
+    it('long', () => {
+      const flags = '--alpha'
+      expect(OptionHelpers.renderFlags(new Option(flags))).toBe(flags)
+    })
+    it('short, long', () => {
+      const flags = '-a, --alpha'
+      expect(OptionHelpers.renderFlags(new Option(flags))).toBe(flags)
+    })
+    it('short, arg', () => {
+      const flags = '-a <arg>'
+      expect(OptionHelpers.renderFlags(new Option(flags))).toBe(flags)
+    })
+    it('long, arg', () => {
+      const flags = '--alpha <arg>'
+      expect(OptionHelpers.renderFlags(new Option(flags))).toBe(flags)
+    })
+    it('short, long, arg', () => {
+      const flags = '-a, --alpha <arg>'
+      expect(OptionHelpers.renderFlags(new Option(flags))).toBe(flags)
+    })
+  })
+})
+
+describe(OptionHelpers.setLong.name, () => {
+  describe('when long name not initially provided', () => {
+    describe('short property', () => {
+      it('should set the long property', () => {
+        const opt = new Option('-a')
+        OptionHelpers.setLong(opt, '--alpha')
+        expect(opt.long).toBe('--alpha')
+      })
+
+      it('should set the long property with dash prefix even if not provided', () => {
+        const opt = new Option('-a')
+        OptionHelpers.setLong(opt, 'alpha')
+        expect(opt.long).toBe('--alpha')
+      })
+
+      it('should set the long property with too many dashes', () => {
+        const opt = new Option('-a')
+        OptionHelpers.setLong(opt, '---alpha')
+        expect(opt.long).toBe('--alpha')
+      })
+    })
+
+    describe('flags property', () => {
+      it('should set the flags property', () => {
+        const opt = new Option('-a')
+        OptionHelpers.setLong(opt, '--alpha')
+        expect(opt.flags).toBe('-a, --alpha')
+      })
+
+      it('should set the flags property no flags provided', () => {
+        const opt = new Option('')
+        OptionHelpers.setLong(opt, '--alpha')
+        expect(opt.flags).toBe('--alpha')
+      })
+
+      it('should set the flags property when there is an option argument', () => {
+        const opt = new Option('-a <arg>')
+        OptionHelpers.setLong(opt, '--alpha')
+        expect(opt.flags).toBe('-a, --alpha <arg>')
+      })
+
+      it('should set the flags property when there is a variadic option argument', () => {
+        const opt = new Option('-a <arg...>')
+        OptionHelpers.setLong(opt, '--alpha')
+        expect(opt.flags).toBe('-a, --alpha <arg...>')
+      })
+    })
+  })
+
+  describe('when long name initially provided', () => {
+    describe('short property', () => {
+      it('should set the long property', () => {
+        const opt = new Option('-a, --beta')
+        OptionHelpers.setLong(opt, '--alpha')
+        expect(opt.long).toBe('--alpha')
+      })
+    })
+
+    describe('flags property', () => {
+      it('should set the flags property', () => {
+        const opt = new Option('-a, --beta')
+        OptionHelpers.setLong(opt, '--alpha')
+        expect(opt.flags).toBe('-a, --alpha')
+      })
+
+      it('should set the flags property when there is an option argument', () => {
+        const opt = new Option('-a, --beta <arg>')
+        OptionHelpers.setLong(opt, '--alpha')
+        expect(opt.flags).toBe('-a, --alpha <arg>')
+      })
+    })
+  })
+})
+
+describe(OptionHelpers.setShort.name, () => {
+  describe('when short name not initially provided', () => {
+    describe('short property', () => {
+      it('should set the short property', () => {
+        const opt = new Option('--alpha')
+        OptionHelpers.setShort(opt, '-a')
+        expect(opt.short).toBe('-a')
+      })
+
+      it('should set the short property with dash prefix even if not provided', () => {
+        const opt = new Option('--alpha')
+        OptionHelpers.setShort(opt, 'a')
+        expect(opt.short).toBe('-a')
+      })
+
+      it('should set the short property with too many dashes', () => {
+        const opt = new Option('--alpha')
+        OptionHelpers.setShort(opt, '--a')
+        expect(opt.short).toBe('-a')
+      })
+    })
+
+    describe('flags property', () => {
+      it('should set the flags property', () => {
+        const opt = new Option('--alpha')
+        OptionHelpers.setShort(opt, '-a')
+        expect(opt.flags).toBe('-a, --alpha')
+      })
+
+      it('should set the flags property no flags provided', () => {
+        const opt = new Option('')
+        OptionHelpers.setShort(opt, '-a')
+        expect(opt.flags).toBe('-a')
+      })
+
+      it('should set the flags property when there is an option argument', () => {
+        const opt = new Option('--alpha <arg>')
+        OptionHelpers.setShort(opt, '-a')
+        expect(opt.flags).toBe('-a, --alpha <arg>')
+      })
+
+      it('should set the flags property when there is a variadic option argument', () => {
+        const opt = new Option('--alpha <arg...>')
+        OptionHelpers.setShort(opt, '-a')
+        expect(opt.flags).toBe('-a, --alpha <arg...>')
+      })
+    })
+  })
+
+  describe('when short name initially provided', () => {
+    describe('short property', () => {
+      it('should set the short property', () => {
+        const opt = new Option('-b, --alpha')
+        OptionHelpers.setShort(opt, '-a')
+        expect(opt.short).toBe('-a')
+      })
+    })
+
+    describe('flags property', () => {
+      it('should set the flags property', () => {
+        const opt = new Option('-b, --alpha')
+        OptionHelpers.setShort(opt, '-a')
+        expect(opt.flags).toBe('-a, --alpha')
+      })
+
+      it('should set the flags property when there is an option argument', () => {
+        const opt = new Option('-b, --alpha <arg>')
+        OptionHelpers.setShort(opt, '-a')
+        expect(opt.flags).toBe('-a, --alpha <arg>')
+      })
+    })
+  })
+})

package/src/opt/OptionHelpers.ts

@@ -0,0 +1,57 @@
+import { arrLast } from '../util/array/arrLast'
+import { Option } from '@commander-js/extra-typings'
+import { strEnsureStartsWith } from '../util/string/strEnsureStartsWith'
+
+/**
+ * Extract the argument name from an option's 'flags' string.
+ */
+function getArgumentName(opt: Option) {
+  const result = arrLast(opt.flags.trim().split(' '))
+  if (/-/.test(result)) return undefined
+  return result
+}
+
+/**
+ * Check if an option has an argument.
+ */
+function hasArgument(opt: Option) {
+  return /[<>[\]]/.test(opt.flags)
+}
+
+/**
+ * Update an Option's 'flags' property from its 'short' and 'long' properties.
+ * The flags property is not automatically updated when 'short' or 'long' are changed.
+ */
+function renderFlags(opt: Option) {
+  const shortLong = []
+  if (opt.short) shortLong.push(opt.short)
+  if (opt.long) shortLong.push(opt.long)
+  const argName = getArgumentName(opt)
+  return shortLong.join(', ') + (argName ? ' ' + argName : '')
+}
+
+/**
+ * Set an Option's 'long' name. The 'flags' property is updated accordingly.
+ * The '--' prefix is automatically added if not present.
+ */
+function setLong(opt: Option, long: string) {
+  opt.long = strEnsureStartsWith(long, '--').replace(/^-+/, '--')
+  opt.flags = renderFlags(opt)
+}
+
+/**
+ * Set an Option's 'short' name. The 'flags' property is updated accordingly.
+ * The '-' prefix is automatically added if not present.
+ */
+function setShort(opt: Option, short: string) {
+  opt.short = strEnsureStartsWith(short, '-').replace(/^-+/, '-')
+  opt.flags = renderFlags(opt)
+}
+
+export const OptionHelpers = {
+  getArgumentName,
+  hasArgument,
+  renderFlags,
+  setLong,
+  setShort,
+}

package/src/opt/OptionReader.test.ts

@@ -0,0 +1,106 @@
+import { CommandBuilder } from '../cmd/CommandBuilder'
+import { OptionBuilder } from './OptionBuilder'
+import { OptionHelpers } from './OptionHelpers'
+import { OptionReader } from './OptionReader'
+
+describe(OptionReader.name, () => {
+  it('should return an OptionReader instance', () => {
+    const o = new OptionBuilder(new CommandBuilder('t'), '-a, --alpha <arg>')
+    expect(o.get).toBeInstanceOf(OptionReader)
+  })
+
+  describe('properties', () => {
+    let o = new OptionBuilder(new CommandBuilder('t'), '-a, --alpha <arg>')
+
+    beforeEach(() => {
+      o = new OptionBuilder(new CommandBuilder('t'), '-a, --alpha <arg>')
+    })
+
+    it('$', () => {
+      expect(o.get.$).toBe(o.$)
+    })
+
+    it('option', () => {
+      expect(o.get.option).toBe(o.$)
+    })
+
+    it('description', () => {
+      o.description('a')
+      expect(o.get.description).toBe(o.$.description)
+    })
+
+    it('optional', () => {
+      expect(o.get.optional).toBe(o.$.optional)
+    })
+
+    it('mandatory', () => {
+      expect(o.get.mandatory).toBe(o.$.mandatory)
+    })
+
+    it('hidden', () => {
+      expect(o.get.hidden).toBe(o.$.hidden)
+    })
+
+    it('variadic', () => {
+      expect(o.get.variadic).toBe(o.$.variadic)
+    })
+
+    it('mandatory', () => {
+      expect(o.get.mandatory).toBe(o.$.mandatory)
+    })
+
+    it('short', () => {
+      expect(o.get.short).toBe(o.$.short)
+    })
+
+    it('long', () => {
+      expect(o.get.long).toBe(o.$.long)
+    })
+
+    it('preset', () => {
+      expect(o.get.preset).toBe(o.$.presetArg)
+    })
+
+    it('default', () => {
+      expect(o.get.default).toBe(o.$.defaultValue)
+    })
+
+    it('choices', () => {
+      o.choices(['a'])
+      expect(o.get.choices).toEqual(o.$.argChoices)
+    })
+
+    it('env', () => {
+      expect(o.get.env).toBe(o.$.envVar)
+    })
+
+    it('flags', () => {
+      expect(o.get.flags).toBe(o.$.flags)
+    })
+
+    it('hasArgument', () => {
+      const spy = jest.spyOn(OptionHelpers, 'hasArgument')
+      expect(spy).not.toHaveBeenCalled()
+      o.get.hasArgument
+      expect(spy).toHaveBeenCalled()
+    })
+
+    it('name', () => {
+      const spy = jest.spyOn(o.$, 'name')
+      expect(spy).not.toHaveBeenCalled()
+      o.get.name
+      expect(spy).toHaveBeenCalled()
+    })
+
+    it('attributeName', () => {
+      const spy = jest.spyOn(o.$, 'attributeName')
+      expect(spy).not.toHaveBeenCalled()
+      o.get.attributeName
+      expect(spy).toHaveBeenCalled()
+    })
+
+    it('defaultValueDescription', () => {
+      expect(o.get.defaultValueDescription).toBe(o.$.defaultValueDescription)
+    })
+  })
+})