aurget

#!/bin/bash
#
# pbrisbin 2013
#
###
AUR='https://aur.archlinux.org'

# Message {{{
message() {
  cat <<EOF
Usage: aurget [ -h | -S* [ --options ] [ -- ] <arguments> ]

  Options:

        -S  <package>   process <package> using your default sync_mode

        -Sd <package>   download <package>
        -Sb <package>   download and build <package>
        -Sy <package>   download, build, and install <package>

        -Su             process available upgrades using your default sync_mode

        -Sdu            download available upgrades
        -Sbu            download and build available upgrades
        -Syu            download, build, and install available upgrades

        -Ss  <term>     search aur for <term>
        -Ssq <term>     search aur for <term>, print only package names
        -Sp  <package>  print the PKGBUILD for <package>
        -Si  <package>  print extended info for <package>

        --sort <name|votes>
                        sort search output by name (ascending) or votes
                        (descending), defaults to name

        --builddir <directory>
                        build in <directory>

        --devel         only affects -Su, add all development packages

        --deps          resolve dependencies
        --nodeps        don't resolve dependencies

        --edit          prompt to edit all pkgbuilds
        --noedit        don't prompt to edit any pkgbuilds

        --discard       discard source files after building
        --nodiscard     don't discard source files after building

        --nocolor       disable coloring

        --noconfirm     auto-answer all prompts

        --ignore <package>
                        add additional packages to be ignored

        --config <file> source <file> for user configuration

        -h, --help      display this

  Any unrecognized options will be passed directly to makepkg.

EOF
}
# }}}

# Support {{{
die() {
  error "$*"
  exit 1
}

info() { printf "%b:: %b%b%b\n" "${colorB}" "${colorW}" "$*" "${nocolor}"; }

warn() { printf "%bwarning:%b %b\n" "${colorY}" "${nocolor}" "$*" >&2; }

error() { printf "%berror:%b %b\n" "${colorR}" "${nocolor}" "$*" >&2; }

debug() {
  $debug && printf "%b[%bDEBUG%b]%b %b\n" "${colorW}" "${colorC}" "${colorW}" "${nocolor}" "${*//%/%%}" >&2
}

# thanks Irm
url_encode() {
  hexdump -v -e '1/1 "%02x\t"' -e '1/1 "%_c\n"' <<<"$*" |
    LANG=C awk '
      $1 ~  /0[adAD]/               {                    next }
      $2 ~  /^[a-zA-Z0-9.*()\/_-]$/ { printf("%s", $2);  next }
                                    { printf("%%%s", $1)      }
    '
}

aur_search_url() {
  # avoid printf because url_encode outputs "%"
  echo "$AUR/rpc/?v=5&type=search&arg=$(url_encode "$1")"
}

aur_info_url() {
  local params='' arg

  for arg; do
    params+="&arg\[\]=$(url_encode "$arg")"
  done

  # avoid printf because url_encode outputs "%"
  echo "$AUR/rpc/?v=5&type=info$params"
}

get() {
  debug "HTTP GET $colorM$1$nocolor"
  curl --silent --fail "$1"
}

pkgbuild() {
  get "$AUR/cgit/aur.git/plain/PKGBUILD?h=$(url_encode "$1")"
}

taurball() {
  get "$AUR/cgit/aur.git/snapshot/$(url_encode "$1").tar.gz"
}

rpc_search() { get "$(aur_search_url "$1")" | parse_rpc | sort_rpc; }

rpc_info() { get "$(aur_info_url "$@")" | parse_rpc | sort_rpc; }

parse_rpc() {
  awk -F '[^\\\\]"' -v RS='{"|,"|"}' '
    function unstring(str) {
      sub(/[^:]+:/, ""  , str) # remove prefix
      gsub(/\\"/  , "\"", str) # un-escape quotes
      gsub(/\\\// , "/" , str) # un-escape urls
      gsub(/%/    , "%%", str) # escape percents for printf
      gsub(/\|/   , "/" , str) # replace pipe (our own field sep)
      gsub(/"$/   , ""  , str) # remove extra trailing quote

      if(substr(str, 1, 1) == "\"")
        return substr(str, 2, length(str)) # unquote value
      else
        return str
    }

    /Description":/ { printf "%s",    unstring($0) }
    /Name":/        { printf "|%s",   unstring($0) }
    /NumVotes":/    { printf "|%s",   unstring($0) }
    /OutOfDate":/   { printf "|%s", unstring($0) }
    /PackageBase":/ { printf "|%s",   unstring($0) }
    /URL":/         { printf "|%s",   unstring($0) }
    /Version":/     { printf "|%s\n",   unstring($0) }
  '
}

sort_rpc() {
  case "$sort_mode" in
    name) sort ;;
    votes) sort -t '|' -k 6,6nr -k 1,1 ;;
    *) die 'invalid argument to --sort. must be name or votes' ;;
  esac
}

# For more details on the matching see https://stackoverflow.com/a/15394738
# shellcheck disable=SC2076
keep_sources() { [[ " $keep_source_packages " =~ " $1 " ]]; }

is_devel() { [[ "$1" =~ -(git|hg|svn|darcs|csv|bzr)$ ]]; }

# shellcheck disable=SC2076
is_ignored() { [[ " $ignore_packages " =~ " $1 " ]]; }

downloading() { [[ "$sync_mode" == 'download' ]]; }

installing() { [[ "$sync_mode" == 'install' ]]; }

searching() { [[ "$opmode" == 'search' ]]; }

upgrading() { [[ "$opmode" == 'upgrade' ]]; }

resolving() { $resolve_dependencies; }

eager_sudo() { $eager_sudo; }

create_temp_directory() {
  debug "storing temporary files in $colorM$temp_directory$nocolor"
  mkdir -p "$temp_directory" || die 'unable to create temp directory'
  rm -rf "${temp_directory:?}"/*
}

enter_build_directory() {
  debug "building in $colorM$build_directory$nocolor"
  mkdir -p "$build_directory" || die 'unable to make build directory'
  cd "$build_directory" || die 'unable to change to build directory'
}

buildpkg() {
  debug "executing $colorY$makepkg ${makepkg_options[*]} $*$nocolor"

  if $silent; then
    debug 'building silently...'
    "$makepkg" "${makepkg_options[@]}" "$@" --noconfirm &>/dev/null
  else
    "$makepkg" "${makepkg_options[@]}" "$@"
  fi
}

prompt() {
  local a

  printf "%s? [Y/n] " "$*"

  $noconfirm && {
    printf "Y\n"
    return 0
  }

  read -r a

  case "${a:-y}" in
    y | Y) return 0 ;;
    q | Q) die 'aborted' ;;
    *) return 1 ;;
  esac
}

prompt_to_edit() {
  local name="$1" pkgbuild="$2"
  shift 2
  local action="${*:-sourcing for dependencies}"

  case "${edit_pkgbuilds:-prompt}" in
    never) return 0 ;;
    prompt) prompt "Edit $name's PKGBUILD before $action" || return 0 ;;
  esac

  debug "executing $colorY$EDITOR $pkgbuild$nocolor"

  $EDITOR "$pkgbuild" || die "editor returned non-zero ($?), aborting"

  prompt "Continue $action"
}

prompt_to_install() {
  local name

  printf "\n%bTargets ($#):%b " "${colorY}" "$nocolor"

  for name; do
    printf "%s-%s " "${name}" "${target_versions[$name]}"
  done

  printf "\n\n"

  prompt 'Proceed with installation' || exit 0
}

nothing_to_do() {
  printf " there is nothing to do\n"
  exit 0
}

sudo_upfront() {
  sudo -v

  while true; do
    sudo -n true
    sleep 60
    kill -0 "$$" || exit
  done 2>/dev/null &
}
# }}}

# Initialize {{{
initialize() {
  local config_regex=' --config +([^ ]+) '

  set_defaults

  [[ " $* " =~ ' --debug ' ]] && debug=true
  [[ " $* " =~ ' --nocolor ' ]] && disable_color=true
  [[ " $* " =~ $config_regex ]] && user_config="${BASH_REMATCH[1]}"

  setup_colors
  source_config
  setup_colors

  while [[ -n "$1" ]]; do
    case "$1" in
      -S) opmode='install' ;;
      -Sy)
        opmode='install'
        sync_mode='install'
        ;;
      -Sb)
        opmode='install'
        sync_mode='build'
        ;;
      -Sd)
        opmode='install'
        sync_mode='download'
        ;;
      -Su) opmode='upgrade' ;;
      -Syu | -Suy)
        opmode='upgrade'
        sync_mode='install'
        ;;
      -Sbu | -Sub)
        opmode='upgrade'
        sync_mode='build'
        ;;
      -Sdu | -Sud)
        opmode='upgrade'
        sync_mode='download'
        ;;
      -Ss)
        opmode='search'
        search_mode='search'
        ;;
      -Ssq | -Sqs)
        opmode='search'
        search_mode='quiet'
        ;;
      -Si | -Ssi | -Sis)
        opmode='search'
        search_mode='info'
        ;;
      -Sp | -Ssp | -Sps)
        opmode='search'
        search_mode='print'
        ;;
      --aur4) warn "deprecated --aur4 option, ignoring..." ;;
      --builddir)
        shift
        build_directory="$1"
        ;;
      --ignore)
        shift
        ignore_packages+=" $1"
        ;;
      --noconfirm)
        noconfirm=true
        makepkg_options+=('--noconfirm')
        ;;
      --devel) devels=true ;;
      --deps) resolve_dependencies=true ;;
      --nodeps) resolve_dependencies=false ;;
      --edit) edit_pkgbuilds='always' ;;
      --noedit) edit_pkgbuilds='never' ;;
      --discard) discard_sources=true ;;
      --nodiscard) discard_sources=false ;;
      --silent) silent=true ;;
      --sort)
        shift
        sort_mode="$1"
        ;;
      -h | --help)
        message
        exit
        ;;
      --)
        shift
        arguments+=("$@")
        return
        ;;
      --debug) : ;;
      --nocolor) : ;;
      --config)
        :
        shift
        ;;
      -*)
        warn "unknown option $1, treating as makepkg argument..."
        makepkg_options+=("$1")
        ;;
      *) arguments+=("$1") ;;
    esac

    shift
  done

  [[ -z "$opmode" ]] && {
    message
    exit 1
  }
}

set_defaults() {
  build_directory="$PWD"
  debug=false
  devels=false
  disable_color=false
  discard_sources=true
  eager_sudo=false
  ignore_packages=''
  keep_devels=true
  keep_source_packages=''
  makepkg='makepkg'
  makepkg_options=('--syncdeps')
  noconfirm=false
  opmode=''
  resolve_dependencies=false
  search_mode='search'
  silent=false
  sort_mode='name'
  sync_mode='install'
  temp_directory='/tmp/aurget'
  disable_maintenance_warning=false
  user_config="${XDG_CONFIG_HOME:-$HOME/.config}/aurgetrc"

  EDITOR="${EDITOR:-$VISUAL}"
  EDITOR="${EDITOR:-vi}"

  colorR="\e[1;31m"
  colorG="\e[1;32m"
  colorY="\e[1;33m"
  colorB="\e[1;34m"
  colorM="\e[1;35m"
  colorC="\e[1;36m"
  colorW="\e[1;m"
  nocolor="\e[0m"
}

source_config() {
  if [[ -r "$user_config" ]]; then
    debug "sourcing user configuration from $colorM$user_config$nocolor"
    # shellcheck source=/dev/null
    source "$user_config"
  fi
}

setup_colors() {
  if $disable_color || [[ ! -t 1 ]]; then
    colorR=''
    colorG=''
    colorY=''
    colorB=''
    colorM=''
    colorC=''
    colorW=''
    nocolor=''

    makepkg_options+=('--nocolor')
  fi
}
# }}}

# Search {{{
perform_search() {
  set -- "${arguments[@]}"

  debug "searching for $colorG$*$nocolor (mode: $colorG$search_mode$nocolor)"

  case "$search_mode" in
    search) rpc_search "$*" | print_search ;;
    info) rpc_info "$@" | print_info ;;
    quiet) rpc_search "$*" | cut -d '|' -f 2 ;;
    print) for name; do pkgbuild "$name"; done ;;
  esac
}

print_search() {
  local name version description outofdate ood

  while IFS='|' read -r description name _ outofdate _ _ version; do
    ood=''

    ((outofdate)) && ood="${colorR}[out of date]${nocolor}"

    printf "%baur/%b%s %b%s%b %b\n" "${colorM}" "${colorW}" "${name}" "${colorG}" "${version}" "${nocolor}" "${ood}"
    printf "    %s\n" "${description}"
  done
}

print_info() {
  local name version description url votes outofdate ood

  while IFS='|' read -r description name votes outofdate pkgbase url version; do
    ood='No'

    ((outofdate)) && ood="${colorR}Yes$nocolor"

    printf "%bRepository  : %baur%b\n" "${colorW}" "${colorM}" "${nocolor}"
    printf "%bName        : %s%b\n" "${colorW}" "${name}" "${nocolor}"
    [[ "$name" != "$pkgbase" ]] &&
      printf "%bBase        : %b%s%b\n" "${colorW}" "${colorB}" "${pkgbase}" "${nocolor}"
    printf "%bVersion     : %b%s%b\n" "${colorW}" "${colorG}" "${version}" "${nocolor}"
    printf "%bURL         : %b%s%b\n" "${colorW}" "${colorC}" "${url}" "${nocolor}"
    printf "%bOut of date : %b%b%b\n" "${colorW}" "${nocolor}" "${ood}" "${nocolor}"
    printf "%bVotes       : %b$votes\n" "${colorW}" "${nocolor}"
    printf "%bDescription : %b%s\n\n" "${colorW}" "${nocolor}" "${description}"
  done
}
# }}}

# Add available upgrades {{{
add_available_upgrades() {
  local update_packages
  info 'Starting AUR upgrade...'

  mapfile -t update_packages < <(available_upgrades)
  arguments=("${update_packages[@]}" "${arguments[@]}")

  (("${#arguments[@]}")) || nothing_to_do
}

available_upgrades() {
  local names versions name pkgbase version vers versN check

  declare -a names
  declare -A versions

  while read -r name version; do
    names+=("$name")
    versions[$name]=$version
  done < <(pacman -Qm)

  debug "found $colorG${#versions[@]}$nocolor foreign packages to check"

  while IFS='|' read -r _ name _ _ pkgbase _ versN; do
    if is_devel "$name"; then
      $devels && output_upgrade "$name" 'development package'
      continue
    fi

    vers="${versions[$name]}"

    read -r check < <(vercmp "$vers" "$versN")

    debug "checking $colorG$name$nocolor ($vers => $versN)"

    ((check > 0)) && warn "$name: local ($vers) is newer than aur ($versN)"
    ((check < 0)) && output_upgrade "$name" "$vers => $versN"
  done < <(rpc_info "${names[@]}")
}

output_upgrade() {
  local name="$1" reason="$2"

  if is_ignored "$name"; then
    warn "$name: ignoring package upgrade ($reason)"
  else
    debug "will upgrade $colorG$name$nocolor ($reason)"
    printf "%s\n" "$name"
  fi
}
# }}}

# Resolve dependencies {{{
resolve_dependencies() {
  info 'Resolving dependencies...'
  create_temp_directory
  resolve "${arguments[@]}"
}

resolve() {
  local name dep

  debug "resolving dependencies for $colorG$*$nocolor..."

  for name; do
    if source_pkgbuild "$name"; then
      # shellcheck disable=SC2076
      if [[ " ${arguments[*]} " =~ " $name " ]]; then
        debug "skipping (already in argument list)"
      else
        dependencies=("$name" "${dependencies[@]}")
        debug "added dependency $colorG$name$nocolor"
        debug "current set: $colorG${dependencies[*]}$nocolor"
      fi

      # See https://github.com/koalaman/shellcheck/wiki/SC2154#exceptions
      # shellcheck disable=SC2154
      mapfile -t depends < <(pacman -T -- "${depends[@]}" "${makedepends[@]}")
      depends=("${depends[@]%>*}")
      depends=("${depends[@]%=*}")
      depends=("${depends[@]%<*}")

      for dep in "${depends[@]}"; do
        resolve "$dep"
      done
    fi
  done
}

source_pkgbuild() {
  local name="$1" pkgbuild="$temp_directory/${1}_PKGBUILD"

  if [[ ! -f "$pkgbuild" ]]; then
    if pkgbuild "$name" >"$pkgbuild"; then
      debug "PKGBUILD found for $colorG$name$nocolor"

      if prompt_to_edit "$name" "$pkgbuild"; then
        debug "executing ${colorY}source $pkgbuild$nocolor"
        # shellcheck source=/dev/null
        source "$pkgbuild"
        return 0
      fi
    else
      debug "PKGBUILD ${colorR}not found$nocolor for $colorG$name$nocolor"
    fi
  fi

  touch "$pkgbuild"
  return 1
}
# }}}

# Setup targets {{{
setup_targets() {
  local name pkgbase version deps pkgbases versions pkgbuild

  declare -A deps
  declare -A pkgbases
  declare -A versions

  set -- "${dependencies[@]}" "${arguments[@]}"

  (("$#")) || die 'no targets specified (use -h for help)'

  for name in "${dependencies[@]}"; do deps[$name]=1; done
  for name in "${arguments[@]}"; do deps[$name]=0; done

  debug "setting up $colorG$#$nocolor targets for processing"

  info 'Searching AUR...'

  while IFS='|' read -r _ name _ _ pkgbase _ version; do
    debug "found $colorG$name$nocolor in the AUR at version $colorG$version$nocolor"
    pkgbases[$name]=$pkgbase
    versions[$name]=$version
  done < <(rpc_info "$@")

  for name; do
    pkgbase="${pkgbases[$name]}"
    version="${versions[$name]}"

    if [[ -z "$version" ]]; then
      pkgbuild="$temp_directory/${name}_PKGBUILD"

      if [[ -f "$pkgbuild" ]]; then
        debug "target $colorG$name$nocolor may have moved to repos"
        debug "legacy PKGBUILD: $colorG$pkgbuild$nocolor"

        # let makepkg deal with it
        ((${deps[$name]})) && continue
      fi

      die "target not found: $name"
    fi

    if is_ignored "$name"; then
      if ! prompt "$name is in ignore_packages. Install anyway"; then
        warn "skipping target: $name"
        continue
      fi
    fi

    if [[ -z "${target_versions[$name]}" ]]; then
      if [[ -z "${targets[$pkgbase]}" ]]; then
        targets[$pkgbase]=''
        target_pkgbases+=("$pkgbase")
      else
        targets[$pkgbase]+=','
      fi

      targets[$pkgbase]+="$name"
      target_names+=("$name")
      target_versions[$name]=$version
    fi
    target_deps[$pkgbase]=${deps[$name]}
  done

  (("${#target_names[@]}")) || nothing_to_do

  prompt_to_install "${target_names[@]}"
}
# }}}

# Process targets {{{
process_targets() {
  local pkgbase ret=0

  set -- "${target_pkgbases[@]}"

  installing && makepkg_options+=('--install')

  debug "processing $colorG$#$nocolor targets"

  enter_build_directory

  for pkgbase; do
    info 'Retrieving taurball from AUR...'

    if downloading; then
      debug "downloading $colorG$pkgbase$nocolor to filesystem"

      if ! taurball "$pkgbase" >"${pkgbase}.tar.gz"; then
        ret=1
        warn "$pkgbase: failed to retrieve aur sources"
        continue
      fi
    else
      debug "extracting $colorG$pkgbase$nocolor directly"

      if ! taurball "$pkgbase" | tar xfz -; then
        if ((${target_deps[$pkgbase]})); then
          die "dependency package $pkgbase failed to download, aborting"
        else
          ret=1
          warn "package $pkgbase failed to download, skipping"
          continue
        fi
      fi

      build_target "$pkgbase" && discard_sources "$pkgbase"
    fi
  done

  debug "processing complete, returning $colorG$ret$nocolor"

  return $ret
}

build_target() {
  local pkgbase="$1" pkgbuild ret=0

  info 'Building package...'

  debug "building $colorG$pkgbase${nocolor}..."

  cd "$pkgbase" || die 'unable to change to source directory'

  invoke_customizepkg "$pkgbase"

  if prompt_to_edit "$pkgbase" './PKGBUILD' 'building'; then
    if ((${target_deps[$pkgbase]})); then
      buildpkg --asdeps || die "dependency package $pkgbase failed to build, aborting"
    else
      buildpkg || {
        ret=1
        warn "package $pkgbase failed to build, skipping"
      }
    fi
  fi

  cd .. || die 'unable to change out of source directory'

  debug "build finished, returning $colorG$ret$nocolor"

  return $ret
}

discard_sources() {
  local pkgbase="$1"

  if ! $discard_sources; then
    debug "keeping sources for $colorG$pkgbase$nocolor (discard false)"
    return
  fi

  if keep_sources "$pkgbase"; then
    debug "keeping sources for $colorG$pkgbase$nocolor (keep sources)"
    return
  fi

  if $keep_devels && is_devel "$pkgbase"; then
    debug "keeping sources for $colorG$pkgbase$nocolor (development package)"
    return
  fi

  info 'Discarding sources...'

  debug "executing ${colorY}rm -rf ./$pkgbase$nocolor"

  rm -rf "./$pkgbase"
}

invoke_customizepkg() {
  local pkgbase=$1 dir

  type -p customizepkg &>/dev/null || return

  : "${CUSTOMIZEPKG_CONFIG:=/etc/customizepkg.d}"

  for dir in "$CUSTOMIZEPKG_CONFIG" "$HOME/.customizepkg"; do
    if [[ -f "$dir/$pkgbase" ]]; then
      info 'Calling customizepkg...'
      debug "executing ${colorY}customizepkg --modify$nocolor"
      customizepkg --modify || warn "customizepkg returned non-zero ($?)"
    fi
  done
}
# }}}

declare -a arguments
declare -a dependencies
declare -a target_names
declare -a target_pkgbases
declare -A targets         # pkgbase->name(s)
declare -A target_versions # name->version
declare -A target_deps     # pkgbase->is-dep?

initialize "$@"

if [[ ! "$disable_maintenance_warning" == "true" ]]; then
  warn "aurget is no longer being maintained, if you would like to volunteer please communicate your interest on this GitHub Issue: https://github.com/pbrisbin/aurget/issues/66. You can disable this warning by setting disable_maintenance_warning=true in your aurgetrc."
  sleep 1
fi

if searching; then
  perform_search
else
  eager_sudo && sudo_upfront

  upgrading && add_available_upgrades
  resolving && resolve_dependencies

  setup_targets
  process_targets
fi