heroku 11.0.0-alpha.10 → 11.0.0-alpha.12

package/lib/oldCommands/autocomplete/create.js

@@ -1,254 +0,0 @@
-export {};
-/*
-import {Command} from '@oclif/core'
-import * as fs from 'fs-extra'
-import * as path from 'path'
-
-import {AutocompleteBase} from '../../lib/autocomplete/base'
-
-const debug = require('debug')('autocomplete:create')
-
-const AC_LIB_PATH = path.resolve(__dirname, '..', '..', '..', 'autocomplete-scripts')
-
-export default class Create extends AutocompleteBase {
-  static hidden = true
-
-  static description = 'create autocomplete setup scripts and completion functions'
-
-  private _commands?: Command.Loadable[]
-
-  async run() {
-    this.errorIfWindows()
-    // 1. ensure needed dirs
-    await this.ensureDirs()
-    // 2. save (generated) autocomplete files
-    await this.createFiles()
-  }
-
-  private async ensureDirs() {
-    // ensure autocomplete cache dir
-    await fs.ensureDir(this.autocompleteCacheDir)
-    // ensure autocomplete completions dir
-    await fs.ensureDir(this.completionsCacheDir)
-  }
-
-  private async createFiles() {
-    await fs.writeFile(this.bashSetupScriptPath, this.bashSetupScript)
-    await fs.writeFile(this.zshSetupScriptPath, this.zshSetupScript)
-    await fs.writeFile(this.bashCommandsListPath, this.bashCommandsList)
-    await fs.writeFile(this.zshCompletionSettersPath, this.zshCompletionSetters)
-  }
-
-  private get bashSetupScriptPath(): string {
-    // <cacheDir>/autocomplete/bash_setup
-    return path.join(this.autocompleteCacheDir, 'bash_setup')
-  }
-
-  private get bashCommandsListPath(): string {
-    // <cacheDir>/autocomplete/commands
-    return path.join(this.autocompleteCacheDir, 'commands')
-  }
-
-  private get zshSetupScriptPath(): string {
-    // <cacheDir>/autocomplete/zsh_setup
-    return path.join(this.autocompleteCacheDir, 'zsh_setup')
-  }
-
-  private get zshCompletionSettersPath(): string {
-    // <cacheDir>/autocomplete/commands_setters
-    return path.join(this.autocompleteCacheDir, 'commands_setters')
-  }
-
-  private get skipEllipsis(): boolean {
-    return process.env.HEROKU_AC_ZSH_SKIP_ELLIPSIS === '1'
-  }
-
-  private get commands(): Command.Loadable[] {
-    if (this._commands) return this._commands
-
-    const plugins = this.config.plugins
-    const commands: Command.Loadable[] = []
-
-    plugins.forEach(p => {
-      p.commands.forEach(c => {
-        if (c.hidden) return
-        try {
-          commands.push(c)
-        } catch (error: any) {
-          debug(`Error creating completions for command ${c.id}`)
-          debug(error.message)
-          this.writeLogFile(error.message)
-        }
-      })
-    })
-
-    this._commands = commands
-    return this._commands
-  }
-
-  private get bashCommandsList(): string {
-    return this.commands.map(c => {
-      try {
-        const publicFlags = this.genCmdPublicFlags(c).trim()
-        return `${c.id} ${publicFlags}`
-      } catch (error: any) {
-        debug(`Error creating bash completion for command ${c.id}, moving on...`)
-        debug(error.message)
-        this.writeLogFile(error.message)
-        return ''
-      }
-    }).join('\n')
-  }
-
-  private get zshCompletionSetters(): string {
-    const cmdsSetter = this.zshCommandsSetter
-    const flagSetters = this.zshCommandsFlagsSetters
-    return `${cmdsSetter}\n${flagSetters}`
-  }
-
-  private get zshCommandsSetter(): string {
-    const cmdsWithDescriptions = this.commands.map(c => {
-      try {
-        return this.genCmdWithDescription(c)
-      } catch (error: any) {
-        debug(`Error creating zsh autocomplete for command ${c.id}, moving on...`)
-        debug(error.message)
-        this.writeLogFile(error.message)
-        return ''
-      }
-    })
-
-    return this.genZshAllCmdsListSetter(cmdsWithDescriptions)
-  }
-
-  private get zshCommandsFlagsSetters(): string {
-    return this.commands.map(c => {
-      try {
-        return this.genZshCmdFlagsSetter(c)
-      } catch (error: any) {
-        debug(`Error creating zsh autocomplete for command ${c.id}, moving on...`)
-        debug(error.message)
-        this.writeLogFile(error.message)
-        return ''
-      }
-    }).join('\n')
-  }
-
-  private genCmdPublicFlags(command: Command.Loadable): string {
-    const Flags = command.flags || {}
-    return Object.keys(Flags)
-      .filter(flag => !Flags[flag].hidden)
-      .map(flag => `--${flag}`)
-      .join(' ')
-  }
-
-  private genCmdWithDescription(command: Command.Loadable): string {
-    let description = ''
-    if (command.description) {
-      const text = command.description.split('\n')[0]
-      description = `:"${text}"`
-    }
-
-    return `"${command.id.replace(/:/g, '\\:')}"${description}`
-  }
-
-  private genZshCmdFlagsSetter(command: Command.Loadable): string {
-    const id = command.id
-    const flagscompletions = Object.keys(command.flags || {})
-      .filter(flag => command.flags && !command.flags[flag].hidden)
-      .map(flag => {
-        const f = (command.flags && command.flags[flag]) || {description: ''}
-        const isBoolean = f.type === 'boolean'
-        const hasCompletion = 'completion' in f || this.findCompletion(id, flag, f.description)
-        const name = isBoolean ? flag : `${flag}=-`
-        let cachecompl = ''
-        if (hasCompletion) {
-          cachecompl = ': :_compadd_flag_options'
-        }
-
-        if (this.wantsLocalFiles(flag)) {
-          cachecompl = ': :_files'
-        }
-
-        const help = isBoolean ? '(switch) ' : (hasCompletion ? '(autocomplete) ' : '')
-        const completion = `--${name}[${help}${f.description}]${cachecompl}`
-        return `"${completion}"`
-      })
-      .join('\n')
-
-    if (flagscompletions) {
-      return `_set_${id.replace(/:/g, '_')}_flags () {
-_flags=(
-${flagscompletions}
-)
-}
-`
-    }
-
-    return `# no flags for ${id}`
-  }
-
-  private genZshAllCmdsListSetter(cmdsWithDesc: Array<string>): string {
-    return `
-_set_all_commands_list () {
-_all_commands_list=(
-${cmdsWithDesc.join('\n')}
-)
-}
-`
-  }
-
-  private get envAnalyticsDir(): string {
-    return `HEROKU_AC_ANALYTICS_DIR=${path.join(
-      this.autocompleteCacheDir,
-      'completion_analytics',
-    )};`
-  }
-
-  private get envCommandsPath(): string {
-    return `HEROKU_AC_COMMANDS_PATH=${path.join(this.autocompleteCacheDir, 'commands')};`
-  }
-
-  private get bashSetupScript(): string {
-    return `${this.envAnalyticsDir}
-${this.envCommandsPath}
-HEROKU_AC_BASH_COMPFUNC_PATH=${path.join(
-    AC_LIB_PATH,
-    'bash',
-    'heroku.bash',
-  )} && test -f $HEROKU_AC_BASH_COMPFUNC_PATH && source $HEROKU_AC_BASH_COMPFUNC_PATH;
-`
-  }
-
-  private get zshSetupScript(): string {
-    return `${this.skipEllipsis ? '' : this.completionDotsFunc}
-${this.envAnalyticsDir}
-${this.envCommandsPath}
-HEROKU_AC_ZSH_SETTERS_PATH=\${HEROKU_AC_COMMANDS_PATH}_setters && test -f $HEROKU_AC_ZSH_SETTERS_PATH && source $HEROKU_AC_ZSH_SETTERS_PATH;
-fpath=(
-${path.join(AC_LIB_PATH, 'zsh')}
-$fpath
-);
-autoload -Uz compinit;
-compinit;
-`
-  }
-
-  private get completionDotsFunc(): string {
-    return `expand-or-complete-with-dots() {
-  echo -n "..."
-  zle expand-or-complete
-  zle redisplay
-}
-zle -N expand-or-complete-with-dots
-bindkey "^I" expand-or-complete-with-dots`
-  }
-
-  private wantsLocalFiles(flag: string): boolean {
-    return [
-      'file',
-      'procfile',
-    ].includes(flag)
-  }
-}
-*/

package/lib/oldCommands/autocomplete/doctor.d.ts

@@ -1 +0,0 @@
-export {};

package/lib/oldCommands/autocomplete/doctor.js

@@ -1,110 +0,0 @@
-export {};
-/*
-import {flags} from '@heroku-cli/command'
-import {Args} from '@oclif/core'
-import {hux} from '@heroku/heroku-cli-util'
-import {FlagInput} from '@oclif/core/lib/interfaces/parser'
-import * as fs from 'fs-extra'
-import * as path from 'path'
-
-import {AutocompleteBase} from '../../lib/autocomplete/base'
-
-export default class Doctor extends AutocompleteBase {
-  static hidden = true
-
-  static description = 'autocomplete diagnostic'
-
-  static args = {
-    shell: Args.string({description: 'shell type', required: false}),
-  }
-
-  static flags: FlagInput = {
-    verbose: flags.boolean({description: 'list completable commands'}),
-  }
-
-  async run() {
-    const {args, flags} = await this.parse(Doctor)
-    const shell = args.shell || this.config.shell
-    const printLine: typeof this.log = (...args) => this.log(...args)
-    this.errorIfNotSupportedShell(shell)
-
-    const data = []
-
-    // cli version
-    data.push({name: 'cli version', value: this.config.version})
-
-    // plugin version
-    const pjson = require(path.resolve(__dirname, '..', '..', '..', 'package.json'))
-    data.push({name: 'plugin version', value: pjson.version})
-
-    // check shell shim source env var
-    // i.e. HEROKU_AC_<shell>_SETUP_PATH
-    const shellProfilePath = path.join(process.env.HOME || '', shell === 'zsh' ? '.zshrc' : '.bashrc')
-    const shellProfile = fs.readFileSync(shellProfilePath)
-    const regex = /AC_\w+_SETUP_PATH/
-    const shimValue = regex.exec(shellProfile.toString()) ? 'present' : 'missing'
-    data.push({name: `~/${shell === 'zsh' ? '.zshrc' : '.bashrc'} shimmed`, value: shimValue})
-
-    // check shell shim
-    const shellCompletion = path.join(this.autocompleteCacheDir, `${shell}_setup`)
-    const shellCompletionValue = fs.existsSync(shellCompletion) ? 'present' : 'missing'
-    data.push({name: `${shell} shim file`, value: shellCompletionValue})
-
-    // check shell command cache
-    const shellCmdCache = path.join(this.autocompleteCacheDir, shell === 'zsh' ? 'commands_setters' : 'commands')
-    const shellCmdCacheValue = fs.existsSync(shellCmdCache) ? 'present' : 'missing'
-    data.push({name: `${shell} commands cache`, value: shellCmdCacheValue})
-
-    // check app completion cache
-    const appsCache = path.join(this.completionsCacheDir, 'app')
-    let appsCacheValue
-    if (fs.existsSync(appsCache)) {
-      const length = fs.readJSONSync(appsCache).length
-      appsCacheValue = length || 'empty'
-    } else {
-      appsCacheValue = 'missing'
-    }
-
-    data.push({name: 'apps completion cache', value: appsCacheValue})
-
-    hux.table(data, {
-      name: {},
-      value: {},
-    }, {'no-header': true, printLine})
-
-    if (flags.verbose) this.printList()
-  }
-
-  private printList() {
-    this.log()
-    const header = 'Completable Commands'
-    this.log(header)
-    this.log('='.repeat(header.length))
-    this.config.plugins.forEach(p => {
-      p.commands.forEach(c => {
-        try {
-          if (c.hidden) {
-            this.log(`${c.id} (hidden)`)
-          } else {
-            const results = Object.keys(c.flags).map((f: string) => {
-              let out = `--${f}`
-              const flag = c.flags[f]
-              if (flag.type === 'option') out += '='
-              const hasCompletion = 'completion' in flag || this.findCompletion(c.id, f, flag.description)
-              if (hasCompletion) {
-                out += '(c)'
-              }
-
-              if (flag.hidden) out += '(h)'
-              return out
-            })
-            if (results.length > 0) this.log(`${c.id} -> ${results}`)
-          }
-        } catch {
-          this.log(`Error creating autocomplete for command ${c.id}`)
-        }
-      })
-    })
-  }
-}
-*/

package/lib/oldCommands/autocomplete/index.d.ts

@@ -1 +0,0 @@
-export {};

package/lib/oldCommands/autocomplete/index.js

@@ -1,80 +0,0 @@
-export {};
-/*
-import {flags} from '@heroku-cli/command'
-import {AppCompletion, PipelineCompletion, SpaceCompletion, TeamCompletion} from '@heroku-cli/command/lib/completions'
-import chalk from 'chalk'
-import {Args, ux} from '@oclif/core'
-import {FlagInput} from '@oclif/core/lib/interfaces/parser'
-
-import * as path from 'path'
-
-import {AutocompleteBase} from '../../lib/autocomplete/base'
-import {updateCache} from '../../lib/autocomplete/cache'
-
-import Create from './create'
-
-export default class Index extends AutocompleteBase {
-  static description = 'display autocomplete installation instructions'
-
-  static args = {
-    shell: Args.string({description: 'shell type', required: false}),
-  }
-
-  static flags: FlagInput = {
-    'refresh-cache': flags.boolean({description: 'refresh cache only (ignores displaying instructions)', char: 'r'}),
-  }
-
-  static examples = [
-    '$ heroku autocomplete',
-    '$ heroku autocomplete bash',
-    '$ heroku autocomplete zsh',
-    '$ heroku autocomplete --refresh-cache',
-  ]
-
-  async run() {
-    const {args, flags} = await this.parse(Index)
-    const shell = args.shell || this.config.shell
-    this.errorIfNotSupportedShell(shell)
-
-    ux.action.start(`${chalk.bold('Building the autocomplete cache')}`)
-    await Create.run([], this.config)
-    await this.updateCache(AppCompletion, 'app')
-    await this.updateCache(PipelineCompletion, 'pipeline')
-    await this.updateCache(SpaceCompletion, 'space')
-    await this.updateCache(TeamCompletion, 'team')
-    ux.action.stop()
-
-    if (!flags['refresh-cache']) {
-      const bin = this.config.bin
-      const bashNote = 'If your terminal starts as a login shell you may need to print the init script into ~/.bash_profile or ~/.profile.'
-      const zshNote = `After sourcing, you can run \`${chalk.cyan('$ compaudit -D')}\` to ensure no permissions conflicts are present`
-      const note = shell === 'zsh' ? zshNote : bashNote
-      const tabStr = shell === 'bash' ? '<TAB><TAB>' : '<TAB>'
-
-      this.log(`
-${chalk.bold(`Setup Instructions for ${bin.toUpperCase()} CLI Autocomplete ---`)}
-
-1) Add the autocomplete env var to your ${shell} profile and source it
-${chalk.cyan(`$ printf "$(${bin} autocomplete:script ${shell})" >> ~/.${shell}rc; source ~/.${shell}rc`)}
-
-NOTE: ${note}
-
-2) Test it out, e.g.:
-${chalk.cyan(`$ ${bin} ${tabStr}`)}                 # Command completion
-${chalk.cyan(`$ ${bin} apps:info --${tabStr}`)}     # Flag completion
-${chalk.cyan(`$ ${bin} apps:info --app=${tabStr}`)} # Flag option completion
-
-Visit the autocomplete Dev Center doc at https://devcenter.heroku.com/articles/heroku-cli-autocomplete
-
-Enjoy!
-`)
-    }
-  }
-
-  private async updateCache(completion: any, cacheKey: string) {
-    const cachePath = path.join(this.completionsCacheDir, cacheKey)
-    const options = await completion.options({config: this.config})
-    await updateCache(cachePath, options)
-  }
-}
-*/

package/lib/oldCommands/autocomplete/options.d.ts

@@ -1 +0,0 @@
-export {};

package/lib/oldCommands/autocomplete/options.js

@@ -1,240 +0,0 @@
-export {};
-/*
-import {flags} from '@heroku-cli/command'
-import {Args, Command} from '@oclif/core'
-import * as path from 'path'
-
-import {AutocompleteBase} from '../../lib/autocomplete/base'
-import {fetchCache} from '../../lib/autocomplete/cache'
-
-export default class Options extends AutocompleteBase {
-  static hidden = true
-
-  static description = 'display arg or flag completion options (used internally by completion functions)'
-
-  static flags = {
-    app: flags.app({required: false, hidden: true}),
-  }
-
-  static args = {
-    completion: Args.string({strict: false}),
-  }
-
-  parsedArgs: { [name: string]: string } = {}
-
-  parsedFlags: { [name: string]: string } = {}
-
-  // helpful dictionary
-  //
-  // *args: refers to a Command's static args
-  // *argv: refers to the current execution's command line positional input
-  // Klass: (class) Command class
-  // completion: (object) object with data/methods to build/retrieve options from cache
-  // curPosition*: the current argv position the shell is trying to complete
-  // options: (string) white-space separated list of values for the shell to use for completion
-
-  async run() {
-    this.errorIfWindows()
-
-    // ex: heroku autocomplete:options 'heroku addons:destroy -a myapp myaddon'
-    try {
-      const commandStateVars = await this.processCommandLine()
-      const completion = this.determineCompletion(commandStateVars)
-      const options = await this.fetchOptions(completion)
-      if (options) this.log(options)
-    } catch (error: any) {
-      // write to ac log
-      this.writeLogFile(error.message)
-    }
-  }
-
-  private async processCommandLine() {
-    // find command id
-    const commandLineToComplete = this.argv[0].split(' ')
-    const id = commandLineToComplete[1]
-    // find Command
-    const C = this.config.findCommand(id)
-    let Klass
-    if (C) {
-      Klass = await C.load()
-      // process Command state from command line data
-      const slicedArgv = commandLineToComplete.slice(2)
-      const [argsIndex, curPositionIsFlag, curPositionIsFlagValue] = this.determineCmdState(slicedArgv, Klass)
-      return {id, Klass, argsIndex, curPositionIsFlag, curPositionIsFlagValue, slicedArgv}
-    }
-
-    this.throwError(`Command ${id} not found`)
-  }
-
-  private determineCompletion(commandStateVars: any) {
-    const {id, Klass, argsIndex, curPositionIsFlag, curPositionIsFlagValue, slicedArgv} = commandStateVars
-    // setup empty cache completion vars to assign
-    let cacheKey: any
-    let cacheCompletion: any
-
-    // completing a flag/value? else completing an arg
-    if (curPositionIsFlag || curPositionIsFlagValue) {
-      const slicedArgvCount = slicedArgv.length
-      const lastArgvArg = slicedArgv[slicedArgvCount - 1]
-      const previousArgvArg = slicedArgv[slicedArgvCount - 2]
-      const argvFlag = curPositionIsFlagValue ? previousArgvArg : lastArgvArg
-      const {name, flag} = this.findFlagFromWildArg(argvFlag, Klass)
-      if (!flag) this.throwError(`${argvFlag} is not a valid flag for ${id}`)
-      cacheKey = name || flag.name
-      cacheCompletion = flag.completion
-    } else {
-      const cmdArgs = Klass.args || []
-      // variable arg (strict: false)
-      if (!Klass.strict) {
-        cacheKey = cmdArgs[0] && cmdArgs[0].name.toLowerCase()
-        cacheCompletion = this.findCompletion(cacheKey, id)
-        if (!cacheCompletion) this.throwError(`Cannot complete variable arg position for ${id}`)
-      } else if (argsIndex > cmdArgs.length - 1) {
-        this.throwError(`Cannot complete arg position ${argsIndex} for ${id}`)
-      } else {
-        const arg = cmdArgs[argsIndex]
-        cacheKey = arg.name.toLowerCase()
-      }
-    }
-
-    // try to auto-populate the completion object
-    if (!cacheCompletion) {
-      cacheCompletion = this.findCompletion(cacheKey, id)
-    }
-
-    return {cacheKey, cacheCompletion}
-  }
-
-  private async fetchOptions(cache: any) {
-    const {cacheCompletion, cacheKey} = cache
-    const flags = await this.parsedFlagsWithEnvVars()
-
-    // build/retrieve & return options cache
-    if (cacheCompletion && cacheCompletion.options) {
-      const ctx = {
-        args: this.parsedArgs,
-        // special case for app & team env vars
-        flags,
-        argv: this.argv,
-        config: this.config,
-      }
-      // use cacheKey function or fallback to arg/flag name
-      const ckey = cacheCompletion.cacheKey ? await cacheCompletion.cacheKey(ctx) : null
-      const key: string = ckey || cacheKey || 'unknown_key_error'
-      const flagCachePath = path.join(this.completionsCacheDir, key)
-
-      // build/retrieve cache
-      const duration = cacheCompletion.cacheDuration || 60 * 60 * 24 // 1 day
-      const opts = {cacheFn: () => cacheCompletion.options(ctx)}
-      const options = await fetchCache(flagCachePath, duration, opts)
-
-      // return options cache
-      return (options || []).join('\n')
-    }
-  }
-
-  private async parsedFlagsWithEnvVars() {
-    const {flags} = await this.parse(Options)
-    return {
-      app: process.env.HEROKU_APP || flags.app,
-      team: process.env.HEROKU_TEAM || process.env.HEROKU_ORG,
-      ...this.parsedFlags,
-    }
-  }
-
-  private throwError(msg: string) {
-    throw new Error(msg)
-  }
-
-  private findFlagFromWildArg(wild: string, Klass: Command.Class): { flag: any; name: any } {
-    let name = wild.replace(/^-+/, '')
-    name = name.replace(/[=](.+)?$/, '')
-
-    const unknown = {flag: undefined, name: undefined}
-    if (!Klass.flags) return unknown
-    const CFlags = Klass.flags
-
-    let flag = CFlags[name]
-    if (flag) return {name, flag}
-
-    name = Object.keys(CFlags).find((k: string) => CFlags[k].char === name) || 'undefinedcommand'
-    flag = CFlags && CFlags[name]
-    if (flag) return {name, flag}
-    return unknown
-  }
-
-  private determineCmdState(argv: string[], Klass: Command.Class): [number, boolean, boolean] {
-    const argNames = Object.keys(Klass.args || {})
-    let needFlagValueSatisfied = false
-    let argIsFlag = false
-    let argIsFlagValue = false
-    let argsIndex = -1
-    let flagName: string
-
-    argv.filter(wild => {
-      if (wild.match(/^-(-)?/)) {
-        // we're a flag
-        argIsFlag = true
-
-        // ignore me
-        const wildSplit = wild.split('=')
-        const key = wildSplit.length === 1 ? wild : wildSplit[0]
-        const {name, flag} = this.findFlagFromWildArg(key, Klass)
-        flagName = name
-        // end ignore me
-
-        if (wildSplit.length === 1) {
-          // we're a flag w/o a '=value'
-          // (find flag & see if flag needs a value)
-          if (flag && flag.type !== 'boolean') {
-            // we're a flag who needs our value to be next
-            argIsFlagValue = false
-            needFlagValueSatisfied = true
-            return false
-          }
-        }
-
-        // --app=my-app is considered a flag & not a flag value
-        // the shell's autocomplete handles partial value matching
-
-        // add parsedFlag
-        if (wildSplit.length === 2 && name) this.parsedFlags[name] = wildSplit[1]
-
-        // we're a flag who is satisfied
-        argIsFlagValue = false
-        needFlagValueSatisfied = false
-        return false
-      }
-
-      // we're not a flag
-      argIsFlag = false
-
-      if (needFlagValueSatisfied) {
-        // we're a flag value
-
-        // add parsedFlag
-        if (flagName) this.parsedFlags[flagName] = wild
-
-        argIsFlagValue = true
-        needFlagValueSatisfied = false
-        return false
-      }
-
-      // we're an arg!
-
-      // add parsedArgs
-      // TO-DO: how to handle variableArgs?
-      argsIndex += 1
-      if (argsIndex < argNames.length) {
-        this.parsedArgs[argNames[argsIndex]] = wild
-      }
-
-      argIsFlagValue = false
-      needFlagValueSatisfied = false
-      return true
-    })
-
-    return [argsIndex, argIsFlag, argIsFlagValue]
-  }
-}
-*/

package/lib/oldCommands/autocomplete/script.d.ts

@@ -1 +0,0 @@
-export {};