@bemoje/cli 0.0.4 → 0.0.5

package/src/core/OutputManager.test.ts

@@ -0,0 +1,129 @@
+import { OutputManager } from './OutputManager'
+
+describe(OutputManager.name, () => {
+  describe('getInstance', () => {
+    it('should return the same instance of OutputManager', () => {
+      const instance1 = OutputManager.getInstance()
+      const instance2 = OutputManager.getInstance()
+      expect(instance1).toBe(instance2)
+    })
+  })
+
+  describe('colors', () => {
+    it('should have enabled property set to true by default', () => {
+      const outputManager = new OutputManager()
+      expect(outputManager.colors.enabled).toBe(true)
+    })
+  })
+
+  describe('stdout', () => {
+    it('should have write method enabled by default', () => {
+      const outputManager = new OutputManager()
+      expect(outputManager.stdout.isEnabled).toBe(true)
+    })
+
+    it('should disable the write method', () => {
+      const outputManager = new OutputManager()
+      outputManager.stdout.disable()
+      expect(outputManager.stdout.isEnabled).toBe(false)
+    })
+  })
+
+  describe('stderr', () => {
+    it('should have write method enabled by default', () => {
+      const outputManager = new OutputManager()
+      expect(outputManager.stderr.isEnabled).toBe(true)
+    })
+
+    it('should enable the write method', () => {
+      const outputManager = new OutputManager()
+      outputManager.stderr.disable()
+      expect(outputManager.stderr.isEnabled).toBe(false)
+    })
+  })
+
+  describe('debug', () => {
+    it('should have debug method disabled by default', () => {
+      const outputManager = new OutputManager()
+      expect(outputManager.debug.isEnabled).toBe(false)
+    })
+
+    it('should enable the debug method', () => {
+      const outputManager = new OutputManager()
+      outputManager.debug.enable()
+      expect(outputManager.debug.isEnabled).toBe(true)
+    })
+  })
+
+  describe('reset', () => {
+    it('should enable colors', () => {
+      const outputManager = new OutputManager()
+      outputManager.colors.enabled = false
+      outputManager.reset()
+      expect(outputManager.colors.enabled).toBe(true)
+    })
+
+    it('should enable the write method of process.stdout', () => {
+      const outputManager = new OutputManager()
+      outputManager.stdout.disable()
+      outputManager.reset()
+      expect(outputManager.stdout.isEnabled).toBe(true)
+    })
+
+    it('should enable the write method of process.stderr', () => {
+      const outputManager = new OutputManager()
+      outputManager.stderr.disable()
+      outputManager.reset()
+      expect(outputManager.stderr.isEnabled).toBe(true)
+    })
+
+    it('should disable the debug method of console', () => {
+      const outputManager = new OutputManager()
+      outputManager.debug.enable()
+      outputManager.reset()
+      expect(outputManager.debug.isEnabled).toBe(false)
+    })
+
+    it('should return the OutputManager instance', () => {
+      const outputManager = new OutputManager()
+      expect(outputManager.reset()).toBe(outputManager)
+    })
+  })
+
+  describe('outputDebug', () => {
+    it('should log the debug message to the console if debug method is enabled', () => {
+      const outputManager = new OutputManager()
+      outputManager.debug.enable()
+      const spy = jest.spyOn(console, 'debug').mockImplementation(() => {})
+      outputManager.outputDebug(() => 'msg')
+      expect(spy).toHaveBeenCalledWith('msg')
+    })
+  })
+
+  describe('drainDebugMessageQueue', () => {
+    it('should log all the messages in the debug message queue to the console', () => {
+      const outputManager = new OutputManager()
+      const spy = jest.spyOn(console, 'debug')
+      outputManager.outputDebug(() => 'msg')
+      outputManager.outputDebug(() => 'msg')
+      outputManager.drainDebugMessageQueue()
+      expect(spy).toHaveBeenCalledTimes(2)
+    })
+
+    it('should empty the debug message queue', () => {
+      const outputManager = new OutputManager()
+      outputManager.outputDebug(() => 'msg')
+      outputManager.drainDebugMessageQueue()
+      expect(outputManager.queueSize).toBe(0)
+    })
+  })
+
+  describe('queueSize', () => {
+    it('should return number of debug messages in the queue', () => {
+      const outputManager = new OutputManager()
+      expect(outputManager.queueSize).toBe(0)
+      outputManager.outputDebug(() => 'msg')
+      expect(outputManager.queueSize).toBe(1)
+    })
+  })
+})

package/src/core/OutputManager.ts

@@ -0,0 +1,103 @@
+import colors from 'ansi-colors'
+import type { Any } from '../util/types/Any'
+import { MethodDisabler } from '../util/function/MethodDisabler'
+
+/**
+ * The OutputManager class manages the output of debug messages to the console.
+ */
+export class OutputManager {
+  /**
+   * The singleton instance of the OutputManager class.
+   */
+  private static instance: OutputManager
+
+  /**
+   * Returns the singleton instance of the OutputManager class.
+   * If the instance does not exist, it creates a new one.
+   */
+  static getInstance() {
+    if (!this.instance) this.instance = new OutputManager()
+    return this.instance
+  }
+
+  /**
+   * Ansi-colors object
+   */
+  readonly colors = colors
+
+  /**
+   * A MethodDisabler instance for disabling the write method of the process.stdout object.
+   */
+  readonly stdout = new MethodDisabler(process.stdout, 'write')
+
+  /**
+   * A MethodDisabler instance for disabling the write method of the process.stderr object.
+   */
+  readonly stderr = new MethodDisabler(process.stderr, 'write')
+
+  /**
+   * A MethodDisabler instance for disabling the debug method of the console object.
+   */
+  readonly debug = new MethodDisabler(console, 'debug')
+
+  /**
+   * An array that holds queued debug messages.
+   */
+  protected readonly debugMsgQueue: (() => Any)[] = []
+
+  /**
+   * Constructs a new instance of the OutputManager class.
+   * console.debug is disabled by default.
+   */
+  constructor() {
+    this.debug.disable()
+    colors.enabled = (() => {
+      const { FORCE_COLOR, NODE_DISABLE_COLORS, NO_COLOR, TERM } = process.env
+      return (
+        !NODE_DISABLE_COLORS &&
+        NO_COLOR == null &&
+        TERM !== 'dumb' &&
+        ((FORCE_COLOR != null && FORCE_COLOR !== '0') || (process.stdout && process.stdout.isTTY))
+      )
+    })()
+  }
+
+  get queueSize() {
+    return this.debugMsgQueue.length
+  }
+
+  /**
+   * Resets the OutputManager to its default state.
+   * - Enables colors.
+   * - Enables the write method of the process.stdout object.
+   * - Enables the write method of the process.stderr object.
+   * - Disables the debug method of the console object.
+   * @returns The OutputManager instance.
+   */
+  reset() {
+    this.colors.enabled = true
+    this.stdout.enable()
+    this.stderr.enable()
+    this.debug.disable()
+    return this
+  }
+
+  /**
+   * Outputs a debug message to the console.
+   * If the debug method is enabled, the message is immediately logged to the console.
+   * Otherwise, the message is added to the debug message queue.
+   * @param fn - A function that returns the debug message.
+   */
+  outputDebug(fn: () => Any) {
+    if (this.debug.isEnabled) console.debug(fn())
+    else this.debugMsgQueue.push(fn)
+  }
+
+  /**
+   * Drains the debug message queue by logging all the messages to the console.
+   */
+  drainDebugMessageQueue() {
+    this.debugMsgQueue.forEach((fn) => console.debug(fn()))
+    this.debugMsgQueue.splice(0, this.debugMsgQueue.length)
+  }
+}

package/src/core/ParserSelector.test.ts

@@ -0,0 +1,7 @@
+import { ParserSelector } from './ParserSelector'
+
+describe(ParserSelector.name, () => {
+  it('should be an abstract class', () => {
+    expect(typeof ParserSelector).toBe('function')
+  })
+})

package/src/core/ParserSelector.ts

@@ -0,0 +1,38 @@
+import { ArgumentBuilder } from '../arg/ArgumentBuilder'
+import { createTypedListParser } from '../util/string-parsers/createTypedListParser'
+import type { JsonValue } from '../util/types/JsonValue'
+import { OptionBuilder } from '../opt/OptionBuilder'
+import { parseInteger } from '../util/string-parsers/parseInteger'
+import { parseNumber } from '../util/string-parsers/parseNumber'
+import { parseString } from '../util/string-parsers/parseString'
+import type { TStringParser } from '../util/types/TStringParser'
+
+export abstract class ParserSelector<Builder extends ArgumentBuilder | OptionBuilder> {
+  constructor(protected readonly builder: Builder) {}
+
+  abstract custom<T extends JsonValue>(parser: TStringParser<T>): Builder
+
+  string() {
+    return this.custom<string>(parseString)
+  }
+  number() {
+    return this.custom<number>(parseNumber)
+  }
+  integer() {
+    return this.custom<number>(parseInteger)
+  }
+
+  delimitedStrings(delimiter = ',') {
+    return this.delimited<string>(delimiter, parseString)
+  }
+  delimitedNumbers(delimiter = ',') {
+    return this.delimited<number>(delimiter, parseNumber)
+  }
+  delimitedIntegers(delimiter = ',') {
+    return this.delimited<number>(delimiter, parseInteger)
+  }
+
+  delimited<T extends JsonValue>(delimiter = ',', parser: TStringParser<T>) {
+    return this.custom(createTypedListParser(delimiter, parser))
+  }
+}

package/src/core/ValidatorSelector.test.ts

@@ -0,0 +1,7 @@
+import { ValidatorSelector } from './ValidatorSelector'
+
+describe(ValidatorSelector.name, () => {
+  it('should be an abstract class', () => {
+    expect(typeof ValidatorSelector).toBe('function')
+  })
+})

package/src/core/ValidatorSelector.ts

@@ -0,0 +1,38 @@
+import { ArgumentBuilder } from '../arg/ArgumentBuilder'
+import { createTypedArrayValidator } from '../util/validation/createTypedArrayValidator'
+import { isInteger } from '../util/validation/numbers/isInteger'
+import { isString } from '../util/validation/isString'
+import { isValidNumber } from '../util/validation/numbers/isValidNumber'
+import type { JsonValue } from '../util/types/JsonValue'
+import { OptionBuilder } from '../opt/OptionBuilder'
+import type { TValidator } from '../util/types/TValidator'
+
+export abstract class ValidatorSelector<Builder extends OptionBuilder | ArgumentBuilder> {
+  constructor(protected readonly builder: Builder) {}
+
+  abstract custom<O>(validator: TValidator<O>): typeof this.builder
+
+  isString() {
+    return this.custom(isString)
+  }
+  isNumber() {
+    return this.custom(isValidNumber)
+  }
+  isInteger() {
+    return this.custom(isInteger)
+  }
+
+  isStringArray() {
+    return this.arrayWhereEach(isString)
+  }
+  isNumberArray() {
+    return this.arrayWhereEach(isValidNumber)
+  }
+  isIntegerArray() {
+    return this.arrayWhereEach(isInteger)
+  }
+
+  arrayWhereEach<O extends JsonValue = JsonValue>(...validators: TValidator<O>[]) {
+    return this.custom(createTypedArrayValidator(validators))
+  }
+}

package/src/core/splitCombinedArgvShorts.test.ts

@@ -0,0 +1,9 @@
+import { splitCombinedArgvShorts } from './splitCombinedArgvShorts'
+
+describe(splitCombinedArgvShorts.name, () => {
+  it('should split only combined short name flags', () => {
+    const argv = ['-abc', 'def', '-g', 'h', '-ab']
+    const expected = ['-a', '-b', '-c', 'def', '-g', 'h', '-a', '-b']
+    expect(splitCombinedArgvShorts(argv)).toEqual(expected)
+  })
+})

package/src/core/splitCombinedArgvShorts.ts

@@ -0,0 +1,10 @@
+export function splitCombinedArgvShorts(argv: string[]) {
+  return argv
+    .map((arg) => {
+      if (arg.length < 3 || !arg.startsWith('-') || arg.startsWith('--') || arg.includes('=')) {
+        return arg
+      }
+      return Array.from(arg.replace('-', '')).map((s) => '-' + s)
+    })
+    .flat()
+}

package/src/db/AbstractJsonFileSection.test.ts

@@ -0,0 +1,274 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { AbstractJsonFileSection } from './AbstractJsonFileSection'
+import { CommandBuilder } from '../cmd/CommandBuilder'
+import { JsonFile } from './JsonFile'
+import { JsonValue } from '../../../util/src'
+import { promptUserEditJsonInTextEditorSync } from '../util/fs/promptUserEditInTextEditor/promptUserEditJsonInTextEditorSync'
+
+jest.mock('../util/fs/promptUserEditInTextEditor/promptUserEditJsonInTextEditorSync', () => ({
+  ...jest.requireActual('../util/fs/promptUserEditInTextEditor/promptUserEditJsonInTextEditorSync'),
+  promptUserEditJsonInTextEditorSync: jest.fn().mockImplementation(() => {}),
+}))
+
+describe(AbstractJsonFileSection.name, () => {
+  let cmd: CommandBuilder
+  let file: JsonFile
+  let section: AbstractJsonFileSection
+  let saveSpy: jest.SpyInstance
+  class Section<Val = JsonValue> extends AbstractJsonFileSection<Val> {
+    override assertValid(): void {
+      return
+    }
+    override defineProperty(key: string, value: Val) {
+      this.defaultValues[key] = value
+    }
+    override initialize() {
+      return
+    }
+  }
+
+  beforeEach(() => {
+    cmd = new CommandBuilder('t')
+    file = new JsonFile(cmd)
+    section = new Section(file, 'section', false)
+    saveSpy = jest.spyOn(file.db, 'save').mockImplementation((() => {}) as any)
+  })
+
+  describe('constructor', () => {
+    it('should set the file property', () => {
+      expect(section.file).toBe(file)
+    })
+
+    it('should set the prefixBaseString property', () => {
+      expect(section.prefixBaseString).toBe('t')
+    })
+  })
+
+  describe('get db', () => {
+    it('should return the db property of the file', () => {
+      expect(section.db).toBe(file.db)
+    })
+  })
+
+  describe('get cmd', () => {
+    it('should return the cmd property of the file', () => {
+      expect(section.cmd).toBe(cmd)
+    })
+  })
+
+  describe('save', () => {
+    it('should call the save method of the db property', async () => {
+      await section.save()
+      expect(saveSpy).toHaveBeenCalledTimes(1)
+    })
+  })
+
+  describe('prefix', () => {
+    it('should return the prefixBaseString + "." + name if no key is provided', () => {
+      expect(section.prefix()).toBe('t.section')
+    })
+
+    it('should return the prefixBaseString + "." + name + "." + key if a key is provided', () => {
+      expect(section.prefix('key')).toBe('t.section.key')
+    })
+  })
+
+  describe('get', () => {
+    it('should call the initialize method with false', () => {
+      const initializeSpy = jest.spyOn(section, 'initialize')
+      section.get('key')
+      expect(initializeSpy).toHaveBeenCalledWith(false)
+    })
+
+    it('should return the value associated with the key if it exists in the db', () => {
+      jest.spyOn(section.db, 'getSafe').mockReturnValue('value')
+      expect(section.get('key')).toBe('value')
+    })
+
+    it('should return the value associated with the key from defaultValues if it does not exist in the db', () => {
+      section.defineProperty('key', 'value')
+      expect(section.get('key')).toBe('value')
+    })
+  })
+
+  describe('getAll', () => {
+    it('should call the initialize method with false', () => {
+      const initializeSpy = jest.spyOn(section, 'initialize')
+      section.getAll()
+      expect(initializeSpy).toHaveBeenCalledWith(false)
+    })
+
+    it('should return all the values in the section if they exist in the db', () => {
+      const values = { key1: 'value1', key2: 'value2' }
+      jest.spyOn(section.db, 'getSafe').mockReturnValue(values)
+      expect(section.getAll()).toBe(values)
+    })
+
+    it('should return all the values in the section from defaultValues if they do not exist in the db', () => {
+      const values = { key1: 'value1', key2: 'value2' }
+      section.defineProperty('key1', 'value1')
+      section.defineProperty('key2', 'value2')
+      jest.spyOn(section.db, 'getSafe').mockReturnValue(undefined)
+      expect(section.getAll()).toEqual(values)
+    })
+  })
+
+  describe('get keys', () => {
+    it('should return all the keys in the db', () => {
+      jest.spyOn(section.db, 'getSafe').mockReturnValue({ key1: 'value1', key2: 'value2' })
+      expect(section.keys).toEqual(['key1', 'key2'])
+    })
+  })
+
+  describe('count', () => {
+    it('should return the number of keys in the section', () => {
+      jest.spyOn(section, 'keys', 'get').mockReturnValue(['key1', 'key2'])
+      expect(section.count()).toBe(2)
+    })
+  })
+
+  describe('set', () => {
+    it('should call the initialize method', () => {
+      const initializeSpy = jest.spyOn(section, 'initialize')
+      section.set('key', 'value')
+      expect(initializeSpy).toHaveBeenCalled()
+    })
+
+    it('should call the assertValid method with the key and value', () => {
+      const assertValidSpy = jest.spyOn(section, 'assertValid')
+      section.set('key', 'value')
+      expect(assertValidSpy).toHaveBeenCalledWith('key', 'value')
+    })
+
+    it('should call the set method of the db property with the prefix, value, and save', () => {
+      const setSpy = jest.spyOn(section.db, 'set')
+      section.set('key', 'value', false)
+      expect(setSpy).toHaveBeenCalledWith(section.prefix('key'), 'value', false)
+    })
+  })
+
+  describe('setAll', () => {
+    it('should call the getAll method', () => {
+      const getAllSpy = jest.spyOn(section, 'getAll')
+      section.setAll({})
+      expect(getAllSpy).toHaveBeenCalled()
+    })
+
+    it('should call the set method for each key-value pair in the values object that is different from the original value', () => {
+      section.defineProperty('key1', 'value1')
+      section.defineProperty('key2', 'value2')
+      const values = { key1: 'new value1', key2: 'value2' }
+      const setSpy = jest.spyOn(section, 'set')
+      section.setAll(values)
+      expect(setSpy).toHaveBeenCalledWith('key1', 'new value1', false)
+      expect(setSpy).toHaveBeenCalledTimes(1)
+    })
+
+    it('should call the delete method for each key in the original object that is not in the values object', () => {
+      section.defineProperty('key1', 'value1')
+      section.defineProperty('key2', 'value2')
+      const values = { key1: 'value1' }
+      const deleteSpy = jest.spyOn(section, 'delete')
+      section.setAll(values)
+      expect(deleteSpy).toHaveBeenCalledWith('key2', false)
+      expect(deleteSpy).toHaveBeenCalledTimes(1)
+    })
+
+    it('should call the save method if save is true', () => {
+      const saveSpy = jest.spyOn(section, 'save')
+      section.setAll({}, true)
+      expect(saveSpy).toHaveBeenCalled()
+    })
+
+    it('should not call the save method if save is false', () => {
+      const saveSpy = jest.spyOn(section, 'save')
+      section.setAll({}, false)
+      expect(saveSpy).not.toHaveBeenCalled()
+    })
+  })
+
+  describe('update', () => {
+    it('should call the update method of the db property with the prefix, value, and save', () => {
+      section.defineProperty('key', 'value')
+      const setSpy = jest.spyOn(section, 'set')
+      section.update('key', () => 'value', false)
+      expect(setSpy).toHaveBeenCalledWith('key', 'value', false)
+      section.update('key', () => 'value', true)
+      expect(setSpy).toHaveBeenCalledWith('key', 'value', true)
+    })
+  })
+
+  describe('reset', () => {
+    it('should call the set method with the key and the default value for the key', () => {
+      section.defineProperty('key', 'def')
+      const setSpy = jest.spyOn(section, 'set')
+      section.reset('key')
+      expect(setSpy).toHaveBeenCalledWith('key', 'def', true)
+    })
+  })
+
+  describe('resetAll', () => {
+    it('should call the setAll method with the defaultValues object', () => {
+      section.defineProperty('key1', 'def1')
+      section.defineProperty('key2', 'def2')
+      const setAllSpy = jest.spyOn(section, 'setAll')
+      section.resetAll()
+      expect(setAllSpy).toHaveBeenCalledWith({ key1: 'def1', key2: 'def2' }, true)
+    })
+  })
+
+  describe('delete', () => {
+    it('should call the initialize method', () => {
+      const initializeSpy = jest.spyOn(section, 'initialize')
+      section.delete('key')
+      expect(initializeSpy).toHaveBeenCalled()
+    })
+
+    it('should call the delete method of the db property with the prefix and save', () => {
+      const deleteSpy = jest.spyOn(section.db, 'delete')
+      section.delete('key', false)
+      expect(deleteSpy).toHaveBeenCalledWith(section.prefix('key'), false)
+    })
+  })
+
+  describe('deleteAll', () => {
+    it('should call the delete method for each key in the section', () => {
+      const keys = ['key1', 'key2']
+      jest.spyOn(section, 'keys', 'get').mockReturnValue(keys)
+      const deleteSpy = jest.spyOn(section, 'delete').mockImplementation((() => {}) as any)
+      section.deleteAll()
+      expect(deleteSpy).toHaveBeenCalledWith('key1', false)
+      expect(deleteSpy).toHaveBeenCalledWith('key2', false)
+      expect(deleteSpy).toHaveBeenCalledTimes(2)
+    })
+
+    it('should call the save method if save is true', () => {
+      const saveSpy = jest.spyOn(section, 'save')
+      section.deleteAll(true)
+      expect(saveSpy).toHaveBeenCalled()
+    })
+
+    it('should not call the save method if save is false', () => {
+      const saveSpy = jest.spyOn(section, 'save')
+      section.deleteAll(false)
+      expect(saveSpy).not.toHaveBeenCalled()
+    })
+  })
+
+  describe('edit', () => {
+    it('should call the getAll method', () => {
+      jest.spyOn(section, 'setAll').mockImplementation(() => {})
+      const getAllSpy = jest.spyOn(section, 'getAll').mockReturnValue({})
+      section.edit()
+      expect(getAllSpy).toHaveBeenCalled()
+    })
+
+    it('should call the promptUserEditJsonInTextEditorSync function with the values from getAll', () => {
+      const values = { key1: 'value1', key2: 'value2' }
+      jest.spyOn(section, 'getAll').mockReturnValue(values)
+      jest.spyOn(section, 'setAll').mockImplementation(() => {})
+      section.edit()
+      expect(promptUserEditJsonInTextEditorSync as jest.Mock).toHaveBeenCalled()
+    })
+  })
+})