scripts-setup

#!/bin/bash
#
# Setup or update an account with the scripts.
#
# Requires: git, sed
#

REPO="https://github.com/dang/scripts.git"
SCRIPTDIR="${HOME}/.scripts"

# Set usage output
USAGE="[-h |--help] [-f | --fixup] [-b <filename> | --braindead <filename> ] [-r <repo> | --repository <repo>  [<directory>]"
LONGUSAGE="\t-h, --help\n\t\tPrint this help message
\t-f, --fixup\n\t\tFix up homedir for new links/copies
\t-b <filename>, --braindead <filename>\n\t\tGenerate a setup script for braindead systems
\t-r <repo>, --repository <repo>\n\t\tUse source repo <repo>. Default: ${REPO}
\t<directory>\n\t\tScripts directory. Defaults to ${SCRIPTDIR}"

# Standard functions
is_interactive() {
	case $- in
		*i*)
			# Don't die in interactive shells
			return 0
			;;
		*)
			return 1
			;;
	esac
}
can_die() {
	if (( BASH_SUBSHELL > 0 )); then
		return 0
	fi
	if ! is_interactive; then
		return 0
	fi
	return 1
}
die() {
	echo "Failed: $@"
	if [ ! -z "$(declare -F | grep "DFGcleanup")" ]; then
		DFGcleanup "$@"
	fi
	if can_die; then
		exit 1
	fi
}
usage() {
	local myusage;
	if [ -n "${USAGE}" ]; then
		myusage=${USAGE}
	else
		myusage="No usage given"
	fi
	if [ -n "$1" ]; then
		echo "$@"
	fi
	echo ""
	echo "Usage:"
	echo "`basename $0` ${myusage}"
	if [ -n "${LONGUSAGE}" ]; then
		echo -e "${LONGUSAGE}"
	fi
	exit 1
}

# Script name
ME=$(basename $0)

# Parse arguments
ARGS=`getopt -o hb:fr: --long help,braindead:,fixup,repository: -n "${ME}" -- "$@"`

if [ $? != 0 ] ; then
	usage
fi
eval set -- "$ARGS"

while true ; do
	case "$1" in
		-h|--help) usage; shift ;;
		-f|--fixup) FIXUP="yes"; shift ;;
		-b|--braindead) BRAINDEAD="$2"; shift 2 ;;
		-r|--repository) REPO="$2"; shift 2 ;;
		--) shift ; break ;;
		* ) usage "Invalid argument $1";;
	esac
done

# Remaining arguments are in $1, $2, etc. as normal
if [ -n "${1}" ]; then
	if [ "$1" == "." ]; then
		SCRIPTDIR=${PWD}
	else
		SCRIPTDIR=$1
	fi
fi

# Array formats are: array["<targetpath>"] = "<file> [<file>...]"
#  Each entry is found in $SCRIPTDIR/cfg/<targetpath>/<file> and is installed into ${HOME}/<targetpath>/<file>

# These are items that should be symlinked to the scripts dir, so they're always up-to-date.
declare -A LNSET=(
	["."]=".ackrc .atoolrc .bashrc .cvsrc .face .gdbinit .gitignore .gvimrc .inputrc .lesskey .pentadactylrc .profile .rpmmacros .tigrc .tmux.conf .toprc .vim .vim:.config/nvim .vimrc .vrapperrc .xinitrc"
	[".cgdb"]="cgdbrc"
	[".config"]="awesome luakit hypr waybar"
	[".config/xfce4"]="terminal"
)

# These are copied, so that they can be locally modified
declare -A CPSET=(
	["."]=".gitconfig"
	[".ssh"]="config"
	[".bashrc.d/env"]="00defaults prompt  python-virtualenv  user-path"
	[".bashrc.d/actions"]="aliases"
)

# These have changed location and need to be moved
declare -A MVSET=(
	[".bashrc.d/00defaults"]=".bashrc.d/env/00defaults"
	[".bashrc.d/prompt"]=".bashrc.d/env/prompt"
	[".bashrc.d/python-virtualenv"]=".bashrc.d/env/python-virtualenv"
	[".bashrc.d/user-path"]=".bashrc.d/env/user-path"
	[".bashrc.d/aliases"]=".bashrc.d/actions/aliases"
)

WANTPROGS="atool tmux clipit nvim"

umask 0077

function cmd_exists {
	which $1 > /dev/null 2>&1
}

# getsrcdst ${entry} src dst
#
# Get a source/destination pair from a variable of the from "foo[:bar]"
# Result will be in local variables src and dst
#
function getsrcdst {
	local __entry=$1
	local  __resultsrc=$2
	local  __resultdst=$3

	IFS=':' read -ra colon <<< "${__entry}"
	local __src=${colon[0]}
	local __dst=${__src}
	if [ -n "${colon[1]}" ]; then
		__dst=${colon[1]}
	fi

	if [[ "$__resultsrc" ]]; then
		eval $__resultsrc="'${__src}'"
		eval $__resultdst="'${__dst}'"
	fi
}

# checkexists ASSOC_ARRAY || die "failed"
#
# Check if the entries in the array exist
#
# Note: do *not* dereference the array in the call
function checkexists {
	local _str_arr="$(declare -p $1)"
	eval "local -A array=${_str_arr#*=}"
	local src dst
	for k in "${!array[@]}"; do
		for f in ${array[$k]}; do
			getsrcdst "${f}" src dst
			if [ -a "${HOME}/${k}/${dst}" ]; then
				die "${HOME}/${k}/${dst} exists; not continuing" || return 1
			fi
		done
	done
}

# braindead ASSOC_ARRAY $outfile [$copy]
#
# Generate a script $outfile that will install scripts on a braindead system
# that doesn't handle associative arrays properly.  If $copy is given and true,
# copy files.  Otherwise, symlink them
#
# Note: do *not* dereference the array in the call
function braindead {
	local _str_arr="$(declare -p $1)"
	eval "local -A array=${_str_arr#*=}"
	local outfile=$2
	local copy=$3
	if [ -z "${outfile}" ]; then
		die "No outfile" || return 1
	fi
	for k in "${!array[@]}"; do
		local base="${k}/"
		if [ "$k" == "." ]; then
			# no extra ./
			base=""
		fi
		for f in ${array[$k]}; do
			local src dst
			getsrcdst "${f}" src dst
			local basedir=$(dirname ${base}${dst}})
			echo mkdir -p "${HOME}/${basedir}" >> "${outfile}"
			if [ -z "${copy}" ]; then
				if [ -n "${FIXUP}" ]; then
					echo rm "${HOME}/${base}${dst}}" >> "${outfile}"
				fi
				echo ln -s "${HOME}/.scripts/cfg/${base}${src}" "${HOME}/${base}${dst}}" \|\| die "failed to link ${base}${src}" >> "${outfile}"
			else
				if [ -n "${FIXUP}" ]; then
					# Skip existing files
					echo if [ ! -e "${HOME}/${base}${dst}}" ]\; then >> "${outfile}"
					echo cp -a "${HOME}/.scripts/cfg/${base}${src}" "${HOME}/${base}${dst}}" \|\| die "failed to copy ${base}${src}" >> "${outfile}"
					echo fi >> "${outfile}"
				fi
			fi
		done
	done
}


# install ASSOC_ARRAY [$copy]
#
# Install the entries in the array.  If copy is given and not empty, copy them.
# Otherwise, symlink them
#
# Note: do *not* dereference the array in the call
function install {
	local _str_arr="$(declare -p $1)"
	eval "local -A array=${_str_arr#*=}"
	local copy=$2
	for k in "${!array[@]}"; do
		local base="${k}/"
		if [ "$k" == "." ]; then
			# no extra ./
			base=""
		fi
		for f in ${array[$k]}; do
			local src dst
			getsrcdst "${f}" src dst
			local basedir=$(dirname ${base}${src})
			mkdir -p "${HOME}/${basedir}"
			if [ -z "${copy}" ]; then
				if [ -n "${FIXUP}" ]; then
					rm "${HOME}/${base}${dst}"
				fi
				# Makes sure any target directories exist
				local tgtdir=$(dirname ${dst})
				mkdir -p "${HOME}/${base}/${tgtdir}"
				ln -s "${HOME}/.scripts/cfg/${base}${src}" "${HOME}/${base}${dst}" || die "failed to link ${base}${src}" || return 1
			else
				if [ -n "${FIXUP}" ]; then
					# Skip existing files
					if [ -e "${HOME}/${base}${dst}" ]; then
						continue
					fi
				fi
				cp -a "${HOME}/.scripts/cfg/${base}${src}" "${HOME}/${base}${dst}" || die "failed to copy ${base}${src}" || return 1
			fi
		done
	done
}

cmd_exists sed || die "You don't have sed installed, sorry"

if [ -n "${BRAINDEAD}" ]; then
	rm "${BRAINDEAD}"
	echo "#!/bin/bash" > "${BRAINDEAD}"
	echo 'die() { echo "Failed: $@"; exit 1; }' >> "${BRAINDEAD}"
	braindead LNSET "${BRAINDEAD}"
	braindead CPSET "${BRAINDEAD}"
	echo "Wrote ${BRAINDEAD}"
	exit
fi

if [ -z "${FIXUP}" ]; then
	# Check for conflicts
	checkexists LNSET || die "Not overriting symlink files"
	checkexists CPSET || die "Not overriting copy files"

	if [ ! -d "${SCRIPTDIR}/.git" ]; then
		SAVEDIR=${PWD}
		cmd_exists git || die "You don't have git installed, sorry"
		cd $(dirname "${SCRIPTDIR}")
		git clone ${REPO} $(basename ${SCRIPTDIR})
		cd $(basename "${SCRIPTDIR}")
		git submodule update --init --recursive
		cd "${SAVEDIR}"
	fi
fi

if [ ! -d "${SCRIPTDIR}/.git" ]; then
	echo "Failed to clone scripts repo from ${REPO}"
	exit 2
fi

cd ${HOME}
# Set up .scripts symlink
ln -s ${SCRIPTDIR} .scripts
if [ -h "${SCRIPTDIR}/.scripts" ]; then
	# installed into .scripts; remove extra symlink
	rm "${SCRIPTDIR}/.scripts"
fi

# Special setup: fix moved files
if [ -n "${FIXUP}" ]; then
	for k in "${!MVSET[@]}"; do
		for f in ${MVSET[$k]}; do
			if [ -e "${HOME}/${k}" ]; then
				basedir=$(dirname $f{})
				mkdir -p "${HOME}/${basedir}"
				mv "${HOME}/${k}" "${HOME}/${f}"
			fi
		done
	done
fi

# Install files
install LNSET || die "Failed to install symlink files"
install CPSET "copy" || die "Failed to install copy files"

# Set up less
lesskey

# Initialize the flavor
export SCRIPTS_SETUP="yes"
. ${SCRIPTDIR}/bashrc.d/env/flavor
if [ -f "${SCRIPTDIR}/bashrc.d/flavor/${FLAVOR}/setup" ]; then
	. ${SCRIPTDIR}/bashrc.d/flavor/${FLAVOR}/setup
fi

# Look to see if my desired programs are installed
for i in ${WANTPROGS}; do
	cmd_exists || NEEDPROGS="$i ${NEEDPROGS}"
done

echo "Done."
echo "You need to edit ${HOME}/.bashrc.d/* for your your local settings"
if [ -n "${NEEDPROGS}" ]; then
	echo "Please install ${NEEDPROGS}"
fi