@remix-run/cli 0.3.3 → 0.4.0

package/src/lib/completion.ts

@@ -1,11 +1,54 @@
+import { testCommandFlags } from './commands/test.ts'
+
 export interface CompletionResult {
   mode: 'files' | 'none' | 'values'
   values?: string[]
 }
 
 const COMPLETION_SHELLS = ['bash', 'zsh'] as const
-const HELP_COMMANDS = ['completion', 'doctor', 'help', 'new', 'routes', 'test', 'version'] as const
-const ROOT_COMMANDS = ['completion', 'doctor', 'help', 'new', 'routes', 'test', 'version'] as const
+const DB_COMMANDS = ['migrate', 'reset', 'seed', 'status', 'wipe'] as const
+const HELP_COMMANDS = [
+  'completion',
+  'db',
+  'doctor',
+  'help',
+  'new',
+  'routes',
+  'test',
+  'version',
+] as const
+const ROOT_COMMANDS = [
+  'completion',
+  'db',
+  'doctor',
+  'help',
+  'new',
+  'routes',
+  'test',
+  'version',
+] as const
+
+// Derived from the `remix test` flag table so completion stays in sync with
+// argument parsing and help text.
+const TEST_BOOLEAN_FLAGS = testCommandFlags
+  .filter((flag) => flag.type === 'boolean')
+  .map((flag) => flag.name)
+const TEST_VALUE_FLAGS = testCommandFlags
+  .filter((flag) => flag.type === 'string')
+  .map((flag) => flag.name)
+const TEST_BOOLEAN_FLAG_SET = new Set(TEST_BOOLEAN_FLAGS)
+const TEST_VALUE_FLAG_SET = new Set(TEST_VALUE_FLAGS)
+const TEST_REPEATABLE_FLAGS = new Set(
+  testCommandFlags.filter((flag) => flag.multiple).map((flag) => flag.name),
+)
+const TEST_FILE_VALUE_FLAGS = new Set(
+  testCommandFlags.filter((flag) => flag.files).map((flag) => flag.name),
+)
+const TEST_FLAG_ALIASES = new Map(
+  testCommandFlags.flatMap((flag) =>
+    flag.alias === undefined ? [] : [[flag.alias, flag.name] as const],
+  ),
+)
 
 export type CompletionShell = (typeof COMPLETION_SHELLS)[number]
 
@@ -18,6 +61,10 @@ export function getCompletionResult(words: string[], currentIndex: number): Comp
   let currentWord = words[resolvedIndex] ?? ''
   let tokens = getTokensBeforeCursor(words, resolvedIndex)
 
+  if (currentWord.startsWith('--config=')) {
+    return { mode: 'files' }
+  }
+
   return completeTopLevel(tokens, currentWord)
 }
 
@@ -47,7 +94,9 @@ if type complete &>/dev/null; then
     local lines
 
     if type _get_comp_words_by_ref &>/dev/null; then
-      _get_comp_words_by_ref -w words -i cword
+      # -n = keeps --config=<path> together as one word; bash's default
+      # COMP_WORDBREAKS would otherwise split it at the equals sign.
+      _get_comp_words_by_ref -n = -w words -i cword
     else
       cword="$COMP_CWORD"
       words=("\${COMP_WORDS[@]}")
@@ -66,7 +115,15 @@ if type complete &>/dev/null; then
     fi
 
     if [[ "$mode" == "mode:files" ]]; then
-      COMPREPLY=($(compgen -f -- "$current"))
+      if [[ "$current" == --config=* ]]; then
+        # Readline still breaks the insertion point at '=', so complete the
+        # path portion alone; prefixing --config= would duplicate the flag.
+        local config_value
+        config_value="\${current#--config=}"
+        COMPREPLY=($(compgen -f -- "$config_value"))
+      else
+        COMPREPLY=($(compgen -f -- "$current"))
+      fi
       return 0
     fi
 
@@ -92,6 +149,9 @@ elif type compdef &>/dev/null; then
     fi
 
     if [[ "$mode" == "mode:files" ]]; then
+      if [[ "\${words[CURRENT]}" == --config=* ]]; then
+        compset -P '--config='
+      fi
       if autoload -U +X _files 2>/dev/null; then
         _files
       else
@@ -116,6 +176,19 @@ function completeTopLevel(tokens: string[], currentWord: string): CompletionResu
   while (index < tokens.length) {
     let token = tokens[index]
 
+    if (token === '--config') {
+      usedFlags.add('--config')
+      if (tokens[index + 1] === undefined) return { mode: 'files' }
+      index += 2
+      continue
+    }
+
+    if (token.startsWith('--config=')) {
+      usedFlags.add('--config')
+      index++
+      continue
+    }
+
     if (token === '--no-color') {
       usedFlags.add('--no-color')
       index++
@@ -144,6 +217,10 @@ function completeCommand(
   currentWord: string,
   usedGlobalFlags: Set<string>,
 ): CompletionResult {
+  if (expectsGlobalConfigValue(tokens)) {
+    return { mode: 'files' }
+  }
+
   if (command === 'help') {
     return completeHelp(tokens, currentWord, usedGlobalFlags)
   }
@@ -152,11 +229,16 @@ function completeCommand(
     return completeNew(tokens, currentWord, usedGlobalFlags)
   }
 
+  if (command === 'db') {
+    return completeDb(tokens, currentWord, usedGlobalFlags)
+  }
+
   if (command === 'doctor') {
     return completeSimpleFlags(tokens, currentWord, usedGlobalFlags, [
       '--fix',
       '--json',
       '--strict',
+      '--no-strict',
     ])
   }
 
@@ -169,7 +251,7 @@ function completeCommand(
   }
 
   if (command === 'test') {
-    return completeSimpleFlags(tokens, currentWord, usedGlobalFlags, ['--coverage', '--watch'])
+    return completeTest(tokens, currentWord, usedGlobalFlags)
   }
 
   if (command === 'completion') {
@@ -179,6 +261,108 @@ function completeCommand(
   return completeValues([], currentWord)
 }
 
+function completeTest(
+  tokens: string[],
+  currentWord: string,
+  usedGlobalFlags: Set<string>,
+): CompletionResult {
+  let filteredTokens = filterGlobalCommandTokens(tokens, usedGlobalFlags)
+  if (filteredTokens == null) {
+    return completeValues([], currentWord)
+  }
+
+  let usedFlags = new Set<string>()
+  let expectedValueFor: string | undefined
+  let afterSeparator = false
+
+  for (let token of filteredTokens) {
+    if (expectedValueFor != null) {
+      expectedValueFor = undefined
+      continue
+    }
+
+    // Everything after a bare `--` is a positional test file glob
+    if (afterSeparator) {
+      continue
+    }
+
+    if (token === '--') {
+      afterSeparator = true
+      continue
+    }
+
+    if (token.startsWith('--')) {
+      // `--flag=value` carries its value inline
+      let equalsIndex = token.indexOf('=')
+      let flag = equalsIndex === -1 ? token : token.slice(0, equalsIndex)
+
+      if (TEST_VALUE_FLAG_SET.has(flag)) {
+        usedFlags.add(flag)
+        if (equalsIndex === -1) {
+          expectedValueFor = flag
+        }
+        continue
+      }
+
+      if (TEST_BOOLEAN_FLAG_SET.has(flag)) {
+        usedFlags.add(flag)
+        continue
+      }
+
+      return completeValues([], currentWord)
+    }
+
+    if (token.startsWith('-') && token !== '-') {
+      let aliased = TEST_FLAG_ALIASES.get(token.slice(0, 2))
+
+      // A value alias may carry its value inline (`-c1`); a bare alias
+      // expects the value in the next token.
+      if (aliased !== undefined && TEST_VALUE_FLAG_SET.has(aliased)) {
+        usedFlags.add(aliased)
+        if (token.length === 2) {
+          expectedValueFor = aliased
+        }
+        continue
+      }
+
+      // A group of boolean aliases (`-qw`)
+      let group = [...token.slice(1)].map((char) => TEST_FLAG_ALIASES.get(`-${char}`))
+      if (
+        group.every((flag): flag is string => flag !== undefined && TEST_BOOLEAN_FLAG_SET.has(flag))
+      ) {
+        for (let flag of group) {
+          usedFlags.add(flag)
+        }
+        continue
+      }
+
+      return completeValues([], currentWord)
+    }
+
+    // Anything else is a positional test file glob
+  }
+
+  if (expectedValueFor != null) {
+    return TEST_FILE_VALUE_FLAGS.has(expectedValueFor) ? { mode: 'files' } : { mode: 'none' }
+  }
+
+  if (afterSeparator) {
+    return { mode: 'files' }
+  }
+
+  let longFlags = [...TEST_BOOLEAN_FLAGS, ...TEST_VALUE_FLAGS].filter(
+    (flag) => !usedFlags.has(flag) || TEST_REPEATABLE_FLAGS.has(flag),
+  )
+  let shortFlags = [...TEST_FLAG_ALIASES].flatMap(([short, long]) =>
+    !usedFlags.has(long) || TEST_REPEATABLE_FLAGS.has(long) ? [short] : [],
+  )
+  let suggestions = withHelpFlags([...longFlags, ...shortFlags], usedGlobalFlags)
+
+  return currentWord.startsWith('-') || currentWord === ''
+    ? completeValues(suggestions, currentWord)
+    : { mode: 'files' }
+}
+
 function completeHelp(
   tokens: string[],
   currentWord: string,
@@ -313,6 +497,105 @@ function completeRoutes(
   return completeValues(flags, currentWord)
 }
 
+function completeDb(
+  tokens: string[],
+  currentWord: string,
+  usedGlobalFlags: Set<string>,
+): CompletionResult {
+  let filteredTokens = filterGlobalCommandTokens(tokens, usedGlobalFlags)
+  if (filteredTokens == null) {
+    return completeValues([], currentWord)
+  }
+
+  if (filteredTokens.length === 0) {
+    return completeValues(withHelpFlags([...DB_COMMANDS], usedGlobalFlags), currentWord)
+  }
+
+  let [subcommand, ...rest] = filteredTokens
+
+  if (subcommand === 'migrate') {
+    return completeDbOptions(
+      rest,
+      currentWord,
+      usedGlobalFlags,
+      [],
+      ['--connection-env', '--journal-table', '--migrations', '--to'],
+    )
+  }
+
+  if (subcommand === 'reset') {
+    return completeDbOptions(
+      rest,
+      currentWord,
+      usedGlobalFlags,
+      ['--force'],
+      ['--connection-env', '--journal-table', '--migrations', '--seed'],
+    )
+  }
+
+  if (subcommand === 'wipe') {
+    return completeDbOptions(rest, currentWord, usedGlobalFlags, ['--force'], ['--connection-env'])
+  }
+
+  if (subcommand === 'seed') {
+    return completeDbOptions(rest, currentWord, usedGlobalFlags, [], ['--connection-env', '--seed'])
+  }
+
+  if (subcommand === 'status') {
+    return completeDbOptions(
+      rest,
+      currentWord,
+      usedGlobalFlags,
+      [],
+      ['--connection-env', '--journal-table', '--migrations'],
+    )
+  }
+
+  return completeValues([], currentWord)
+}
+
+function completeDbOptions(
+  tokens: string[],
+  currentWord: string,
+  usedGlobalFlags: Set<string>,
+  booleanFlags: string[],
+  valueFlags: string[],
+): CompletionResult {
+  let usedFlags = new Set<string>()
+  let expectedValueFor: string | undefined
+
+  for (let token of tokens) {
+    if (expectedValueFor !== undefined) {
+      expectedValueFor = undefined
+      continue
+    }
+
+    let equalsIndex = token.indexOf('=')
+    let flag = equalsIndex === -1 ? token : token.slice(0, equalsIndex)
+    if (booleanFlags.includes(flag)) {
+      usedFlags.add(flag)
+      continue
+    }
+
+    if (valueFlags.includes(flag)) {
+      usedFlags.add(flag)
+      if (equalsIndex === -1) expectedValueFor = flag
+      continue
+    }
+
+    return completeValues([], currentWord)
+  }
+
+  if (expectedValueFor !== undefined) {
+    return expectedValueFor === '--migrations' || expectedValueFor === '--seed'
+      ? { mode: 'files' }
+      : { mode: 'none' }
+  }
+
+  let available = [...booleanFlags, ...valueFlags].filter((flag) => !usedFlags.has(flag))
+  return completeValues(withHelpFlags(available, usedGlobalFlags), currentWord)
+}
+
 function completeCompletionCommand(
   tokens: string[],
   currentWord: string,
@@ -356,6 +639,7 @@ function completeSimpleFlags(
 
 function getTopLevelSuggestions(currentWord: string, usedFlags: Set<string>): string[] {
   let flags = [
+    ...(!usedFlags.has('--config') ? ['--config'] : []),
     ...(!usedFlags.has('-h') ? ['-h', '--help'] : []),
     ...(!usedFlags.has('--no-color') ? ['--no-color'] : []),
     ...(!usedFlags.has('-v') ? ['-v', '--version'] : []),
@@ -371,6 +655,7 @@ function getTopLevelSuggestions(currentWord: string, usedFlags: Set<string>): st
 function withHelpFlags(values: string[], usedGlobalFlags: Set<string>): string[] {
   return [
     ...values,
+    ...(!usedGlobalFlags.has('--config') ? ['--config'] : []),
     ...(!usedGlobalFlags.has('-h') ? ['-h', '--help'] : []),
     ...(!usedGlobalFlags.has('--no-color') ? ['--no-color'] : []),
   ]
@@ -382,7 +667,20 @@ function filterGlobalCommandTokens(
 ): string[] | null {
   let filtered: string[] = []
 
-  for (let token of tokens) {
+  for (let index = 0; index < tokens.length; index++) {
+    let token = tokens[index]!
+
+    if (token === '--config') {
+      usedGlobalFlags.add('--config')
+      index++
+      continue
+    }
+
+    if (token.startsWith('--config=')) {
+      usedGlobalFlags.add('--config')
+      continue
+    }
+
     if (token === '--no-color') {
       usedGlobalFlags.add('--no-color')
       continue
@@ -399,6 +697,23 @@ function filterGlobalCommandTokens(
   return filtered
 }
 
+function expectsGlobalConfigValue(tokens: string[]): boolean {
+  let expectsValue = false
+
+  for (let token of tokens) {
+    if (expectsValue) {
+      expectsValue = false
+      continue
+    }
+
+    if (token === '--config') {
+      expectsValue = true
+    }
+  }
+
+  return expectsValue
+}
+
 function completeValues(values: string[], currentWord: string): CompletionResult {
   return {
     mode: 'values',

package/src/lib/controller-files.ts

@@ -3,8 +3,6 @@ import * as path from 'node:path'
 const OWNER_FILE_EXTENSIONS = ['.ts', '.tsx', '.js', '.jsx'] as const
 const ACTIONS_DIRECTORY = path.join('app', 'actions')
 
-export type OwnerFileExtension = (typeof OWNER_FILE_EXTENSIONS)[number]
-
 export function getControllerOwnerCandidates(segments: string[]): string[] {
   return OWNER_FILE_EXTENSIONS.map((extension) =>
     normalizeRelativePath(path.join(ACTIONS_DIRECTORY, ...segments, `controller${extension}`)),
@@ -20,17 +18,6 @@ export function getPreferredOwnerDisplayPath(candidates: string[]): string {
   return tsxCandidate ?? candidates[0] ?? ''
 }
 
-export function getOwnerCandidateForExtension(
-  candidates: string[],
-  extension: OwnerFileExtension,
-): string | null {
-  return candidates.find((candidate) => candidate.endsWith(extension)) ?? null
-}
-
-export function getOwnerFileExtension(filePath: string): OwnerFileExtension | null {
-  return OWNER_FILE_EXTENSIONS.find((extension) => filePath.endsWith(extension)) ?? null
-}
-
 export function toDiskSegment(segment: string): string {
   let diskSegment = segment
     .replace(/[\\/]+/g, '-')
@@ -45,31 +32,6 @@ export function toDiskSegment(segment: string): string {
   return diskSegment.length === 0 ? 'route' : diskSegment
 }
 
-export function isControllerEntryFileName(fileName: string): boolean {
-  return OWNER_FILE_EXTENSIONS.some((extension) => fileName === `controller${extension}`)
-}
-
-export function getOwnerModuleBaseName(fileName: string): string | null {
-  let extension = OWNER_FILE_EXTENSIONS.find((ownerExtension) => fileName.endsWith(ownerExtension))
-
-  if (extension == null) {
-    return null
-  }
-
-  return fileName.slice(0, -extension.length)
-}
-
-export function isActionFileName(fileName: string): boolean {
-  let baseName = getOwnerModuleBaseName(fileName)
-
-  return (
-    baseName != null &&
-    baseName !== 'controller' &&
-    !baseName.endsWith('.test') &&
-    !baseName.endsWith('.spec')
-  )
-}
-
 function normalizeRelativePath(filePath: string): string {
   return filePath.split(path.sep).join('/')
 }