35da3eeb6e
When using Git for Windows (a.k.a. msysGit) from Cygwin, git stumbles over paths in Unix notation. Git for Windows only accepts Windows paths (mixed notation is OK, for example `C:/GITREPO/`). This patch converts paths passed to and from git to the appropriate notation using cygpath if yadm is run under Cygwin and Git for Windows is detected.
642 lines
16 KiB
Bash
Executable file
642 lines
16 KiB
Bash
Executable file
#!/bin/sh
|
|
# yadm - Yet Another Dotfiles Manager
|
|
# Copyright (C) 2015 Tim Byrne
|
|
|
|
# This program is free software: you can redistribute it and/or modify
|
|
# it under the terms of the GNU General Public License as published by
|
|
# the Free Software Foundation, version 3 of the License.
|
|
|
|
# This program is distributed in the hope that it will be useful,
|
|
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
# GNU General Public License for more details.
|
|
|
|
# You should have received a copy of the GNU General Public License
|
|
# along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
#; execute script with bash (shebang line is /bin/sh for portability)
|
|
if [ -z "$BASH_VERSION" ]; then
|
|
[ "$YADM_TEST" != 1 ] && exec bash "$0" "$@"
|
|
fi
|
|
|
|
VERSION=1.05
|
|
|
|
YADM_WORK="$HOME"
|
|
YADM_DIR="$HOME/.yadm"
|
|
|
|
YADM_REPO="repo.git"
|
|
YADM_CONFIG="config"
|
|
YADM_ENCRYPT="encrypt"
|
|
YADM_ARCHIVE="files.gpg"
|
|
|
|
GPG_PROGRAM="gpg"
|
|
LS_PROGRAM="/bin/ls"
|
|
|
|
#; flag when something may have changes (which prompts auto actions to be performed)
|
|
CHANGES_POSSIBLE=0
|
|
|
|
function main() {
|
|
|
|
#; create the YADM_DIR if it doesn't exist yet
|
|
[ -d "$YADM_DIR" ] || mkdir -p "$YADM_DIR"
|
|
|
|
#; parse command line arguments
|
|
internal_commands="^(alt|clean|clone|config|decrypt|encrypt|help|init|list|perms|version)$"
|
|
if [ -z "$*" ] ; then
|
|
#; no argumnts will result in help()
|
|
help
|
|
elif [[ "$1" =~ $internal_commands ]] ; then
|
|
#; for internal commands, process all of the arguments
|
|
YADM_COMMAND="$1"
|
|
YADM_ARGS=()
|
|
shift
|
|
|
|
while [[ $# -gt 0 ]] ; do
|
|
key="$1"
|
|
case $key in
|
|
-a) #; used by list()
|
|
LIST_ALL="YES"
|
|
;;
|
|
-d) #; used by all commands
|
|
DEBUG="YES"
|
|
;;
|
|
-f) #; used by init() and clone()
|
|
FORCE="YES"
|
|
;;
|
|
-l) #; used by decrypt()
|
|
DO_LIST="YES"
|
|
;;
|
|
-w) #; used by init() and clone()
|
|
if [[ ! "$2" =~ ^/ ]] ; then
|
|
error_out "You must specify a fully qualified work tree"
|
|
fi
|
|
YADM_WORK="$2"
|
|
shift
|
|
;;
|
|
*) #; any unhandled arguments
|
|
YADM_ARGS+=("$1")
|
|
;;
|
|
esac
|
|
shift
|
|
done
|
|
[ ! -d "$YADM_WORK" ] && error_out "Work tree does not exist: [$YADM_WORK]"
|
|
$YADM_COMMAND "${YADM_ARGS[@]}"
|
|
else
|
|
#; any other commands are simply passed through to git
|
|
git_command "$@"
|
|
fi
|
|
|
|
#; process automatic events
|
|
auto_alt
|
|
auto_perms
|
|
|
|
exit 0
|
|
|
|
}
|
|
|
|
#; ****** yadm Commands ******
|
|
|
|
function alt() {
|
|
|
|
require_repo
|
|
|
|
#; regex for matching "<file>##SYSTEM.HOSTNAME.USER"
|
|
match_system=$(uname -s)
|
|
match_host=$(hostname -s)
|
|
match_user=$(id -u -n)
|
|
match="^(.+)##($match_system|$match_system.$match_host|$match_system.$match_host.$match_user|())$"
|
|
|
|
#; process relative to YADM_WORK
|
|
YADM_WORK=$(to_yadm_dir "$(git config core.worktree)")
|
|
cd "$YADM_WORK" || {
|
|
debug "Alternates not processed, unable to cd to $YADM_WORK"
|
|
return
|
|
}
|
|
|
|
#; only be noisy if the "alt" command was run directly
|
|
[ "$YADM_COMMAND" = "alt" ] && loud="YES"
|
|
|
|
#; loop over all "tracked" files
|
|
#; for every file which matches the above regex, create a symlink
|
|
last_linked=''
|
|
for tracked_file in $(git ls-files | sort); do
|
|
tracked_file="$YADM_WORK/$tracked_file"
|
|
#; process both the path, and it's parent directory
|
|
for alt_path in "$tracked_file" "${tracked_file%/*}"; do
|
|
if [ -e "$alt_path" ] ; then
|
|
if [[ $alt_path =~ $match ]] ; then
|
|
if [ "$alt_path" != "$last_linked" ] ; then
|
|
new_link="${BASH_REMATCH[1]}"
|
|
debug "Linking $alt_path to $new_link"
|
|
[ -n "$loud" ] && echo "Linking $alt_path to $new_link"
|
|
ln -nfs "$alt_path" "$new_link"
|
|
last_linked="$alt_path"
|
|
fi
|
|
fi
|
|
fi
|
|
done
|
|
done
|
|
|
|
}
|
|
|
|
function clean() {
|
|
|
|
error_out "\"git clean\" has been disabled for safety. You could end up removing all unmanaged files."
|
|
|
|
}
|
|
|
|
function clone() {
|
|
|
|
#; clone will begin with a bare repo
|
|
init
|
|
|
|
#; add the specified remote, and configure the repo to track origin/master
|
|
debug "Adding remote to new repo"
|
|
git remote add origin "$1"
|
|
debug "Configuring new repo to track origin/master"
|
|
git config branch.master.remote origin
|
|
git config branch.master.merge refs/heads/master
|
|
|
|
#; fetch / merge (and possibly fallback to reset)
|
|
debug "Doing an initial fetch of the origin"
|
|
git fetch origin || {
|
|
debug "Removing repo after failed clone"
|
|
rm -rf "$YADM_REPO"
|
|
error_out "Unable to fetch origin $1"
|
|
}
|
|
debug "Doing an initial merge of origin/master"
|
|
git merge origin/master || {
|
|
debug "Merge failed, doing a reset."
|
|
git reset origin/master
|
|
cat <<EOF
|
|
**NOTE**
|
|
Merging origin/master failed.
|
|
yadm did 'reset origin/master' instead.
|
|
|
|
This likely happened because you had files in your
|
|
work-tree, which conflict files tracked by origin/master
|
|
|
|
Please review and resolve any differences appropriately
|
|
If you know what you're doing, and want to overwrite the
|
|
tracked files, consider 'yadm reset --hard origin/master'
|
|
EOF
|
|
}
|
|
|
|
CHANGES_POSSIBLE=1
|
|
|
|
}
|
|
|
|
function config() {
|
|
|
|
#; ensure we have a file, even if empty
|
|
[ -f "$YADM_CONFIG" ] || touch "$YADM_CONFIG"
|
|
|
|
if [ -z "$*" ] ; then
|
|
#; with no parameters, provide some helpful documentation
|
|
echo TODO: Print help about available yadm configurations
|
|
else
|
|
#; operate on the yadm configuration file
|
|
git config --file="$(to_git_dir "$YADM_CONFIG")" "$@"
|
|
fi
|
|
|
|
}
|
|
|
|
function decrypt() {
|
|
|
|
require_gpg
|
|
require_archive
|
|
|
|
YADM_WORK=$(to_yadm_dir "$(git config core.worktree)")
|
|
|
|
if [ "$DO_LIST" = "YES" ] ; then
|
|
tar_option="t"
|
|
else
|
|
tar_option="x"
|
|
fi
|
|
|
|
#; decrypt the archive
|
|
($GPG_PROGRAM -d "$YADM_ARCHIVE" || echo 1) | tar v${tar_option}f - -C "$YADM_WORK"
|
|
if [ $? = 0 ] ; then
|
|
[ ! "$DO_LIST" = "YES" ] && echo "All files decrypted."
|
|
else
|
|
error_out "Unable to extract encrypted files."
|
|
fi
|
|
|
|
CHANGES_POSSIBLE=1
|
|
|
|
}
|
|
|
|
function encrypt() {
|
|
|
|
require_gpg
|
|
require_encrypt
|
|
require_ls
|
|
|
|
#; process relative to YADM_WORK
|
|
YADM_WORK=$(to_yadm_dir "$(git config core.worktree)")
|
|
cd "$YADM_WORK" || {
|
|
debug "Encryption not processed, unable to cd to $YADM_WORK"
|
|
return
|
|
}
|
|
|
|
#; Build gpg options for gpg
|
|
GPG_KEY="$(config yadm.gpg-recipient)"
|
|
if [ "$GPG_KEY" = "ASK" ]; then
|
|
GPG_OPTS=("--no-default-recipient" "-e")
|
|
elif [ "$GPG_KEY" != "" ]; then
|
|
GPG_OPTS=("-e" "-r $GPG_KEY")
|
|
else
|
|
GPG_OPTS=("-c")
|
|
fi
|
|
|
|
#; build a list of globs from YADM_ENCRYPT
|
|
GLOBS=()
|
|
while IFS='' read -r glob || [ -n "$glob" ]; do
|
|
if [[ ! $glob =~ ^# ]] ; then
|
|
GLOBS=("${GLOBS[@]}" $(eval "$LS_PROGRAM" "$glob" 2>/dev/null))
|
|
fi
|
|
done < "$YADM_ENCRYPT"
|
|
|
|
#; report which files will be encrypted
|
|
echo "Encrypting the following files:"
|
|
"$LS_PROGRAM" -1 "${GLOBS[@]}"
|
|
echo
|
|
|
|
#; encrypt all files which match the globs
|
|
tar -f - -c "${GLOBS[@]}" | $GPG_PROGRAM --yes "${GPG_OPTS[@]}" --output "$YADM_ARCHIVE"
|
|
if [ $? = 0 ]; then
|
|
echo "Wrote new file: $YADM_ARCHIVE"
|
|
else
|
|
error_out "Unable to write $YADM_ARCHIVE"
|
|
fi
|
|
|
|
#; offer to add YADM_ARCHIVE if untracked
|
|
archive_status=$(git status --porcelain -uall "$(to_git_dir "$YADM_ARCHIVE")" 2>/dev/null)
|
|
archive_regex="^\?\?"
|
|
if [[ $archive_status =~ $archive_regex ]] ; then
|
|
echo "It appears that $YADM_ARCHIVE is not tracked by yadm's repository."
|
|
echo "Would you like to add it now? (y/n)"
|
|
read -r answer
|
|
if [[ $answer =~ ^[yY]$ ]] ; then
|
|
git add "$(to_git_dir "$YADM_ARCHIVE")"
|
|
fi
|
|
fi
|
|
|
|
CHANGES_POSSIBLE=1
|
|
|
|
}
|
|
|
|
function git_command() {
|
|
|
|
require_repo
|
|
|
|
#; translate 'gitconfig' to 'config' -- 'config' is reserved for yadm
|
|
if [ "$1" = "gitconfig" ] ; then
|
|
set -- "config" "${@:2}"
|
|
fi
|
|
|
|
#; pass commands through to git
|
|
git "$@"
|
|
|
|
CHANGES_POSSIBLE=1
|
|
|
|
}
|
|
|
|
function help() {
|
|
|
|
cat << EOF
|
|
Usage: yadm <command> [options...]
|
|
|
|
Manage dotfiles maintained in a Git repository. Manage alternate files
|
|
for specific systems or hosts. Encrypt/decrypt private files.
|
|
|
|
Git Commands:
|
|
Any Git command or alias can be used as a <command>. It will operate
|
|
on yadm's repository and files in the work tree (usually \$HOME).
|
|
|
|
Commands:
|
|
yadm init [-f] - Initialize an empty repository
|
|
yadm clone <url> [-f] - Clone an existing repository
|
|
yadm config <name> <value> - Configure a setting
|
|
yadm list [-a] - List tracked files
|
|
yadm alt - Create links for alternates
|
|
yadm encrypt - Encrypt files
|
|
yadm decrypt [-l] - Decrypt files
|
|
yadm perms - Fix perms for private files
|
|
|
|
Files:
|
|
\$HOME/.yadm/config - yadm's configuration file
|
|
\$HOME/.yadm/repo.git - yadm's Git repository
|
|
\$HOME/.yadm/encrypt - List of globs used for encrypt/decrypt
|
|
\$HOME/.yadm/files.gpg - Encrypted data stored here
|
|
|
|
Use "man yadm" for complete documentation.
|
|
EOF
|
|
|
|
exit 1
|
|
|
|
}
|
|
|
|
function init() {
|
|
|
|
#; safety check, don't attempt to init when the repo is already present
|
|
[ -d "$YADM_REPO" ] && [ -z "$FORCE" ] && \
|
|
error_out "Git repo already exists. [$YADM_REPO]\nUse '-f' if you want to force it to be overwritten."
|
|
|
|
#; remove existing if forcing the init to happen anyway
|
|
[ -d "$YADM_REPO" ] && {
|
|
debug "Removing existing repo prior to init"
|
|
rm -rf "$YADM_REPO"
|
|
}
|
|
|
|
#; init a new bare repo
|
|
debug "Init new repo"
|
|
git init --shared=0600 --bare "$(to_git_dir "$YADM_REPO")"
|
|
configure_repo
|
|
|
|
CHANGES_POSSIBLE=1
|
|
|
|
}
|
|
|
|
function list() {
|
|
|
|
require_repo
|
|
|
|
#; process relative to YADM_WORK when --all is specified
|
|
if [ -n "$LIST_ALL" ] ; then
|
|
YADM_WORK=$(to_yadm_dir "$(git config core.worktree)")
|
|
cd "$YADM_WORK" || {
|
|
debug "List not processed, unable to cd to $YADM_WORK"
|
|
return
|
|
}
|
|
fi
|
|
|
|
#; list tracked files
|
|
git ls-files
|
|
|
|
}
|
|
|
|
function perms() {
|
|
|
|
require_ls
|
|
|
|
#; TODO: prevent repeats in the files changed
|
|
|
|
#; process relative to YADM_WORK
|
|
YADM_WORK=$(to_yadm_dir "$(git config core.worktree)")
|
|
cd "$YADM_WORK" || {
|
|
debug "Perms not processed, unable to cd to $YADM_WORK"
|
|
return
|
|
}
|
|
|
|
GLOBS=()
|
|
|
|
#; include the archive created by "encrypt"
|
|
[ -f "$YADM_ARCHIVE" ] && GLOBS=("${GLOBS[@]}" "$YADM_ARCHIVE")
|
|
|
|
#; include all .ssh files (unless disabled)
|
|
if [[ $(config --bool yadm.ssh-perms) != "false" ]] ; then
|
|
GLOBS=("${GLOBS[@]}" ".ssh" ".ssh/*")
|
|
fi
|
|
|
|
#; include all gpg files (unless disabled)
|
|
if [[ $(config --bool yadm.gpg-perms) != "false" ]] ; then
|
|
GLOBS=("${GLOBS[@]}" ".gnupg" ".gnupg/*")
|
|
fi
|
|
|
|
#; include globs found in YADM_ENCRYPT (if present)
|
|
if [ -f "$YADM_ENCRYPT" ] ; then
|
|
while IFS='' read -r glob || [ -n "$glob" ]; do
|
|
if [[ ! $glob =~ ^# ]] ; then
|
|
GLOBS=("${GLOBS[@]}" $(eval "$LS_PROGRAM" "$glob" 2>/dev/null))
|
|
fi
|
|
done < "$YADM_ENCRYPT"
|
|
fi
|
|
|
|
#; remove group/other permissions from collected globs
|
|
#shellcheck disable=SC2068
|
|
#(SC2068 is disabled because in this case, we desire globbing)
|
|
chmod -f go-rwx ${GLOBS[@]} >/dev/null 2>&1
|
|
#; TODO: detect and report changing permissions in a portable way
|
|
|
|
}
|
|
|
|
function version() {
|
|
|
|
echo "yadm $VERSION"
|
|
exit 0
|
|
|
|
}
|
|
|
|
#; ****** Utility Functions ******
|
|
|
|
function process_global_args() {
|
|
|
|
#; global arguments are removed before the main processing is done
|
|
MAIN_ARGS=()
|
|
while [[ $# -gt 0 ]] ; do
|
|
key="$1"
|
|
case $key in
|
|
-Y|--yadm-dir) #; override the standard YADM_DIR
|
|
if [[ ! "$2" =~ ^/ ]] ; then
|
|
error_out "You must specify a fully qualified yadm directory"
|
|
fi
|
|
YADM_DIR="$2"
|
|
shift
|
|
;;
|
|
--yadm-repo) #; override the standard YADM_REPO
|
|
if [[ ! "$2" =~ ^/ ]] ; then
|
|
error_out "You must specify a fully qualified repo path"
|
|
fi
|
|
YADM_OVERRIDE_REPO="$2"
|
|
shift
|
|
;;
|
|
--yadm-config) #; override the standard YADM_CONFIG
|
|
if [[ ! "$2" =~ ^/ ]] ; then
|
|
error_out "You must specify a fully qualified config path"
|
|
fi
|
|
YADM_OVERRIDE_CONFIG="$2"
|
|
shift
|
|
;;
|
|
--yadm-encrypt) #; override the standard YADM_ENCRYPT
|
|
if [[ ! "$2" =~ ^/ ]] ; then
|
|
error_out "You must specify a fully qualified encrypt path"
|
|
fi
|
|
YADM_OVERRIDE_ENCRYPT="$2"
|
|
shift
|
|
;;
|
|
--yadm-archive) #; override the standard YADM_ARCHIVE
|
|
if [[ ! "$2" =~ ^/ ]] ; then
|
|
error_out "You must specify a fully qualified archive path"
|
|
fi
|
|
YADM_OVERRIDE_ARCHIVE="$2"
|
|
shift
|
|
;;
|
|
*) #; main arguments are kept intact
|
|
MAIN_ARGS+=("$1")
|
|
;;
|
|
esac
|
|
shift
|
|
done
|
|
|
|
}
|
|
|
|
function configure_paths() {
|
|
|
|
#; change all paths to be relative to YADM_DIR
|
|
YADM_REPO="$YADM_DIR/$YADM_REPO"
|
|
YADM_CONFIG="$YADM_DIR/$YADM_CONFIG"
|
|
YADM_ENCRYPT="$YADM_DIR/$YADM_ENCRYPT"
|
|
YADM_ARCHIVE="$YADM_DIR/$YADM_ARCHIVE"
|
|
|
|
#; independent overrides for paths
|
|
if [ -n "$YADM_OVERRIDE_REPO" ]; then
|
|
YADM_REPO="$YADM_OVERRIDE_REPO"
|
|
fi
|
|
if [ -n "$YADM_OVERRIDE_CONFIG" ]; then
|
|
YADM_CONFIG="$YADM_OVERRIDE_CONFIG"
|
|
fi
|
|
if [ -n "$YADM_OVERRIDE_ENCRYPT" ]; then
|
|
YADM_ENCRYPT="$YADM_OVERRIDE_ENCRYPT"
|
|
fi
|
|
if [ -n "$YADM_OVERRIDE_ARCHIVE" ]; then
|
|
YADM_ARCHIVE="$YADM_OVERRIDE_ARCHIVE"
|
|
fi
|
|
|
|
#; use the yadm repo for all git operations
|
|
GIT_DIR=$(to_git_dir "$YADM_REPO")
|
|
export GIT_DIR
|
|
|
|
}
|
|
|
|
function configure_repo() {
|
|
|
|
debug "Configuring new repo"
|
|
|
|
#; change bare to false (there is a working directory)
|
|
git config core.bare 'false'
|
|
|
|
#; set the worktree for the yadm repo
|
|
git config core.worktree "$(to_git_dir "$YADM_WORK")"
|
|
|
|
#; by default, do not show untracked files and directories
|
|
git config status.showUntrackedFiles no
|
|
|
|
#; possibly used later to ensure we're working on the yadm repo
|
|
git config yadm.managed 'true'
|
|
|
|
}
|
|
|
|
function debug() {
|
|
|
|
[ -n "$DEBUG" ] && echo -e "DEBUG: $*"
|
|
|
|
}
|
|
|
|
function error_out() {
|
|
|
|
echo -e "ERROR: $*"
|
|
exit 1
|
|
|
|
}
|
|
|
|
#; ****** Auto Functions ******
|
|
|
|
function auto_alt() {
|
|
|
|
#; process alternates if there are possible changes
|
|
if [ "$CHANGES_POSSIBLE" = "1" ] ; then
|
|
auto_alt=$(config --bool yadm.auto-alt)
|
|
if [ "$auto_alt" != "false" ] ; then
|
|
alt
|
|
fi
|
|
fi
|
|
|
|
}
|
|
|
|
function auto_perms() {
|
|
|
|
#; process permissions if there are possible changes
|
|
if [ "$CHANGES_POSSIBLE" = "1" ] ; then
|
|
auto_perms=$(config --bool yadm.auto-perms)
|
|
if [ "$auto_perms" != "false" ] ; then
|
|
perms
|
|
fi
|
|
fi
|
|
|
|
}
|
|
|
|
#; ****** Prerequisites Functions ******
|
|
|
|
function require_archive() {
|
|
[ -f "$YADM_ARCHIVE" ] || error_out "$YADM_ARCHIVE does not exist. did you forget to create it?"
|
|
}
|
|
function require_encrypt() {
|
|
[ -f "$YADM_ENCRYPT" ] || error_out "$YADM_ENCRYPT does not exist. did you forget to create it?"
|
|
}
|
|
function require_git() {
|
|
command -v git >/dev/null 2>&1 || \
|
|
error_out "This functionality requires Git to be installed, but the command git cannot be located."
|
|
|
|
case "$(uname -s)" in
|
|
CYGWIN*)
|
|
if git --version | grep -q "windows"; then
|
|
use_cygpath="true"
|
|
fi
|
|
;;
|
|
|
|
*)
|
|
;;
|
|
esac
|
|
}
|
|
function require_gpg() {
|
|
local alt_gpg
|
|
alt_gpg="$(config yadm.gpg-program)"
|
|
|
|
local more_info
|
|
more_info=""
|
|
|
|
if [ "$alt_gpg" != "" ] ; then
|
|
GPG_PROGRAM="$alt_gpg"
|
|
more_info="\nThis command has been set via the yadm.gpg-program configuration."
|
|
fi
|
|
command -v "$GPG_PROGRAM" >/dev/null 2>&1 || \
|
|
error_out "This functionality requires GPG to be installed, but the command '$GPG_PROGRAM' cannot be located.$more_info"
|
|
}
|
|
function require_repo() {
|
|
[ -d "$YADM_REPO" ] || error_out "Git repo does not exist. did you forget to run 'init' or 'clone'?"
|
|
}
|
|
function require_ls() {
|
|
if [ ! -f "$LS_PROGRAM" ] ; then
|
|
command -v ls >/dev/null 2>&1 || \
|
|
error_out "This functionality requires 'ls' to be installed at '$LS_PROGRAM' or listed in your \$PATH"
|
|
LS_PROGRAM=ls
|
|
fi
|
|
}
|
|
|
|
#; ****** directory helpers ******
|
|
|
|
function to_yadm_dir() {
|
|
if [ -n "$use_cygpath" ] ; then
|
|
cygpath -u "$1"
|
|
else
|
|
echo "$1"
|
|
fi
|
|
}
|
|
function to_git_dir() {
|
|
if [ -n "$use_cygpath" ] ; then
|
|
cygpath -m "$1"
|
|
else
|
|
echo "$1"
|
|
fi
|
|
}
|
|
|
|
#; ****** Main processing (when not unit testing) ******
|
|
|
|
if [ "$YADM_TEST" != 1 ] ; then
|
|
process_global_args "$@"
|
|
require_git
|
|
configure_paths
|
|
main "${MAIN_ARGS[@]}"
|
|
fi
|