@remix-run/cli 0.0.0 → 0.2.0

package/src/lib/completion.ts

@@ -0,0 +1,418 @@
+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
+
+export type CompletionShell = (typeof COMPLETION_SHELLS)[number]
+
+export function isCompletionShell(value: string): value is CompletionShell {
+  return COMPLETION_SHELLS.includes(value as CompletionShell)
+}
+
+export function getCompletionResult(words: string[], currentIndex: number): CompletionResult {
+  let resolvedIndex = Math.max(0, currentIndex)
+  let currentWord = words[resolvedIndex] ?? ''
+  let tokens = getTokensBeforeCursor(words, resolvedIndex)
+
+  return completeTopLevel(tokens, currentWord)
+}
+
+export function renderCompletionResult(result: CompletionResult): string {
+  let lines = [`mode:${result.mode}`]
+
+  if (result.mode === 'values') {
+    lines.push(...(result.values ?? []))
+  }
+
+  return `${lines.join('\n')}\n`
+}
+
+export function getCompletionScript(): string {
+  return `###-begin-remix-completion-###
+#
+# Remix command completion script
+#
+# Installation:
+#   remix completion bash >> ~/.bashrc
+#   remix completion zsh >> ~/.zshrc
+#
+
+if type complete &>/dev/null; then
+  _remix_completion() {
+    local words cword current output mode si
+    local lines
+
+    if type _get_comp_words_by_ref &>/dev/null; then
+      _get_comp_words_by_ref -w words -i cword
+    else
+      cword="$COMP_CWORD"
+      words=("\${COMP_WORDS[@]}")
+    fi
+
+    current="\${words[cword]}"
+    output=$(remix completion -- "$cword" "\${words[@]}" 2>/dev/null) || return 0
+    si="$IFS"
+    IFS=$'\\n' lines=($output)
+    IFS="$si"
+    mode="\${lines[0]}"
+
+    if [[ "$mode" == "mode:values" ]]; then
+      COMPREPLY=("\${lines[@]:1}")
+      return 0
+    fi
+
+    if [[ "$mode" == "mode:files" ]]; then
+      COMPREPLY=($(compgen -f -- "$current"))
+      return 0
+    fi
+
+    COMPREPLY=()
+  }
+
+  complete -o default -F _remix_completion remix
+elif type compdef &>/dev/null; then
+  _remix_completion() {
+    local output mode
+    local -a lines values
+
+    output=$(remix completion -- "$((CURRENT - 1))" "\${words[@]}" 2>/dev/null) || return 0
+    lines=("\${(@f)output}")
+    mode="\${lines[1]}"
+
+    if [[ "$mode" == "mode:values" ]]; then
+      values=("\${(@)lines[2,-1]}")
+      if (( \${#values[@]} > 0 )); then
+        compadd -- "\${values[@]}"
+      fi
+      return 0
+    fi
+
+    if [[ "$mode" == "mode:files" ]]; then
+      if autoload -U +X _files 2>/dev/null; then
+        _files
+      else
+        compadd -f
+      fi
+      return 0
+    fi
+
+    return 0
+  }
+
+  compdef _remix_completion remix
+fi
+###-end-remix-completion-###
+`
+}
+
+function completeTopLevel(tokens: string[], currentWord: string): CompletionResult {
+  let usedFlags = new Set<string>()
+  let index = 0
+
+  while (index < tokens.length) {
+    let token = tokens[index]
+
+    if (token === '--no-color') {
+      usedFlags.add('--no-color')
+      index++
+      continue
+    }
+
+    if (token === '-h' || token === '--help') {
+      usedFlags.add('-h')
+      return completeValues([], currentWord)
+    }
+
+    if (token === '-v' || token === '--version') {
+      usedFlags.add('-v')
+      return completeValues([], currentWord)
+    }
+
+    return completeCommand(token, tokens.slice(index + 1), currentWord, usedFlags)
+  }
+
+  return completeValues(getTopLevelSuggestions(currentWord, usedFlags), currentWord)
+}
+
+function completeCommand(
+  command: string,
+  tokens: string[],
+  currentWord: string,
+  usedGlobalFlags: Set<string>,
+): CompletionResult {
+  if (command === 'help') {
+    return completeHelp(tokens, currentWord, usedGlobalFlags)
+  }
+
+  if (command === 'new') {
+    return completeNew(tokens, currentWord, usedGlobalFlags)
+  }
+
+  if (command === 'doctor') {
+    return completeSimpleFlags(tokens, currentWord, usedGlobalFlags, [
+      '--fix',
+      '--json',
+      '--strict',
+    ])
+  }
+
+  if (command === 'routes') {
+    return completeRoutes(tokens, currentWord, usedGlobalFlags)
+  }
+
+  if (command === 'version') {
+    return completeSimpleFlags(tokens, currentWord, usedGlobalFlags, [])
+  }
+
+  if (command === 'test') {
+    return completeSimpleFlags(tokens, currentWord, usedGlobalFlags, [
+      '--coverage',
+      '--watch',
+      '--help',
+    ])
+  }
+
+  if (command === 'completion') {
+    return completeCompletionCommand(tokens, currentWord, usedGlobalFlags)
+  }
+
+  return completeValues([], currentWord)
+}
+
+function completeHelp(
+  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([...HELP_COMMANDS], usedGlobalFlags), currentWord)
+  }
+
+  let [, ...rest] = filteredTokens
+  if (rest.length === 0) {
+    return completeValues([], currentWord)
+  }
+
+  return completeValues([], currentWord)
+}
+
+function completeNew(
+  tokens: string[],
+  currentWord: string,
+  usedGlobalFlags: Set<string>,
+): CompletionResult {
+  let filteredTokens = filterGlobalCommandTokens(tokens, usedGlobalFlags)
+  if (filteredTokens == null) {
+    return completeValues([], currentWord)
+  }
+
+  let hasAppName = false
+  let hasForce = false
+  let hasTargetDir = false
+  let expectsAppName = false
+
+  for (let token of filteredTokens) {
+    if (expectsAppName) {
+      expectsAppName = false
+      continue
+    }
+
+    if (token === '--app-name') {
+      hasAppName = true
+      expectsAppName = true
+      continue
+    }
+
+    if (token === '--force') {
+      hasForce = true
+      continue
+    }
+
+    if (token.startsWith('-')) {
+      return completeValues([], currentWord)
+    }
+
+    if (!hasTargetDir) {
+      hasTargetDir = true
+      continue
+    }
+
+    return completeValues([], currentWord)
+  }
+
+  if (expectsAppName) {
+    return { mode: 'none' }
+  }
+
+  let flags = withHelpFlags(
+    [...(!hasAppName ? ['--app-name'] : []), ...(!hasForce ? ['--force'] : [])],
+    usedGlobalFlags,
+  )
+
+  if (!hasTargetDir && !currentWord.startsWith('-')) {
+    return { mode: 'files' }
+  }
+
+  return completeValues(flags, currentWord)
+}
+
+function completeRoutes(
+  tokens: string[],
+  currentWord: string,
+  usedGlobalFlags: Set<string>,
+): CompletionResult {
+  let filteredTokens = filterGlobalCommandTokens(tokens, usedGlobalFlags)
+  if (filteredTokens == null) {
+    return completeValues([], currentWord)
+  }
+
+  let hasJson = false
+  let hasNoHeaders = false
+  let hasTable = false
+  let hasVerbose = false
+
+  for (let token of filteredTokens) {
+    if (token === '--json') {
+      hasJson = true
+      continue
+    }
+
+    if (token === '--table') {
+      hasTable = true
+      continue
+    }
+
+    if (token === '--no-headers') {
+      hasNoHeaders = true
+      continue
+    }
+
+    if (token === '--verbose') {
+      hasVerbose = true
+      continue
+    }
+
+    return completeValues([], currentWord)
+  }
+
+  let flags = withHelpFlags(
+    [
+      ...(!hasJson && !hasTable && !hasVerbose ? ['--json'] : []),
+      ...(!hasTable && !hasJson ? ['--table'] : []),
+      ...(!hasNoHeaders && hasTable ? ['--no-headers'] : []),
+      ...(!hasVerbose && !hasJson ? ['--verbose'] : []),
+    ],
+    usedGlobalFlags,
+  )
+
+  return completeValues(flags, currentWord)
+}
+
+function completeCompletionCommand(
+  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([...COMPLETION_SHELLS], usedGlobalFlags), currentWord)
+  }
+
+  return completeValues([], currentWord)
+}
+
+function completeSimpleFlags(
+  tokens: string[],
+  currentWord: string,
+  usedGlobalFlags: Set<string>,
+  commandFlags: string[],
+): CompletionResult {
+  let filteredTokens = filterGlobalCommandTokens(tokens, usedGlobalFlags)
+  if (filteredTokens == null) {
+    return completeValues([], currentWord)
+  }
+
+  let usedFlags = new Set<string>()
+  for (let token of filteredTokens) {
+    if (!commandFlags.includes(token)) {
+      return completeValues([], currentWord)
+    }
+
+    usedFlags.add(token)
+  }
+
+  let availableFlags = commandFlags.filter((flag) => !usedFlags.has(flag))
+  return completeValues(withHelpFlags(availableFlags, usedGlobalFlags), currentWord)
+}
+
+function getTopLevelSuggestions(currentWord: string, usedFlags: Set<string>): string[] {
+  let flags = [
+    ...(!usedFlags.has('-h') ? ['-h', '--help'] : []),
+    ...(!usedFlags.has('--no-color') ? ['--no-color'] : []),
+    ...(!usedFlags.has('-v') ? ['-v', '--version'] : []),
+  ]
+
+  if (currentWord.startsWith('-')) {
+    return flags
+  }
+
+  return [...ROOT_COMMANDS, ...flags]
+}
+
+function withHelpFlags(values: string[], usedGlobalFlags: Set<string>): string[] {
+  return [
+    ...values,
+    ...(!usedGlobalFlags.has('-h') ? ['-h', '--help'] : []),
+    ...(!usedGlobalFlags.has('--no-color') ? ['--no-color'] : []),
+  ]
+}
+
+function filterGlobalCommandTokens(
+  tokens: string[],
+  usedGlobalFlags: Set<string>,
+): string[] | null {
+  let filtered: string[] = []
+
+  for (let token of tokens) {
+    if (token === '--no-color') {
+      usedGlobalFlags.add('--no-color')
+      continue
+    }
+
+    if (token === '-h' || token === '--help') {
+      usedGlobalFlags.add('-h')
+      return null
+    }
+
+    filtered.push(token)
+  }
+
+  return filtered
+}
+
+function completeValues(values: string[], currentWord: string): CompletionResult {
+  return {
+    mode: 'values',
+    values: values.filter((value) => value.startsWith(currentWord)),
+  }
+}
+
+function getTokensBeforeCursor(words: string[], currentIndex: number): string[] {
+  let startIndex = words[0] === 'remix' ? 1 : 0
+  let endIndex = Math.max(startIndex, Math.min(currentIndex, words.length))
+
+  return words.slice(startIndex, endIndex)
+}

package/src/lib/contained-path.ts

@@ -0,0 +1,13 @@
+import * as path from 'node:path'
+
+export function resolveContainedPath(rootDir: string, relativePath: string): string {
+  let resolvedRootDir = path.resolve(rootDir)
+  let resolvedPath = path.resolve(resolvedRootDir, relativePath)
+  let pathFromRoot = path.relative(resolvedRootDir, resolvedPath)
+
+  if (pathFromRoot === '' || (!pathFromRoot.startsWith('..') && !path.isAbsolute(pathFromRoot))) {
+    return resolvedPath
+  }
+
+  throw new Error(`Resolved path escapes the allowed root: ${relativePath}`)
+}

package/src/lib/controller-files.ts

@@ -0,0 +1,79 @@
+import * as path from 'node:path'
+
+const OWNER_FILE_EXTENSIONS = ['.ts', '.tsx', '.js', '.jsx'] as const
+export type OwnerFileExtension = (typeof OWNER_FILE_EXTENSIONS)[number]
+
+export function getActionOwnerCandidates(segments: string[]): string[] {
+  return OWNER_FILE_EXTENSIONS.map((extension) =>
+    normalizeRelativePath(path.join('app', 'controllers', `${path.join(...segments)}${extension}`)),
+  )
+}
+
+export function getControllerOwnerCandidates(segments: string[]): string[] {
+  return OWNER_FILE_EXTENSIONS.map((extension) =>
+    normalizeRelativePath(path.join('app', 'controllers', ...segments, `controller${extension}`)),
+  )
+}
+
+export function getRouteSubtreePath(segments: string[]): string {
+  return normalizeRelativePath(path.join('app', 'controllers', ...segments))
+}
+
+export function getPreferredOwnerDisplayPath(candidates: string[]): string {
+  let tsxCandidate = candidates.find((candidate) => candidate.endsWith('.tsx'))
+  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, '-')
+    .replace(/\.+/g, '-')
+    .replace(/([a-z0-9])([A-Z])/g, '$1-$2')
+    .replace(/([A-Z])([A-Z][a-z])/g, '$1-$2')
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, '-')
+    .replace(/-+/g, '-')
+    .replace(/^-+|-+$/g, '')
+
+  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('/')
+}