# Copyright (c) 2011 The Chromium OS Authors. All rights reserved.
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.

# Add programmable completion to some Chromium OS build scripts


# Echo a list of -- flags that the current command accepts. The
# function assumes that the command supports shflags' --help flag.
_flags() {
  echo $(command "${COMP_WORDS[0]}" --help 2>&1 \
    | egrep -o -- --\[^\ \]+: \
    | sed 's/://; s/--\[no\]\(.\+\)/--\1 --no\1/')
}


# Complete flags, i.e., current words starting with --. Return 1 if
# the current word doesn't start with --, 0 otherwise.
_flag_complete() {
  COMPREPLY=()
  local cur="${COMP_WORDS[COMP_CWORD]}"
  if [[ "${cur}" == --* ]]; then
    COMPREPLY=( $(compgen -W "$(_flags)" -- ${cur}) )
    return 0
  fi
  return 1
}


# Look for "--arg=foo" or "--arg foo" (where foo can be an empty string) in the
# word to be completed. If found, echo "--arg=foo".
_argeq() {
  local arg=$1
  local w0="${COMP_WORDS[COMP_CWORD]}"
  local w1="${COMP_WORDS[COMP_CWORD-1]}"

  # Check for completing "--arg="
  if [ "${w1}" == ${arg} -a "${w0}" == "=" ]; then
    echo "${w1}${w0}"
    return 0
  fi

  # Check for completing "--arg foo"
  if [ "${w1}" == ${arg} ]; then
    echo "${w1}=${w0}"
    return 0
  fi

  # Check for completing "--arg=foo"
  if [ ${COMP_CWORD} -gt 2 ]; then
    local w2="${COMP_WORDS[COMP_CWORD-2]}"
    if [ "${w2}" == ${arg} -a "${w1}" == "=" ]; then
      echo "${w2}${w1}${w0}"
      return 0
    fi
  fi
}


# echo the existing target board sysroots
_board_sysroots() {
  local builddir=/build
  if [ -d ${builddir} ]; then
    echo $(command ls "${builddir}")
  fi
}

_complete_board_sysroot_flag() {
  COMPREPLY=()
  local arg=$(_argeq --board)
  if [[ ${arg} == --board=* ]]; then
    COMPREPLY=( $(compgen -W "$(_board_sysroots)" -- ${arg#--board=}) )
    return 0
  fi
  return 1
}

# Completion for --board= argument for existing board sysroots
_board_sysroot() {
  _flag_complete && return 0
  _complete_board_sysroot_flag && return 0
}

# Completion for -c and -s argument for autotest script
_ls_autotest() {
  local autotest_dir=../third_party/autotest/files
  ls --color=never -dBFH ${autotest_dir}/$1* 2>/dev/null \
    | sed s/"..\/third_party\/autotest\/files\/"//g
}

_autotest_complete() {
  _flag_complete && return 0

  local arg=$(_argeq -c)
  if [[ ${arg} == -c=* ]]; then
    COMPREPLY=($(compgen -W "$(_ls_autotest ${arg#-c=})"))
    return 0
  fi

  arg=$(_argeq -s)
  if [[ ${arg} == -s=* ]]; then
    COMPREPLY=($(compgen -W "$(_ls_autotest ${arg#-s=})"))
    return 0
  fi

  _complete_board_sysroot_flag && return 0
}

# Complete cros_workon's <command> argument.
#
# TODO(petkov): We should probably extract the list of commands from
# cros_workon --help, just like we do for flags (see _flag_complete).
#
# TODO(petkov): Currently, this assumes that the command is the first
# argument. In practice, the command is the first non-flag
# argument. I.e., this should be fixed to support something like
# "cros_workon --all list".
_complete_cros_workon_command() {
  [ ${COMP_CWORD} -eq 1 ] || return 1
  local command="${COMP_WORDS[1]}"
  COMPREPLY=($(compgen -W "start stop list iterate" -- "$command"))
  return 0
}

# Prints the full path to the cros_workon executable, handling tilde
# expansion for the current user.
_cros_workon_executable() {
  local cros_workon="${COMP_WORDS[0]}"
  if [[ "$cros_workon" == '~/'* ]]; then
    cros_workon="$HOME/${cros_workon#'~/'}"
  fi
  echo "$cros_workon"
}

# Lists the workon (or live, if --all is passed in) ebuilds. Lists
# both the full names (e.g., chromeos-base/metrics) as well as just
# the ebuild names (e.g., metrics).
_cros_workon_list() {
  local cros_workon=$(_cros_workon_executable)
  ${cros_workon} list $1 | sed 's,\(.\+\)/\(.\+\),\1/\2 \2,'
}

# Completes the current cros_workon argument assuming it's a
# package/ebuild name.
_complete_cros_workon_package() {
  [ ${COMP_CWORD} -gt 1 ] || return 1
  local package="${COMP_WORDS[COMP_CWORD]}"
  local command="${COMP_WORDS[1]}"
  # If "start", complete based on all workon packages.
  if [[ ${command} == "start" ]]; then
    COMPREPLY=($(compgen -W "$(_cros_workon_list --all)" -- "$package"))
    return 0
  fi
  # If "stop" or "iterate", complete based on all live packages.
  if [[ ${command} == "stop" ]] || [[ ${command} == "iterate" ]]; then
    COMPREPLY=($(compgen -W "$(_cros_workon_list)" -- "$package"))
    return 0
  fi
  return 1
}

# Complete cros_workon arguments.
_cros_workon() {
  COMPREPLY=()
  _flag_complete && return 0
  _complete_board_sysroot_flag && return 0
  _complete_cros_workon_command && return 0
  _complete_cros_workon_package && return 0
  return 0
}

_list_repo_commands() {
  local repo=${COMP_WORDS[0]}
  "$repo" help --all | grep -E '^  ' | sed 's/  \([^ ]\+\) .\+/\1/'
}

_list_repo_branches() {
  local repo=${COMP_WORDS[0]}
  "$repo" branches 2>&1 | grep \| | sed 's/[ *][Pp ] *\([^ ]\+\) .*/\1/'
}

_list_repo_projects() {
  local repo=${COMP_WORDS[0]}
  "$repo" manifest -o /dev/stdout 2> /dev/null \
    | grep 'project name=' \
    | sed 's/.\+name="\([^"]\+\)".\+/\1/'
}

# Complete repo's <command> argument.
_complete_repo_command() {
  [ ${COMP_CWORD} -eq 1 ] || return 1
  local command=${COMP_WORDS[1]}
  COMPREPLY=($(compgen -W "$(_list_repo_commands)" -- "$command"))
  return 0
}

_complete_repo_arg() {
  [ ${COMP_CWORD} -gt 1 ] || return 1
  local command=${COMP_WORDS[1]}
  local current=${COMP_WORDS[COMP_CWORD]}
  if [[ ${command} == "abandon" ]]; then
    if [[ ${COMP_CWORD} -eq 2 ]]; then
      COMPREPLY=($(compgen -W "$(_list_repo_branches)" -- "$current"))
    else
      COMPREPLY=($(compgen -W "$(_list_repo_projects)" -- "$current"))
    fi
    return 0
  fi
  if [[ ${command} == "help" ]]; then
    [ ${COMP_CWORD} -eq 2 ] && \
      COMPREPLY=($(compgen -W "$(_list_repo_commands)" -- "$current"))
    return 0
  fi
  if [[ ${command} == "start" ]]; then
    [ ${COMP_CWORD} -gt 2 ] && \
      COMPREPLY=($(compgen -W "$(_list_repo_projects)" -- "$current"))
    return 0
  fi
  return 1
}

# Complete repo arguments.
_complete_repo() {
  COMPREPLY=()
  _complete_repo_command && return 0
  _complete_repo_arg && return 0
  return 0
}

complete -o bashdefault -o default -F _board_sysroot \
  build_autotest.sh \
  build_image \
  build_packages \
  image_to_usb.sh \
  mod_image_for_test.sh
complete -o bashdefault -o default -o nospace -F _autotest_complete autotest
complete -F _cros_workon cros_workon
complete -F _complete_repo repo

###  Local Variables:
###  mode: shell-script
###  End: