#!/bin/bash
#
###############################################################################
#
# portage-slotcheck: Check whether ebuilds in old slots can be updated...
#		    These are usually missed by "emerge world"
#
# Stuart Shelton, 20040421.
#
# Revision History
# ----------------
# 20040421 SRCS Initial Version
#
###############################################################################
#
# set -o xtrace

NAME="$( basename ${0} )"
EMERGE="/usr/bin/emerge"
EMERGEOPTS="--nospinner -pO"
PORTAGEQ="/usr/bin/portageq"

# EQUERY="/usr/bin/equery"
# EQOPTS="-q -C list -i \*"
# EQLIST="-q -C list -i"
EQUERY="$( type -p qpkg )"
EQOPTS="-I -d -v -nc"

PORTDIR="$( $PORTAGEQ portdir 2>/dev/null )"
[ -d $PORTDIR ] || [ -r /etc/make.conf ] && eval "$( grep "PORTDIR=" /etc/make.conf )"
[ -d $PORTDIR ] || PORTDIR="/usr/portage"

PARAMS="$#"

VERBOSE=""

[ -d /dev/shm -a -w /dev/shm ] && TMP="/dev/shm"

function die() {
	[ -e $FIFO ] && rm -f $FIFO
	[ -e $FTMP ] && rm -f $FTMP
	exit ${1:-1}
}

function warn() {
	echo "$@" >&2
}

function error() {
	warn "$@"
	die 1
}

function verbose() {
	if [ -n "$VERBOSE" ]; then
		echo -e "$@" >&2
	fi
}

function showHelp() {
	echo "Usage: $NAME [architecture] [package]"
	echo "       Where package is in the form of \"category/ebuild\""
	echo "       architecure is a value for ACCEPT_KEYWORD"
	die 1
}

function checkKeyword() {
	if [ -r $PORTDIR/profiles/arch.list ]; then
		BASEARCH="$( echo $1 | sed 's/~//' )"
		[ -z "$BASEARCH" ] && error "Internal Error: No keyword supplied" 1
		if [ -n "$( grep $BASEARCH $PORTDIR/profiles/arch.list )" ]; then
			ACCEPT_KEYWORDS=$1
		else
			error "\"$1\" is not a supported architecture"
		fi
	else
		error "Cannot read arch.list - Accepting supplied value"
		ACCEPT_KEYWORDS=$1
	fi
}

trap die 1 2 3

[ -x "$( type -p $EQUERY )" ] || error "Please install \"$( basename $EQUERY )\""
[ -x "$( type -p $PORTAGEQ )" ] || error "Please install \"sys-apps/portage\""
[ -x "$( type -p $EMERGE )" ] || error "Please install \"sys-apps/portage\""

for ARG in $@; do
	if [ "$ARG" = "--help" -o "$ARG" = "-h" ]; then
		(( PARAMS-- ))
		showHelp
	fi
	if [ "$ARG" = "--verbose" -o "$ARG" = "-v" ]; then
		(( PARAMS-- ))
		VERBOSE=1
	fi
done
if (( PARAMS > 2 )); then
	showHelp
fi

FIFO=${TMP:-/tmp}/$NAME.list
[ -e $FIFO ] && rm -f $FIFO
touch $FIFO
[ -f $FIFO ] || error "Cannot create or read from file \"$FIFO\""
FTMP=${TMP:-/tmp}/$NAME.tmp
[ -e $FTMP ] && rm -f $FTMP
touch $FTMP
[ -f $FTMP ] || error "Cannot create or read from file \"$FTMP\""

(( OPT = 1 ))
(( DONE = 0 ))
until (( 1 == DONE )) || (( 3 == OPT )); do
	VALUE="$( eval echo \$$OPT )"
	if [ -z "$( echo $VALUE | grep "^\-" )" ]; then
		ARCH=$VALUE
		(( DONE = 1 ))
	else
		(( OPT++ ))
	fi
done
if (( 0 == DONE )); then
	showHelp
else
	(( DONE = 0 ))
	(( OPT++ ))
fi
until (( 1 == DONE )) || (( 3 == OPT )); do
	VALUE="$( eval echo \$$OPT )"
	if [ -z "$( echo $VALUE | grep "^\-" )" ]; then
		PKG=$VALUE
		(( DONE = 1 ))
	else
		(( OPT++ ))
	fi
done

if (( 2 == PARAMS )); then
	if [ -n "$( grep "$( echo $ARCH | sed 's/^~//' )" $PORTDIR/profiles/arch.list )" ]; then
		checkKeyword $ARCH
	elif [ -n "$( grep "$( echo $PKG | sed 's/^~//' )" $PORTDIR/profiles/arch.list )" ]; then
		ARCH=$2
		PKG=$1
		checkKeyword $ARCH
	else
		# Oh, dear...
		warn "$ARCH appears to be an unknown architecture: Running as \"$NAME x86 $PKG\""
		ARCH="x86"
		checkKeyword $ARCH
	fi
elif (( 1 == PARAMS )); then
	PKG=$ARCH
	if [ -n "$( grep "$( echo $ARCH | sed 's/^~//' )" $PORTDIR/profiles/arch.list )" ]; then
		checkKeyword $ARCH
	else
		warn "Running as \"$NAME x86 $PKG\""
		ARCH="x86"
		PARAMS=2
		checkKeyword $ARCH
	fi
else
	warn "Running as \"$NAME x86\""
	ARCH="x86"
	PARAMS=1
	checkKeyword $ARCH
fi

[ -z "$( grep $ARCH $PORTDIR/profiles/arch.list )" ] && if [ -n "$( grep $PKG $PORTDIR/profiles/arch.list )" ]; then
	ARCH=$2
	PKG=$1
fi

checkKeyword $ARCH

# We'll honor the ACCEPT_KEYWORDS variable, make.conf, and the command-line
if [ -z "$ACCEPT_KEYWORDS" ]; then
	[ -r /etc/make.conf ] && source /etc/make.conf
fi

if [ -z "$ACCEPT_KEYWORDS" ]; then
	warn "Architecture not specified - assuming \"x86\"..."
	ACCEPT_KEYWORDS="x86"
fi

export ACCEPT_KEYWORDS

if (( PARAMS > 1 )); then
	warn -n "Building $ACCEPT_KEYWORDS package list for \"$PKG\"... "
#	( exec $EQUERY ${EQLIST:-$EQOPTS} $PKG | sed 's#^.*/##' | grep -v "^$" | cut -d" " -f1 >$FIFO ; )
	$EQUERY ${EQLIST:-$EQOPTS} $PKG > $FIFO
#	grep "^$PKG-[0-9]" $FIFO | sort >  $FIFO
	# Grr... qpkg/equery doesn't return false if no packages exist
	if (( 0 == $( cat $FIFO | wc -l ) )); then
		error "Cannot find ebuild \"$PKG\""
	else
		verbose -e "\nFound$( for ENTRY in $( cat $FIFO ); do echo -n " $ENTRY"; done )\n"
	fi
else
	warn -n "Building $ACCEPT_KEYWORDS package list... "
#	for PKG in $( exec $EQUERY $EQOPTS | sed 's|^.*/||' | cut -d" " -f 1 | sed 's/-[0-9].*$//' | sort | uniq -d ); do
#		cat /dev/null > $FTMP
#		( exec $EQUERY ${EQLIST:-$EQOPTS} $PKG | sed 's#^.*/##' | grep -v "^$" | cut -d" " -f1 >>$FTMP ; )
#		# Weed-out extraneous matches...
#		grep "^$PKG-[0-9]" $FTMP | sort >> $FIFO
#	done
#	rm -f $FTMP
	$EQUERY $EQOPTS > $FIFO
	warn -e "Done"
fi

LIST=""

verbose -e "\n"

cat $FIFO | sed 's|\-[0-9].*$||' | sort | uniq > $FIFO

while read LINE; do
	verbose "Checking $LINE..."
	DIR="$( echo $LINE | cut -d "/" -f 1 )"
	PACKAGE="$( echo $LINE | cut -d " " -f 1 | cut -d "/" -f 2 )"

	LOCALLIST=""

	for FILE in $PORTDIR/$DIR/$PACKAGE/*.ebuild; do
		EBUILD="$( basename $FILE )"
		verbose -n " ${EBUILD}:\t"
		EBUILD="$( echo $EBUILD | sed 's/.ebuild.*$//' )"
		env - ACCEPT_KEYWORDS=$ACCEPT_KEYWORDS $EMERGE $EMERGEOPTS =$DIR/$EBUILD 2>&1 \
			| grep "^\[ebuild ....U \]" | grep "$PACKAGE" \
			&& LOCALLIST="$LOCALLIST =$DIR/$EBUILD" \
			|| verbose -n "\n"
	done

	LIST="$LIST $( \
	for EBUILD in $LOCALLIST; do
		echo "$EBUILD" | sed 's/_pre/.pre/'
	done | sort -bdfi | tail -n 1 | sed 's/\.pre/_pre/' \
	)"

	unset LOCALLIST
done < $FIFO

echo
LIST="$( echo $LIST | tr -s [:space:] " " )"
[ -n "$LIST" -a "$LIST" != " " ] && echo "emerge -pv $LIST" || echo "No SLOT upgrades available"

rm -f $FIFO
unset FIFO