Dotfiles
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
 
 
 
 
 
 

698 lines
19 KiB

#!/bin/zsh
# (c) 2014-2018 Taeyeon Mori
# vim: ft=sh:ts=2:sw=2:et
AUR_DEFAULT_HOST="https://aur.archlinux.org/"
# Load libraries and configuraion
source "$DOTFILES/lib/libzsh-utils.zsh"
source "$DOTFILES/etc/aur.conf"
function throw {
# throw <exit code> <err msg>
err "$2"
clean_exit $1
}
function clean_exit {
# clean_exit <exit code>
exit ${1-0}
}
# Load ZSH Extensions
autoload is-at-least
function is-exactly {
[[ "$1" == "$2" ]]
return $?
}
function is-at-most {
! is-at-least "$1" "$2" || is-exactly "$1" "$2"
return $?
}
function is-less {
! is-at-least "$1" "$2"
return $?
}
function is-more {
! is-at-most "$1" "$2"
return $?
}
function check_bool {
[[ -n "$1" ]] && $1
return $?
}
# ------------------------------------------------------------------------------
# Parse commandline: anything prefixed with - is a makepkg option, others are package names
PROG="$0"
packages=()
makepkg_args=()
aur_get=aur_get_aur4
DL_ONLY=false
ASK=false
AUR_HOST="$AUR_DEFAULT_HOST"
ADD_UPDATES=false
ADD_SCMPKGS=false
ADD_PYTHON=false
RECURSE_DEPS=false
NEED_AURACLE=false
NEED_ROOT=false
LIST_ONLY=false
IGNORE_ERRORS=false
EXCLUDE=
ASDEPS=false
NEEDED=true
NOCONFIRM=true
USECUSTOM=true
LOCAL_ONLY=false
NOCLEAN=false
add_makepkg_arg() {
makepkg_args=("${makepkg_args[@]}" "$1")
}
_proxy_args=0
_next_arg=
process_arg() {
local cx="$1"
if [ $_proxy_args -gt 0 ]; then
add_makepkg_arg "$cx"
_proxy_args=$[$_proxy_args - 1]
continue
fi
if [ -n "$_next_arg" ]; then
case "$_next_arg" in
--aur-host)
AUR_HOST="$cx";;
--exclude)
EXCLUDE=",$cx";;
--threads)
if [ "${cx:0:1}" = "-" -o "${cx:0:1}" = "+" ]; then
export MAKEPKG_MAKETHREADS=$[`nproc` + $cx]
elif [ "$cx" = 0 ]; then
export MAKEPKG_MAKETHREADS=`nproc`
else
export MAKEPKG_MAKETHREADS=$cx
fi;;
esac
_next_arg=
continue
fi
case "$cx" in
# aur.sh options
--old-aur)
warn "[AUR] Using old AUR methods (--old-aur)"
aur_get=aur_get_old;;
-X|--download-only)
warn "[AUR] Building was disabled (-X)"
DL_ONLY=true;;
-a|--ask)
ASK=true;;
--offline)
LOCAL_ONLY=true;;
--aur-host|--exclude) # need more args
_next_arg="$cx";;
--no-custom)
USECUSTOM=false;;
--noclean)
NOCLEAN=true;;
-j|--threads)
_next_arg=--threads;;
-1)
export MAKEPKG_MAKETHREADS=$[`nproc` - 1];;
-u|--update)
NEED_AURACLE=true
ADD_UPDATES=true;;
-g|--scm-packages|--scm-update)
ADD_SCMPKGS=true;;
--python-update)
ADD_PYTHON=true
NEEDED=false
add_makepkg_arg -f;;
-S|--recurse-deps)
NEED_AURACLE=true
RECURSE_DEPS=true
NEED_ROOT=true
add_makepkg_arg -i;;
-L|--list-only)
LIST_ONLY=true;;
-E|--ignore-errors)
IGNORE_ERRORS=true;;
-h|--help)
echo "Usage $PROG [options] <packages>"
echo "Taeyeon's aur.sh (c) 2014-2016 Taeyeon Mori (not related to http://aur.sh)"
echo
echo "A simple AUR client realized in zsh"
echo
echo "aur.sh options:"
echo " -h, --help Display this message"
echo " -u, --update Build all updated AUR packages [c]"
echo " -g, --scm-update, --scm-packages"
echo " Try to rebuild all *-git packages"
echo " --python-update"
echo " Rebuild all python-* packages after new python release"
echo " Equivalent to: $PROG -f \`pacman -Qm | grep 'python-.\\+'\`"
echo " Note: Doesn't honor AURSH_IGNORE_UPDATES"
echo " -S, --recurse-deps"
echo " Recursively build & install all dependencies [c]"
echo " Implies -i (Auto-install built packages)"
echo " -L, --list-only"
echo " Only list all affected packages"
echo " -X, --download-only"
echo " Only download the PKGBUILDs from AUR, don't build."
echo " --offline Don't try to download new PKGBUILDs"
echo " -E, --ignore-errors"
echo " Continue with the next package even after a failure."
echo " -j, --threads [+-]<n>"
echo " Set \$MAKEPKG_MAKETHREADS to be used in makepkg.conf"
echo " Values prefixed with + or - are added to the number of host cpus"
echo " -1 Short for '--threads -1'"
echo " -a, --ask Review changes before building packages"
echo " --exclude <pkgs>"
echo " Exclude packages (Useful with -u, -g, --python-update)"
echo " --no-custom Don't use custom packages from $CUSTOMDIR"
echo " --noclean Don't clean up temporary build directory when done."
echo
echo " --clean Clean up leaftover temporary files (of previous (failed) builds) and exit"
echo
echo "AUR backend options:"
echo " --aur-host <url>"
echo " Use a different AUR server. default: https://aur.archlinux.org/"
echo " --old-aur Use the old (non-git) AUR methods"
echo
echo "Makepkg/Pacman options:"
echo " -i Install package after building it (requires superuser)"
echo " -s Install dependencies from official repos (requires superuser)"
echo " -r Remove installed dependencies after build"
echo " --pkg <list> Only build selected packages (when working with split packages)"
echo " --asdeps Pass --asdeps to pacman for all installed packages"
echo " --reinstall Reinstall installed packages, even when version info matches."
echo " --needed Opposite of --reinstall (default)"
echo " --noconfirm Skip makepkg/pacman confirmation prompts (default)"
echo " -o, --nobuild Download and extract sources only. Implies --noclean"
echo " -f, --force Force rebuilding of built packages. Implies --reinstall"
echo " --no- Negate options: --no-asdeps --no-noconfirm"
echo
echo "NOTE: options marked [c] require auracle to be installed (\$ $PROG -is auracle-git)"
echo " However, certain auracle-only features are automatically enabled when auracle is found."
exit 0
;;
# Clean up files from failed operations
--clean)
local temp="${TMPDIR-/tmp}"
for tmp in `find "$temp" -name 'aur.sh.*'`; do
if [ -e "$tmp/aur.sh.running" ] && [ -e "/proc/${tmp%%.}" ]; then
err "Cannot remove '$tmp', aur.sh instance seems to be running"
else
msg "Removing '$tmp'.."
rm -rf "$tmp"
fi
done
color 35 echo "Cleaned leftover temporary files."
exit 0;;
# Inverted makepkg args
--asdeps)
ASDEPS=true;;
--no-asdeps)
ASDEPS=false;;
--asexplicit)
echo "NOTE: --asexplicit and --no-asexplicit are DEPRECATED."
ASDEPS=false;;
--no-asexplicit)
echo "NOTE: --asexplicit and --no-asexplicit are DEPRECATED."
ASDEPS=true;;
--needed|--no-reinstall)
NEEDED=true;;
--reinstall|--no-needed)
NEEDED=false;;
--noconfirm)
NOCONFIRM=true;;
--no-noconfirm)
NOCONFIRM=false;;
# Makepkg args
-f|--force)
NEEDED=false;
add_makepkg_arg "$cx";;
-o|--nobuild) # Remember some stuff for own use
NOCLEAN=true
add_makepkg_arg "$cx";;
-i|--install|-s|--syncdeps)
NEED_ROOT=true
add_makepkg_arg "$cx";;
--pkg|--key|--config|-p) # These take an additional value
_proxy_args=1
add_makepkg_arg "$cx";;
-*)
add_makepkg_arg "$cx";;
# Package names
*)
packages=("${packages[@]}" "$cx");;
esac
}
for cx in "$@"; do
case "$cx" in
--*)
process_arg "$cx";;
-*)
for c in `echo "${cx:1}" | grep -o .`; do
process_arg "-$c"
done;;
*)
process_arg "$cx";;
esac
done
# Inverted Makepkg args
$NEEDED && add_makepkg_arg "--needed"
$NOCONFIRM && add_makepkg_arg "--noconfirm"
# Auracle Detection
USE_AURACLE=false
if auracle --version >/dev/null; then
USE_AURACLE=true # Auto-enable auracle support if installed.
elif $NEED_AURACLE; then
throw 31 "Options requiring auracle have been selected but auracle was not found. Install auracle-git from AUR."
else
warn "Could not detect auracle on the system."
fi
if [ "$aur_get" != "aur_get_aur4" ] || [ "$AUR_HOST" != "$AUR_DEFAULT_HOST" ]; then
USE_AURACLE=false
$NEED_AURACLE &&
throw 31 "--old-aur and --aur-host are not supported with auracle features" ||
warn "--old-aur and --aur-host are no longer supported"
fi
if ! $USE_AURACLE; then
warn "Auracle will not be used. Not all features are available without it."
warn "Specifically, split packages cannot be detected without auracle."
fi
# -------------------------------------------------------------------------
# aur functions
aur_get_old() {
[ -d "$1/.git" ] && throw 32 "Local copy of $1 is a Git clone from AUR v4. Don't use --old-aur with it!"
curl "$AUR_HOST/packages/${1:0:2}/$1/$1.tar.gz" | tar xz
}
[[ -z "$AUR_GIT_OPTIONS" ]] && AUR_GIT_OPTIONS=()
[[ -z "$AUR_GIT_PULL_OPTIONS" ]] && AUR_GIT_PULL_OPTIONS=(--rebase)
[[ -z "$AUR_GIT_CLONE_OPTIONS" ]] && AUR_GIT_CLONE_OPTIONS=()
aur_get_aur4() {
if [ -d "$1/.git" ]; then (
cd "$1"
git "${AUR_GIT_OPTIONS[@]}" pull "${AUR_GIT_PULL_OPTIONS[@]}"
) else
if [ -e "$1" ]; then
warn "$1 PKGBUILD directory exists but is not a git clone."
ans=n
ask "Overwrite $1?" ans
[ "$ans" = "y" ] || [ "$ans" = "yes" ] || [ "$ans" = "Y" ] || return 32
rm -rf "$1"
fi
git "${AUR_GIT_OPTIONS[@]}" clone "${AUR_GIT_CLONE_OPTIONS[@]}" -- "$AUR_HOST/$1.git" "$1"
fi
}
# ----------------------------------------------------------------------------
# package functions
declare -a AFFECTED_PKGS
declare -a FAILED_PKGS
declare -A PKG_INFO
function pkg_failed {
# pkg_failed <pkg name> <exit code> <err msg>
FAILED_PKGS=("${FAILED_PKGS[@]}" "$1")
if $IGNORE_ERRORS; then
err "$3"
else
throw "$2" "$3"
fi
return "$2"
}
# Metadata collection
parse_pkgbuild() {
local p="$1"
local path="$2"
# Funky
PKG_INFO[$p:Depends]="$( ( source "$path"; echo "$depends[@]"; ) )"
}
collect_package() {
local p="$1" # package name
local INFO="$2"
# Skip dupes (prob. from dependencies)
if (( $AFFECTED_PKGS[(I)$p] )); then
return 0
fi
# Set Defaults
PKG_INFO[$p:AsDeps]=$ASDEPS
# Get package information
if $USECUSTOM && [ -e "$CUSTOMDIR/$p" ]; then
msg "[AUR] Found '$p' in '$CUSTOMDIR', Using that"
cd "$CUSTOMDIR"
PKG_INFO[$p:From]="$CUSTOMDIR/$p"
parse_pkgbuild "$p" "$CUSTOMDIR/$p/PKGBUILD"
else
if $USE_AURACLE; then
if [ -z "$INFO" ]; then
INFO=`auracle info "$p"`
fi
PKG_INFO[$p:Info]="$INFO"
info_grep() {
echo "$INFO" | grep "$@" | cut -d: -f2
}
PKG_INFO[$p:PackageBase]=`info_grep PackageBase | sed -e 's/^\s*//' -e 's/\s*$//'`
PKG_INFO[$p:Depends]=`info_grep -i depends`
PKG_INFO[$p:Version]=`info_grep -i version`
fi
fi
# Check for split package
if [ -n "$PKG_INFO[$p:PackageBase]" ]; then
color 35 echo "[AUR] $p: Is a split package. Selecting base package '$PKG_INFO[$p:PackageBase]' instead."
warn "[AUR] Split-Package support is currently broken."
collect_package "$PKG_INFO[$p:PackageBase]" "`echo "$PKG_INFO[$p:Info]" | grep -v PackageBase`"
return $?
fi
# Check for dependencies
if [ -n "$PKG_INFO[$p:Depends]" ]; then
# process dependencies
PKG_INFO[$p:Dependencies]=""
for dep in ${(z)PKG_INFO[$p:Depends]}; do
if echo "$dep" | grep -qE "[=<>]"; then # Parse Version constraints
dereq=""
case "$dep" in
(*\<=*) dereq=is-at-most; delim="<=";;
(*=\<*) dereq=is-at-most; delim="=<";;
(*\>=*) dereq=is-at-least; delim=">=";;
(*=\>*) dereq=is-at-least; delim="=>";;
(*\<*) dereq=is-less; delim="<";;
(*\>*) dereq=is-more; delim=">";;
(*=*) dereq=is-exactly; delim="=";;
(*) warn "[AUR] Faulty dependency: $dep";;
esac
if [ -n "$dereq" ]; then
depname=${dep%$delim*}
depver=${dep#*$delim}
PKG_INFO[$p:Dependencies]="$PKG_INFO[$p:Dependencies] $depname"
constraint=${depname// /}:VersionConstraints:$p
if [ -n "$PKG_INFO[$constraint]" ]; then
ct=1; while [ -n "$PKG_INFO[$constraint#$ct]" ]; do ct=$[$ct + 1]; done
constraint="$constraint#$ct"
fi
PKG_INFO[$constraint]="$dereq ${depver// /}"
fi
else
PKG_INFO[$p:Dependencies]="$PKG_INFO[$p:Dependencies] $dep"
fi
done
for dep in ${(z)PKG_INFO[$p:Dependencies]}; do
if (( $packages[(I)$dep] )); then # make sure queued dependencies are processed before dependants, even if a version is already installed
collect_package "$dep"
fi
if $RECURSE_DEPS && ! pacman -Qi "$dep" >/dev/null 2>&1 && auracle info "$dep" >/dev/null 2>&1; then # Check if it's an (un-installed) aur package
color 35 echo "[AUR] $p: Collecting AUR dependency '$dep'..."
collect_package "$dep"
# Mark as dependency
PKG_INFO[$dep:AsDeps]=true
fi
done
fi
# Queue package for build
if ! (( $AFFECTED_PKGS[(I)$p] )); then # Don't add split packages depending on themselves multiple times. FIXME: Properly handle cycles
AFFECTED_PKGS=("${AFFECTED_PKGS[@]}" "$p")
fi
}
# Package processing
fetch_package() {
local p="$1"
if [ -z "$PKG_INFO[$p:From]" ]; then
# First, download the PKGBUILD from AUR, to $AURDEST
cd "$AURDEST"
msg "[AUR] $p: Getting PKGBUILD"
{
test -d $p && \
test -f $p/PKGBUILD && \
grep -q "#CUSTOMPKG" $p/PKGBUILD && \
warn "[AUR] $p: Found #CUSTOMPKG; not updating PKGBUILD from AUR!" \
} || \
$aur_get "$p" || \
warn "[AUR] $p: Couldn't download PKGBUILD from aur!"
PKG_INFO[$p:From]="$AURDEST/$p"
fi
}
build_package() {
local p="$1" # package name
# Copy it to the build directory $build and change there
cp -Lr "$PKG_INFO[$p:From]" "$build/$p"
cd "$build/$p"
# Build makepkg args
local add_args=()
if check_bool $PKG_INFO[$p:AsDeps]; then
add_args+=("--asdeps")
fi
# Run makepkg
msg "[AUR] $p: Building..."
makepkg "${makepkg_args[@]}" "${add_args[@]}" || \
{ pkg_failed "$p" 1 "[AUR] $p: Makepkg failed!"; return $? }
msg "[AUR] $p: Done!"
}
# ============== Main ========================
# Actual work starts here
# Print some info
msg "[AUR] AURDIR=$AURDIR; PKGDEST=$PKGDEST"
# Check updates ------------------------
if $ADD_UPDATES || $ADD_SCMPKGS; then
ignore=($(echo $AURSH_IGNORE_UPDATES | tr , " "))
if (( ${#ignore} )); then
msg "[AUR] Ignoring updates for: ${ignore[*]}"
fi
fi
if $ADD_UPDATES; then
declare -a updates
updates=($(auracle outdated -q))
#for update in "${(f)$(auracle outdated)}"; do
# updates+=("${${(s: :)update}[2]}")
#done
msg "[AUR] Updates available for: ${updates[*]}"
if (( ${#ignore} )); then
updates=(${updates:|ignore})
fi
packages+=("${updates[@]}")
fi
packages_from_filter() {
zparseopts -D i=o_ignore a=o_add p:=o_print g:=o_global
local -a pkgs
pkgs=("${(@f)$(pacman -Qqm | grep "$1")}")
if [ -n "$o_print" ]; then
color 34 printf "${o_print[2]}" "${pkgs[*]}"
fi
if [ -n "$o_ignore" ] && (( ${#ignore} )); then
pkgs=(${pkgs:|ignore})
fi
if [ -n "$o_add" ]; then
packages+=("${pkgs[@]}")
fi
if [ -n "$o_global" ]; then
declare -ga ${o_global[2]}
eval "${o_global[2]}=(\"\${(@)pkg}\")"
fi
}
if $ADD_SCMPKGS; then
packages_from_filter -ai -p "[AUR] Adding installed scm packages: %s\n" '.\+-git'
fi
if $ADD_PYTHON; then
packages_from_filter -a -p "[AUR] Adding installed python packages: %s\n" 'python-.\+'
fi
exclude=($(echo $EXCLUDE | tr , " "))
if (( ${#exclude} )); then
msg "[AUR] Excluding Packages: ${exclude[*]}"
packages=(${packages:|exclude})
fi
if [ -z "$packages" ]; then
warn "[AUR] Nothing to do."
clean_exit
fi
msg "[AUR] Package set (${#packages}): ${packages[*]}"
# Collect package metadata ---------------
for p in "${packages[@]}"; do
collect_package "$p"
done
if (( ${#exclude} )); then
all_affected_pkgs="${AFFECTED_PKGS[*]}"
AFFECTED_PKGS=(${AFFECTED_PKGS:|exclude})
if ! [[ "$all_affected_pkgs" == "${AFFECTED_PKGS[*]}" ]]; then
warn "[AUR] Some dependencies have been excluded!"
fi
fi
msg "[AUR] Affected Packages (${#AFFECTED_PKGS}): $AFFECTED_PKGS[@]"
# Check version constraints
for constraint in ${(@kM)PKG_INFO:#*:VersionConstraints:*}; do
name=${constraint%%:*}
if (( $AFFECTED_PKGS[(I)$name] )); then
if ! ${(z)PKG_INFO[$constraint]} $PKG_INFO[$name:Version]; then
warn "[AUR] Version constraint not satisfied: ${constraint##*:} requires that $name $PKG_INFO[$constraint]"
fi
fi
done
if $LIST_ONLY; then
clean_exit
fi
if $ASK; then
ans=y
ask "[AUR] Continue?" ans
if ! [ "$ans" = y -o "$ans" = Y -o "$ans" = YES -o "$ans" = Yes -o "$ans" = yes ]; then
err "[AUR] Aborted by user"
clean_exit 0
fi
fi
# Fetch packages --------------------------
if ! $LOCAL_ONLY; then
for p in "${AFFECTED_PKGS[@]}"; do
fetch_package "$p"
done
elif $DL_ONLY; then
warn "[AUR] --offline and --download-only both given. Doing nothing. (Like --list-only)"
fi
if $DL_ONLY; then
clean_exit
fi
# Add PKGBUILDs from cache
for p in "${AFFECTED_PKGS[@]}"; do
if [ -z "$PKG_INFO[$p:From]" ]; then
if [ -d "$AURDEST/$p" ]; then
PKG_INFO[$p:From]="$AURDEST/$p"
else
pkg_failed "$p" 2 "[AUR] $p: Could not find PKGBUILD anywhere"
fi
fi
done
if (( ${#FAILED_PKGS} )); then
warn "[AUR]: Failed to fetch packages (${#FAILED_PKGS}): ${FAILED_PKGS[*]}"
AFFECTED_PKGS=(${AFFECTED_PKGS:|${FAILED_PKGS[@]}})
fi
# Build packages --------------------------
# Figure out build directory
tmpbuild="${TMPDIR-/tmp}/aur.sh.$$"
build="${BUILDDIR:-$tmpbuild}"
test -d "$build" || mkdir -p "$build" || throw 1 "Couldn't create build directory"
clean_exit() {
rm "$build/aur.sh.running" 2>/dev/null || true
[ -n "$SUDO_PROC" ] && kill $SUDO_PROC
exit ${1-0}
}
trap clean_exit TERM
trap clean_exit INT
touch "$build/aur.sh.running"
test "$build" = "$PWD" || \
msg "[AUR] Working in $build."
# Sudo
if $NEED_ROOT && $NOCONFIRM; then
# Ask now
msg "[AUR] Updating sudo timestamp"
sudo -v
# Keep up
while true; do
sleep 250
sudo -vn
done &
SUDO_PROC=$!
fi
msg "[AUR] Makepkg args: ${makepkg_args[*]}"
# Build
for p in "${AFFECTED_PKGS[@]}"; do
build_package "$p"
done
if (( ${#FAILED_PKGS} )); then
warn "[AUR] All done, but some packages encountered errors (${#FAILED_PKGS}): ${FAILED_PKGS[*]}"
clean_exit 255
fi
msg "[AUR] All Done!"
# Remove the builddir if we previously created it.
cd "$AURDEST"
if [ "$build" = "$tmpbuild" ]; then
if $NOCLEAN; then
msg "[AUR] Files in: $tmpbuild"
warn "[AUR] Clean up later with aur.sh --clean"
else
warn "[AUR] Removing temporary directory $tmpbuild"
rm -rf "$tmpbuild"
fi
fi
clean_exit