Add rules for bash completion and prepare for cli options.

lu0 · lu0 · commit fd4459cdd0f0 · 2021-09-12T02:40:40.000-05:00
diff --git a/README.md b/README.md
@@ -8,16 +8,16 @@ This script clones a subdirectory of a github/gitlab repository.
 Test the script with the example config file.
 By the end of the execution, you will see a `tmp` directory containing the subfolder of the example repository.
 ```zsh
-./git-partial-clone.sh example.conf
+./git-partial-clone.sh --file example.conf
 ```
 ## Install
-Add the script to your `PATH`
+Install the script and autocompletion rules.
 ```zsh
-ln -srf git-partial-clone.sh ~/.local/bin/git-partial-clone
+./install.sh
 ```
-Then you can execute the script from any directory with your custom config file.
+Then you can execute the script from any directory with your custom config file and use `TAB` to autocomplete the CLI options.
 ```zsh
-git-partial-clone path/to/your/config/file.conf
+git-partial-clone --file path/to/your/config/file.conf
 ```
 
 # Configuration
diff --git a/completion-rules.sh b/completion-rules.sh
@@ -0,0 +1,34 @@
+#
+# Bash completion file for the git-partial-clone script
+#
+# Copyright (c) 2021 Lucero Alvarado 
+#   https://github.com/lu0/git-partial-clone
+#
+
+have git-partial-clone &&
+_git-partial-clone()
+{
+    local cur prev
+    local words cword
+    _init_completion || return
+
+    local i use_config_file
+    for ((i = cword - 1; i > 0; i--)); do
+        [[ ${words[i]} == --file ]] \
+            && use_config_file=true && break
+    done
+
+    case $prev in
+        --file | -!(-*)f)
+            # Suggest files with .conf extension
+            _filedir '?()conf'
+            return
+            ;;
+    esac
+
+    # Suggest options contained in the 'usage' section of the script
+    [[ ! $use_config_file ]] \
+        && COMPREPLY=($(compgen -W '$(_parse_help "$1")' -- "$cur"))
+}
+complete -F _git-partial-clone git-partial-clone
+ 
diff --git a/git-partial-clone.sh b/git-partial-clone.sh
@@ -8,82 +8,106 @@
 #   https://github.com/lu0/git-partial-clone
 #
 
-CONFIG_FILE_PATH=${1}
 
-git-partial-clone() {
+main() {
+    usage() {
+        # echo "This script must be run with super-user privileges." 
+	    # echo -e "\nUsage: \$0 [arguments] \n" 
+        echo -e "\nClone a subdirectory of a github/gitlab repository."
+        echo -e "\nUSAGE:"
+        echo -e "   git-partial-clone [OPTIONS] ARGUMENTS"
+        echo -e "\nOPTIONS:"
+        echo -e "   Using a config file:"
+        echo -e "       -f | --file     Path to the configuration file.\n"
+        echo
+    }
+    case $# in
+    2) 
+        FILE_PATH=${2}
+        [ ${FILE_PATH} ] \
+            && _git-partial-clone ${FILE_PATH} \
+            || usage
+        ;;
+    *)
+        usage
+        ;;
+    esac
+}
+
+_git-partial-clone() {
     # Source config file
-    [ ${1} ] \
-        && get-variables-from-file ${1} \
-        || { notif err "git-partial-clone requires a configuration file." && abort ;}
+    [ -f ${1} ] \
+        && _get-variables-from-file ${1} \
+        || _notif err "Not a valid path."
 
-    check-mandatory-vars "GIT_HOST REPO_NAME REPO_OWNER" || abort
-    get-token-from-file "${TOKEN_PATH}" GIT_TOKEN
+    _check-mandatory-vars "GIT_HOST REPO_NAME REPO_OWNER" || _abort
+    _get-token-from-file "${TOKEN_PATH}" GIT_TOKEN
     
     # Change working directory
-    get-clone-dir-path "${PARENT_DIR}" "${REPO_NAME}" CLONE_DIR || abort
-    mkdir "${CLONE_DIR}" && cd "${CLONE_DIR}" || abort
+    _get-clone-dir-path "${PARENT_DIR}" "${REPO_NAME}" CLONE_DIR || _abort
+    mkdir "${CLONE_DIR}" && cd "${CLONE_DIR}" || _abort
 
     # Add origin
     [ -d "${CLONE_DIR}"/.git/ ] \
-        && notif err "${CLONE_DIR} is already a git directory." && abort \
+        && _notif err "${CLONE_DIR} is already a git directory." && _abort \
         || git init
     GIT_URL=${GIT_HOST}.com/${REPO_OWNER}/${REPO_NAME}
     [ ${GIT_USER} ] && [ ${GIT_TOKEN} ] \
         && git remote add origin https://${GIT_USER}:${GIT_TOKEN}@${GIT_URL}.git \
         || git remote add origin https://${GIT_URL}.git
 
-    enable-partial-clone ${CLONE_DIR} ${REMOTE_PARTIAL_DIR}
-    fetch-commit-history ${CLONE_DIR} ${COMMIT_DEPTH}
+    _enable-partial-clone ${CLONE_DIR} ${REMOTE_PARTIAL_DIR}
+    _fetch-commit-history ${CLONE_DIR} "${COMMIT_DEPTH}"
 
     # Pull branch(es)
     [ ${BRANCH} ] \
-        && { notif ok "Trying to fetch branch ${BRANCH}" && \
-             pull-single-branch ${CLONE_DIR} ${BRANCH} ;} \
-        || { notif warn "BRANCH not specified, pulling every branch in ${REPO_NAME}." && \
-             pull-all-branches ${CLONE_DIR} ;}
+        && { _notif ok "Trying to fetch branch ${BRANCH}" && \
+             _pull-single-branch ${CLONE_DIR} ${BRANCH} ;} \
+        || { _notif warn "BRANCH not specified, pulling every branch in ${REPO_NAME}." && \
+             _pull-all-branches ${CLONE_DIR} ;}
 
     # Done
     [ ${REMOTE_PARTIAL_DIR} ] \
-        && notif ok "${REMOTE_PARTIAL_DIR} of https://${GIT_URL} was cloned into" \
-        || notif ok "https://${GIT_URL} was cloned into"
-    notif ok "${CLONE_DIR}"
-    cd - && unset-variables-from-file ${1}
+        && _notif ok "${REMOTE_PARTIAL_DIR} of https://${GIT_URL} was cloned into" \
+        || _notif ok "https://${GIT_URL} was cloned into"
+    _notif ok "${CLONE_DIR}"
+    cd - && _unset-variables-from-file ${1}
 }
 
-check-mandatory-vars() {
+_check-mandatory-vars() {
     # Returns an error if a mandatory variable is missing.
-    # Usage: check-mandatory-vars ${STRING_OF_SPACE_SEPARATED_VAR_NAMES}
+    # Usage: _check-mandatory-vars ${STRING_OF_SPACE_SEPARATED_VAR_NAMES}
     local vars_arr=($1)
     local count=0
     for var_name in "${vars_arr[@]}"; do
         local var_value="${!var_name}"
         # echo "$var_name=${var_value}"
         [ "${var_value}" ] \
-            || { notif err "$var_name is mandatory." && ((++count)) ;}
+            || { _notif err "$var_name is mandatory." && ((++count)) ;}
     done
     [[ $count -eq 0 ]] && return 0 || return 1
 }
 
-get-token-from-file() {
+_get-token-from-file() {
     # Reads the contents of the token file
-    # Usage: get-token-from-file <path to token file> <OUTPUT_VARIABLE_NAME>
+    # Usage: _get-token-from-file <path to token file> <OUTPUT_VARIABLE_NAME>
     eval TOKEN_PATH="${1}"  # expand quoted path
     MSG_NO_TOKEN="The repository must be public in order to be cloned."
     MSG_TOKEN_PROVIDED="A token was found! The repository will be cloned if you have access to it."
     
     [[ -z $TOKEN_PATH ]] \
-        && notif warn "You did not provide a token. ${MSG_NO_TOKEN}" \
+        && _notif warn "You did not provide a token. ${MSG_NO_TOKEN}" \
         || { MY_TOKEN=$(cat ${TOKEN_PATH}) && [ ${MY_TOKEN} ] \
-                && eval "${2}='${MY_TOKEN}'" && notif ok "${MSG_TOKEN_PROVIDED}" \
-                || notif err "Could not find a token in ${TOKEN_PATH}. ${MSG_NO_TOKEN}" ;}
+                && eval "${2}='${MY_TOKEN}'" && _notif ok "${MSG_TOKEN_PROVIDED}" \
+                || _notif err "Could not find a token in ${TOKEN_PATH}. ${MSG_NO_TOKEN}" ;}
 }
 
-get-clone-dir-path() {
+_get-clone-dir-path() {
     # Returns the path where the repository will be cloned.
-    # Usage: get-clone-dir-path <parent path> <name of repository> <OUTPUT_VARIABLE_NAME>
+    # Usage: _get-clone-dir-path <parent path> <name of repository> <OUTPUT_VARIABLE_NAME>
     local PARENT_DIR="${1}"
     local REPO_NAME="${2}"
-    [[ -z "${PARENT_DIR}" ]] && PARENT_DIR=${PWD} && notif warn "PARENT_DIR is blank"
+    [[ -z "${PARENT_DIR}" ]] && PARENT_DIR=${PWD} && _notif warn "PARENT_DIR is blank"
 
     # Convert to absolute
     [[ "${PARENT_DIR:0:1}" != "/" ]] && PARENT_DIR=${PWD}/${PARENT_DIR}
@@ -93,52 +117,52 @@ get-clone-dir-path() {
 
     mkdir -p "${PARENT_DIR}" && [ -d "${PARENT_DIR}" ] \
         && eval "${3}='${PARENT_DIR}/${REPO_NAME}'" \
-            && notif ok "The repository will be cloned within ${PARENT_DIR}" && return 0 \
-        || { notif err "${PARENT_DIR} does not exist." && return 1 ;}
+            && _notif ok "The repository will be cloned within ${PARENT_DIR}" && return 0 \
+        || { _notif err "${PARENT_DIR} does not exist." && return 1 ;}
 }
 
-get-variables-from-file() {
+_get-variables-from-file() {
     # Set the variables contained in a file of key-value pairs
     export $(grep --invert-match '^#' ${1} | xargs -d '\n')
 }
 
-unset-variables-from-file() {
+_unset-variables-from-file() {
     # Removes variables contained in a file of key-value pairs
     unset $(grep --invert-match '^#' ${1} | \
             grep --perl-regexp --only-matching '.*(?=\=)' | xargs)
 }
 
-enable-partial-clone() {
+_enable-partial-clone() {
     # Enable partial cloning if a subfolder is provided
     local CLONE_DIR=${1}
     local REMOTE_PARTIAL_DIR=${2}
     git -C ${CLONE_DIR} config --local extensions.partialClone origin
     [ ${REMOTE_PARTIAL_DIR} ] && git -C ${CLONE_DIR} sparse-checkout set ${REMOTE_PARTIAL_DIR}
 }
 
-fetch-commit-history() {
+_fetch-commit-history() {
     # Fetch history according to the provided commit depth
     local CLONE_DIR="${1}"
     local COMMIT_DEPTH="${2}"
     [ ${COMMIT_DEPTH} ] && [ ${COMMIT_DEPTH} -eq ${COMMIT_DEPTH} ] \
-        && { notif warn "Using COMMIT_DEPTH=${COMMIT_DEPTH}." \
+        && { _notif warn "Using COMMIT_DEPTH=${COMMIT_DEPTH}." \
             && git -C ${CLONE_DIR} fetch --depth ${COMMIT_DEPTH} --filter=blob:none \
-            || abort clean ;} \
-        || { notif warn "COMMIT_DEPTH not provided, fetching all of the history." \
+            || _abort clean ;} \
+        || { _notif warn "COMMIT_DEPTH not provided, fetching all of the history." \
             && git -C ${CLONE_DIR} fetch --filter=blob:none \
-            || abort clean ;}
+            || _abort clean ;}
 }
 
-pull-single-branch() {
+_pull-single-branch() {
     local CLONE_DIR=${1}
     local BRANCH=${2}
     git -C ${CLONE_DIR} checkout -b $BRANCH
     git -C ${CLONE_DIR} pull origin $BRANCH \
         && git -C ${CLONE_DIR} branch --set-upstream-to=origin/$BRANCH ${BRANCH} \
-        || abort clean
+        || _abort clean
 }
 
-pull-all-branches() {
+_pull-all-branches() {
     # Pull every branch in the remote
     # and switch to the default branch
     local CLONE_DIR=${1}
@@ -164,8 +188,8 @@ pull-all-branches() {
     git checkout ${HEAD_BRANCH}
 }
 
-notif() {
-    # Usage: notif <status> <message>
+_notif() {
+    # Usage: _notif <status> <message>
     local info='\033[0m'
     local ok='\033[0;32m'
     local warn='\033[0;33m'
@@ -176,17 +200,17 @@ notif() {
     printf ${info}
 }
 
-abort() {
-    notif err "Aborted."
+_abort() {
+    _notif err "Aborted."
     case $# in
     1)
-        notif warn "Removing empty tree in ${CLONE_DIR}"
+        _notif warn "Removing empty tree in ${CLONE_DIR}"
         rm -rf ${CLONE_DIR} && \
         rmdir -p --ignore-fail-on-non-empty ${CLONE_DIR%/*}
         ;;
     esac
     exit
 }
 
-git-partial-clone ${CONFIG_FILE_PATH}
+main "$@"
  
diff --git a/install.sh b/install.sh
@@ -0,0 +1,30 @@
+#!/bin/bash
+
+#
+# Installer for the git-partial-clone script
+#
+# Copyright (c) 2021 Lucero Alvarado 
+#   https://github.com/lu0/git-partial-clone
+#
+
+echo "Installing git-partial-clone ..."
+LOCAL_PATH=~/.local/bin
+BASH_COMPLETION_DIR=~/.local/etc/bash_completion.d
+BASH_COMPLETION_SCRIPT=~/.bash_completion
+KEYWORDS_DIR=~/.config/git-partial-clone
+
+echo "Adding script to the local PATH ..."
+ln -srf git-partial-clone.sh ${LOCAL_PATH}/git-partial-clone
+
+echo "Adding the completion rules ..."
+mkdir -p ${BASH_COMPLETION_DIR}
+ln -srf completion-rules.sh ${BASH_COMPLETION_DIR}/git-partial-clone
+mkdir -p ${KEYWORDS_DIR}
+ln -srf keywords ${KEYWORDS_DIR}/
+echo "for file in ${BASH_COMPLETION_DIR}/* ; do" >> ${BASH_COMPLETION_SCRIPT}
+echo -e "\t. \$file" >> ${BASH_COMPLETION_SCRIPT}
+echo "done" >> ${BASH_COMPLETION_SCRIPT}
+echo "Done!"
+
+exec bash
+ 
diff --git a/uninstall.sh b/uninstall.sh
@@ -0,0 +1,30 @@
+#!/bin/bash
+
+#
+# Uninstaller for the git-partial-clone script
+#
+# Copyright (c) 2021 Lucero Alvarado 
+#   https://github.com/lu0/git-partial-clone
+#
+
+echo "Uninstalling git-partial-clone ..."
+LOCAL_PATH=~/.local/bin
+BASH_COMPLETION_DIR=~/.local/etc/bash_completion.d
+BASH_COMPLETION_SCRIPT=~/.bash_completion
+KEYWORDS_DIR=~/.config/git-partial-clone
+
+echo "Removing script from the local PATH ..."
+rm -rf ${LOCAL_PATH}/git-partial-clone
+
+echo "Removing the completion rules ..."
+LINES_IN_FILE=$([[ -f ~/.bash_completion ]] \
+                    && sort ~/.bash_completion | uniq | wc -l)
+[[ ${LINES_IN_FILE} == 3 ]] \
+    && rm -rf ${BASH_COMPLETION_DIR} \
+    && rm -rf ~/.bash_completion \
+    || rm -rf ${BASH_COMPLETION_SCRIPT}
+rm -rf ${KEYWORDS_DIR}
+echo "Done!"
+
+exec bash
+ 
