eac_git 0.18.1 → 0.18.2

data/vendor/git-subrepo/lib/git-subrepo

@@ -4,6 +4,7 @@
 # Copyright 2013-2020 - Ingy döt Net <ingy@ingy.net>
 #
 
+# shellcheck disable=1090,1091,2034
 
 # Exit on any errors:
 set -e
@@ -11,26 +12,28 @@ set -e
 export FILTER_BRANCH_SQUELCH_WARNING=1
 
 # Import Bash+ helper functions:
-SOURCE="$BASH_SOURCE"
+SOURCE=${BASH_SOURCE[0]}
 while [[ -h $SOURCE ]]; do
-  DIR="$( cd -P "$( dirname "$SOURCE" )" && pwd )"
-  SOURCE="$(readlink "$SOURCE")"
-  [[ $SOURCE != /* ]] && SOURCE="$DIR/$SOURCE"
+  DIR=$( cd -P "$( dirname "$SOURCE" )" && pwd )
+  SOURCE=$(readlink "$SOURCE")
+  [[ $SOURCE != /* ]] && SOURCE=$DIR/$SOURCE
 done
-SOURCE_DIR="$(dirname "$SOURCE")"
+SOURCE_DIR=$(dirname "$SOURCE")
 
-if [[ -z "$GIT_SUBREPO_ROOT" ]]; then
+if [[ -z $GIT_SUBREPO_ROOT ]]; then
   # If `make install` installation used:
   source "${SOURCE_DIR}/git-subrepo.d/bash+.bash"
 else
   # If `source .rc` method used:
   source "${SOURCE_DIR}/../ext/bashplus/lib/bash+.bash"
 fi
-bash+:import :std can
+bash+:import :std can version-check
 
-VERSION=0.4.1
+
+VERSION=0.4.9
+REQUIRED_BASH_VERSION=4.0
 REQUIRED_GIT_VERSION=2.7.0
-GIT_TMP="$(git rev-parse --git-common-dir 2> /dev/null || echo .git)/tmp"
+GIT_TMP=$(git rev-parse --git-common-dir 2> /dev/null || echo .git)/tmp
 
 # `git rev-parse` turns this into a getopt parser and a command usage message:
 GETOPT_SPEC="\
@@ -61,20 +64,20 @@ Options:
 h           Show the command summary
 help        Help overview
 version     Print the git-subrepo version number
-
+ 
 a,all       Perform command on all current subrepos
 A,ALL       Perform command on all subrepos and subsubrepos
 b,branch=   Specify the upstream branch to push/pull/fetch
 e,edit      Edit commit message
 f,force     Force certain operations
 F,fetch     Fetch the upstream content first
-M,method=   Method when you join, valid options are 'merge' or 'rebase'
-            Default is 'merge'
+M,method=   Join method: 'merge' (default) or 'rebase'
 m,message=  Specify a commit message
+file=       Specify a commit message file
 r,remote=   Specify the upstream remote to push/pull/fetch
 s,squash    Squash commits on push
 u,update    Add the --branch and/or --remote overrides to .gitrepo
-
+ 
 q,quiet     Show minimal output
 v,verbose   Show verbose output
 d,debug     Show the actual commands used
@@ -106,7 +109,8 @@ main() {
   local subref=                 # Valid git ref format of subdir
   local gitrepo=                # Path to .gitrepo file
   local worktree=               # Worktree created by 'git worktree'
-  local start_pwd=$(pwd)        # Store the original directory
+  local start_pwd
+        start_pwd=$(pwd)        # Store the original directory
 
   local original_head_commit=   # HEAD commit id at start of command
   local original_head_branch=   # HEAD ref at start of command
@@ -128,6 +132,7 @@ main() {
 
   local edit_wanted=false       # Edit commit message using -e
   local wanted_commit_message=  # Custom commit message using -m
+  local commit_msg_file=        # Custom commit message using --file
 
   local join_method=            # Current join method (rebase/merge)
 
@@ -154,10 +159,14 @@ main() {
   command-init
 
   if $all_wanted && [[ ! $command =~ ^(help|status)$ ]]; then
+    if [[ -n $subrepo_branch ]]; then
+      error "options --branch and --all are not compatible"
+    fi
+
     # Run the command on all subrepos
     local args=( "${command_arguments[@]}" )
     get-all-subrepos
-    for subdir in ${subrepos[*]}; do
+    for subdir in "${subrepos[@]}"; do
       command-prepare
       subrepo_remote=
       subrepo_branch=
@@ -195,15 +204,18 @@ command:clone() {
   # Successful command output:
   local re=
   $force_wanted && re=re
-  local remote="$subrepo_remote"
+  local remote=$subrepo_remote
   say "Subrepo '$remote' ($subrepo_branch) ${re}cloned into '$subdir'."
 }
 
 # `git subrepo init <subdir>` command:
 command:init() {
   command-setup +subdir
-  local remote="${subrepo_remote:=none}"
-  local branch="${subrepo_branch:=master}"
+  local default_branch=
+  default_branch=$(git config init.defaultbranch)
+  default_branch=${default_branch:=master}
+  local remote=${subrepo_remote:=none}
+  local branch=${subrepo_branch:=$default_branch}
 
   # Init new subrepo from the subdir:
   subrepo:init
@@ -259,7 +271,7 @@ command:push() {
 # `git subrepo fetch <subdir>` command
 command:fetch() {
   command-setup +subdir
-  if [[ $subrepo_remote == "none" ]]; then
+  if [[ $subrepo_remote == none ]]; then
     say "Ignored '$subdir', no remote."
   else
     subrepo:fetch
@@ -274,10 +286,10 @@ command:branch() {
     CALL subrepo:fetch
   fi
 
-  local branch="subrepo/$subref"
+  local branch=subrepo/$subref
   if $force_wanted; then
     # We must make sure that the worktree is removed as well
-    worktree="$GIT_TMP/$branch"
+    worktree=$GIT_TMP/$branch
     git:delete-branch "$branch"
   fi
 
@@ -300,10 +312,10 @@ command:commit() {
   fi
   git:rev-exists "$refs_subrepo_fetch" ||
     error "Can't find ref '$refs_subrepo_fetch'. Try using -F."
-  upstream_head_commit="$(git rev-parse "$refs_subrepo_fetch")"
+  upstream_head_commit=$(git rev-parse "$refs_subrepo_fetch")
 
-  [[ -n $subrepo_commit_ref ]] ||
-    subrepo_commit_ref="subrepo/$subref"
+  [[ ${subrepo_commit_ref-} ]] ||
+    subrepo_commit_ref=subrepo/$subref
   subrepo:commit
 
   say "Subrepo commit '$subrepo_commit_ref' committed as"
@@ -317,11 +329,11 @@ command:status() {
 
 status-refs() {
   local output=
-  while read line; do
+  while read -r line; do
     [[ $line =~ ^([0-9a-f]+)\ refs/subrepo/$subref/([a-z]+) ]] || continue
-    local sha1=; sha1="$(git rev-parse --short "${BASH_REMATCH[1]}")"
-    local type="${BASH_REMATCH[2]}"
-    local ref="refs/subrepo/$subref/$type"
+    local sha1=; sha1=$(git rev-parse --short "${BASH_REMATCH[1]}")
+    local type=${BASH_REMATCH[2]}
+    local ref=refs/subrepo/$subref/$type
     if [[ $type == branch ]]; then
       output+="    Branch Ref:    $sha1 ($ref)"$'\n'
     elif [[ $type == commit ]]; then
@@ -334,8 +346,8 @@ status-refs() {
       output+="    Push Ref:      $sha1 ($ref)"$'\n'
     fi
   done < <(git show-ref)
-  if [[ -n $output ]]; then
-    printf "  Refs:\n$output"
+  if [[ $output ]]; then
+    printf "  Refs:\n%s" "$output"
   fi
 }
 
@@ -352,13 +364,14 @@ command:clean() {
 # Wrap git config $gitrepo
 command:config() {
   command-setup +subdir +config_option config_value
-  o "Update '$subdir' configuration with $config_option=$config_value"
+  # shellcheck disable=2154
+  o "Update '$subdir' configuration with $config_option=${config_value-}"
 
   if [[ ! $config_option =~ ^(branch|cmdver|commit|method|remote|version)$ ]]; then
     error "Option $config_option not recognized"
   fi
 
-  if [[ -z $config_value ]]; then
+  if [[ -z ${config_value-} ]]; then
     OUT=true RUN git config --file="$gitrepo" "subrepo.$config_option"
     say "Subrepo '$subdir' option '$config_option' has value '$output'."
     return
@@ -366,12 +379,12 @@ command:config() {
 
   if ! $force_wanted; then
     # Only allow changing method without force
-    if [[ ! $config_option == "method" ]]; then
+    if [[ $config_option != method ]]; then
       error "This option is autogenerated, use '--force' to override."
     fi
   fi
 
-  if [[ $config_option == "method" ]]; then
+  if [[ $config_option == method ]]; then
     if [[ ! $config_value =~ ^(merge|rebase)$ ]]; then
       error "Not a valid method. Valid options are 'merge' or 'rebase'."
     fi
@@ -385,8 +398,8 @@ command:config() {
 # Launch the manpage viewer:
 command:help() {
   source "${SOURCE_DIR}/git-subrepo.d/help-functions.bash"
-  local cmd="${command_arguments[0]}"
-  if [[ -n $cmd ]]; then
+  local cmd=${command_arguments[0]}
+  if [[ $cmd ]]; then
     if can "help:$cmd"; then
       "help:$cmd"
       echo
@@ -409,7 +422,7 @@ command:version() {
 git-subrepo Version: $VERSION
 Copyright 2013-2020 Ingy döt Net
 https://github.com/ingydotnet/git-subrepo
-$BASH_SOURCE
+${BASH_SOURCE[0]}
 Git Version: $git_version
 
 ...
@@ -417,15 +430,15 @@ Git Version: $git_version
 }
 
 command:upgrade() {
-  local path="$0"
+  local path=$0
   if [[ $path =~ ^/ && $path =~ ^(.*/git-subrepo)/lib/git-subrepo$ ]]; then
-    local subrepo_root="${BASH_REMATCH[1]}"
+    local subrepo_root=${BASH_REMATCH[1]}
     (
       o "Change directory to '$subrepo_root'."
       cd "${BASH_REMATCH[1]}"
 
-      local branch="$(git rev-parse --abbrev-ref HEAD)"
-      if [[ $branch != master ]]; then
+      branch_name=$(git rev-parse --abbrev-ref HEAD)
+      if [[ $branch_name != master ]]; then
         error "git-subrepo repo is not on the 'master' branch"
       fi
 
@@ -457,8 +470,6 @@ If you used 'make install' to install git-subrepo, then just do this:
 
 # Clone by fetching remote content into our subdir:
 subrepo:clone() {
-  re="$1"
-
   FAIL=false RUN git rev-parse HEAD
   if ! OK; then
     error "You can't clone into an empty repository"
@@ -474,18 +485,25 @@ subrepo:clone() {
     CALL subrepo:fetch
     read-gitrepo-file
     o "Check if we already are up to date."
-    if [[ $upstream_head_commit == $subrepo_commit ]]; then
+    if [[ $upstream_head_commit == "$subrepo_commit" ]]; then
       reclone_up_to_date=true
       return
     fi
     o "Remove the old subdir."
     RUN git rm -r -- "$subdir"
+
+    if [[ -z $override_branch ]]; then
+      o "Determine the upstream head branch."
+      get-upstream-head-branch
+      subrepo_branch="$output"
+      override_branch="$output" # Force update of the branch in .gitrepo
+    fi
   else
     assert-subdir-empty
     if [[ -z $subrepo_branch ]]; then
       o "Determine the upstream head branch."
       get-upstream-head-branch
-      subrepo_branch="$output"
+      subrepo_branch=$output
     fi
 
     CALL subrepo:fetch
@@ -495,13 +513,13 @@ subrepo:clone() {
   RUN mkdir -p -- "$subdir"
 
   o "Commit the new '$subdir/' content."
-  subrepo_commit_ref="$upstream_head_commit"
+  subrepo_commit_ref=$upstream_head_commit
   CALL subrepo:commit
 }
 
 # Init a new subrepo from current repo:
 subrepo:init() {
-  local branch_name="subrepo/${subref:??}"
+  local branch_name=subrepo/${subref:??}
   # Check if subdir is proper candidate for this init:
   assert-subdir-ready-for-init
 
@@ -513,7 +531,7 @@ subrepo:init() {
   RUN git add -f -- "$gitrepo"
 
   o "Commit new subrepo to the '$original_head_branch' branch."
-  subrepo_commit_ref="$original_head_commit"
+  subrepo_commit_ref=$original_head_commit
   RUN git commit -m "$(get-commit-message)"
 
   o "Create ref '$refs_subrepo_commit'."
@@ -524,22 +542,28 @@ subrepo:init() {
 subrepo:pull() {
   CALL subrepo:fetch
 
+  # If forced pull, then clone instead
+  if $force_wanted; then
+    CALL subrepo:clone
+    return
+  fi
+
   # Check if we already are up to date
   # If the -u flag is present, always perform the operation
-  if [[ $upstream_head_commit == $subrepo_commit ]] && ! $update_wanted; then
+  if [[ $upstream_head_commit == "$subrepo_commit" ]] && ! $update_wanted; then
     OK=false; CODE=-1; return
   fi
 
-  local branch_name="subrepo/$subref"
+  local branch_name=subrepo/$subref
   git:delete-branch "$branch_name"
 
-  subrepo_commit_ref="$branch_name"
+  subrepo_commit_ref=$branch_name
 
   o "Create subrepo branch '$branch_name'."
   CALL subrepo:branch
   cd "$worktree";
 
-  if [[ "$join_method" == "rebase" ]]; then
+  if [[ $join_method == rebase ]]; then
     o "Rebase changes to $refs_subrepo_fetch"
     FAIL=false OUT=true RUN git rebase "$refs_subrepo_fetch" "$branch_name"
     if ! OK; then
@@ -573,7 +597,7 @@ subrepo:pull() {
 
 # Push a properly merged subrepo branch upstream:
 subrepo:push() {
-  local branch_name="$branch"
+  local branch_name=$branch
   local new_upstream=false
   local branch_created=false
 
@@ -595,25 +619,27 @@ subrepo:push() {
       # Check that we are up to date:
       o "Check upstream head against .gitrepo commit."
       if ! $force_wanted; then
-        if [[ $upstream_head_commit != $subrepo_commit ]]; then
+        if [[ $upstream_head_commit != "$subrepo_commit" ]]; then
           error "There are new changes upstream, you need to pull first."
         fi
       fi
     fi
 
-    branch_name="subrepo/$subref"
+    branch_name=subrepo/$subref
+    # We must make sure that a stale worktree is removed as well
+    worktree=$GIT_TMP/$branch_name
     git:delete-branch "$branch_name"
 
     if $squash_wanted; then
       o "Squash commits"
-      subrepo_parent="HEAD^"
+      subrepo_parent=HEAD^
     fi
 
     o "Create subrepo branch '$branch_name'."
     CALL subrepo:branch "$branch_name"
     cd "$worktree";
 
-    if [[ "$join_method" == "rebase" ]]; then
+    if [[ $join_method == rebase ]]; then
       o "Rebase changes to $refs_subrepo_fetch"
       FAIL=false OUT=true RUN git rebase "$refs_subrepo_fetch" "$branch_name"
       if ! OK; then
@@ -637,9 +663,13 @@ subrepo:push() {
     error "No subrepo branch '$branch_name' to push."
 
   o "Check if we have something to push"
-  new_upstream_head_commit="$(git rev-parse "$branch_name")"
+  new_upstream_head_commit=$(git rev-parse "$branch_name")
   if ! $new_upstream; then
-    if [[ $upstream_head_commit == $new_upstream_head_commit ]]; then
+    if [[ $upstream_head_commit == "$new_upstream_head_commit" ]]; then
+      if $branch_created; then
+        o "Remove branch '$branch_name'."
+        git:delete-branch "$branch_name"
+      fi
       OK=false
       CODE=-2
       return
@@ -658,6 +688,7 @@ subrepo:push() {
   "$force_wanted" && force=' --force'
 
   o "Push$force branch '$branch_name' to '$subrepo_remote' ($subrepo_branch)."
+  # shellcheck disable=2086
   RUN git push$force "$subrepo_remote" "$branch_name":"$subrepo_branch"
 
   o "Create ref '$refs_subrepo_push' for branch '$branch_name'."
@@ -669,10 +700,22 @@ subrepo:push() {
   fi
 
   o "Put updates into '$subdir/.gitrepo' file."
-  upstream_head_commit="$new_upstream_head_commit"
-  subrepo_commit_ref="$upstream_head_commit"
+  upstream_head_commit=$new_upstream_head_commit
+  subrepo_commit_ref=$upstream_head_commit
   update-gitrepo-file
-  RUN git commit -m "$(get-commit-message)"
+
+  local commit_message
+  if [[ $wanted_commit_message ]]; then
+    commit_message=$wanted_commit_message
+  else
+    commit_message=$(get-commit-message)
+  fi
+
+  if [[ $commit_msg_file ]]; then
+    RUN git command --file "$commit_msg_file"
+  else
+    RUN git commit -m "$commit_message"
+  fi
 }
 
 # Fetch the subrepo's remote branch content:
@@ -687,15 +730,16 @@ subrepo:fetch() {
 
   o "Get the upstream subrepo HEAD commit."
   OUT=true RUN git rev-parse FETCH_HEAD^0
-  upstream_head_commit="$output"
+  upstream_head_commit=$output
 
   o "Create ref '$refs_subrepo_fetch'."
   git:make-ref "$refs_subrepo_fetch" FETCH_HEAD^0
 }
 
 # Create a subrepo branch containing all changes
+# shellcheck disable=2120
 subrepo:branch() {
-  local branch="${1:-"subrepo/$subref"}"
+  local branch=${1:-"subrepo/$subref"}
   o "Check if the '$branch' branch already exists."
   git:branch-exists "$branch" && return
 
@@ -703,39 +747,63 @@ subrepo:branch() {
   local first_gitrepo_commit=
 
   o "Subrepo parent: $subrepo_parent"
-  if [[ -n "$subrepo_parent" ]]; then
+
+  if [[ $subrepo_parent ]]; then
+
+    # Check if the subrepo parent is an ancestor of HEAD.
+    # For example rebasing the commit that touched the subrepo
+    # could make the commit no longer match.
+    local parent_is_ancestor=
+    git merge-base --is-ancestor "$subrepo_parent" HEAD && parent_is_ancestor="true"
+    if [[ -z "$parent_is_ancestor" ]]; then
+      local prev_merge_point
+      prev_merge_point=$(git log -1 -G "commit =" --format="%H" "$gitrepo")
+        # We want the SHA of the patch before the sync point just in case someone made a modifcation in the
+        # actual sync commit
+        prev_merge_point=$(git log -1 --format="%H" "$prev_merge_point"^)
+        error "The last sync point (where upstream and the subrepo were equal) is not an ancestor. \n \
+            This is usually caused by a rebase affecting that commit. \n \
+            To recover set the subrepo parent in '$gitrepo'\n \
+            to '$prev_merge_point' \n \
+            and validate the subrepo by comparing with 'git subrepo branch $subdir'"
+    fi
+
     local prev_commit=
     local ancestor=
     o "Create new commits with parents into the subrepo fetch"
     OUT=true RUN git rev-list --reverse --ancestry-path --topo-order "$subrepo_parent..HEAD"
-    local commit_list="$output"
+    local commit_list=$output
     for commit in $commit_list; do
       o "Working on $commit"
 
       FAIL=false OUT=true RUN git config --blob \
-        "$commit":"$subdir/.gitrepo" "subrepo.commit"
-      if [[ -z "$output" ]]; then
+        "$commit:$subdir/.gitrepo" "subrepo.commit"
+      if [[ -z $output ]]; then
         o "Ignore commit, no .gitrepo file"
         continue
       fi
 
-      local gitrepo_commit="$output"
+      local gitrepo_commit=$output
       o ".gitrepo reference commit: $gitrepo_commit"
 
 
       # Only include the commit if it's a child of the previous commit
       # This way we create a single path between $subrepo_parent..HEAD
-      if [[ -n "$ancestor" ]]; then
-        local is_direct_child=$(git show -s --pretty=format:"%P" $commit | grep "$ancestor")
+      if [[ $ancestor ]]; then
+        local is_direct_child
+        is_direct_child=$(
+          git show -s --pretty=format:"%P" "$commit" |
+            grep "$ancestor"
+        ) || true
         o "is child: $is_direct_child"
-        if [[ -z "$is_direct_child" ]]; then
+        if [[ -z $is_direct_child ]]; then
           o "Ignore $commit, it's not in the selected path"
           continue
         fi
       fi
 
       # Remember the previous commit from the parent repo path
-      ancestor="$commit"
+      ancestor=$commit
 
       o "Check for rebase"
       if git:rev-exists "$refs_subrepo_fetch"; then
@@ -745,30 +813,33 @@ subrepo:branch() {
       fi
 
       o "Find parents"
-      local first_parent=
-      [[ -n $prev_commit ]] && first_parent="-p $prev_commit"
-      local second_parent=
-      if [[ -z "$first_gitrepo_commit" ]]; then
-        first_gitrepo_commit="$gitrepo_commit"
-        second_parent="-p $gitrepo_commit"
+      local first_parent second_parent
+      first_parent=()
+      [[ $prev_commit ]] && first_parent=(-p "$prev_commit")
+      second_parent=()
+      if [[ -z $first_gitrepo_commit ]]; then
+        first_gitrepo_commit=$gitrepo_commit
+        second_parent=(-p "$gitrepo_commit")
       fi
 
-      if [[ "$join_method" != "rebase" ]]; then
+      if [[ $join_method != rebase ]]; then
         # In the rebase case we don't create merge commits
-        if [[ "$gitrepo_commit" != "$last_gitrepo_commit" ]]; then
-          second_parent="-p $gitrepo_commit"
-          last_gitrepo_commit="$gitrepo_commit"
+        if [[ $gitrepo_commit != "$last_gitrepo_commit" ]]; then
+          second_parent=(-p "$gitrepo_commit")
+          last_gitrepo_commit=$gitrepo_commit
         fi
       fi
 
-      o "Create a new commit $first_parent $second_parent"
+      o "Create a new commit ${first_parent[*]} ${second_parent[*]}"
       FAIL=false RUN git cat-file -e "$commit":"$subdir"
       if OK; then
         o "Create with content"
         local PREVIOUS_IFS=$IFS
         IFS=$'\n'
-        local author_info=( $(git log -1 --date=default --format=%ad%n%ae%n%an "$commit") )
-        local commiter_info=( $(git log -1 --date=default --format=%cd%n%ce%n%cn "$commit") )
+        local author_info
+        mapfile -t author_info < <(git log -1 --date=default --format=%ad%n%ae%n%an "$commit")
+        local commiter_info
+        mapfile -t commiter_info < <(git log -1 --date=default --format=%cd%n%ce%n%cn "$commit")
         IFS=$PREVIOUS_IFS
 
         # When we create new commits we leave the author information unchanged
@@ -777,17 +848,17 @@ subrepo:branch() {
         # to store both the original author but also the responsible committer
         # that created the local version of the commit and pushed it.
         prev_commit=$(git log -n 1 --date=default --format=%B "$commit" |
-          GIT_AUTHOR_DATE="${author_info[0]}" \
-          GIT_AUTHOR_EMAIL="${author_info[1]}" \
-          GIT_AUTHOR_NAME="${author_info[2]}" \
+          GIT_AUTHOR_DATE=${author_info[0]} \
+          GIT_AUTHOR_EMAIL=${author_info[1]} \
+          GIT_AUTHOR_NAME=${author_info[2]} \
           GIT_COMMITTER_DATE="${commiter_info[0]}" \
           GIT_COMMITTER_EMAIL="${commiter_info[1]}" \
           GIT_COMMITTER_NAME="${commiter_info[2]}" \
-          git commit-tree -F - $first_parent $second_parent "$commit":"$subdir")
+          git commit-tree -F - "${first_parent[@]}" "${second_parent[@]}" "$commit":"$subdir")
       else
         o "Create empty placeholder"
         prev_commit=$(git commit-tree -m "EMPTY" \
-          $first_parent $second_parent "4b825dc642cb6eb9a060e54bf8d69288fbee4904")
+          "${first_parent[*]}" "${second_parent[*]}" "4b825dc642cb6eb9a060e54bf8d69288fbee4904")
       fi
     done
 
@@ -801,8 +872,8 @@ subrepo:branch() {
   fi
 
   o "Remove the .gitrepo file from $first_gitrepo_commit..$branch"
-  local filter="$branch"
-  [[ -n "$first_gitrepo_commit" ]] && filter="$first_gitrepo_commit..$branch"
+  local filter=$branch
+  [[ $first_gitrepo_commit ]] && filter=$first_gitrepo_commit..$branch
   FAIL=false RUN git filter-branch -f --prune-empty --tree-filter \
     "rm -f .gitrepo" "$filter"
 
@@ -819,7 +890,7 @@ subrepo:commit() {
     error "Commit ref '$subrepo_commit_ref' does not exist."
 
   if ! "$force_wanted"; then
-    local upstream="$upstream_head_commit"
+    local upstream=$upstream_head_commit
     o "Make sure '$subrepo_commit_ref' contains the upstream HEAD."
     if ! git:commit-in-rev-list "$upstream" "$subrepo_commit_ref"; then
       error \
@@ -840,29 +911,37 @@ subrepo:commit() {
   RUN git add -f -- "$gitrepo"
 
   local commit_message
-  if [[ -n "$wanted_commit_message" ]]; then
-    commit_message="$wanted_commit_message"
+  if [[ $wanted_commit_message ]]; then
+    commit_message=$wanted_commit_message
   else
-    commit_message="$(get-commit-message)"
+    commit_message=$(get-commit-message)
   fi
 
   local edit_flag=
   $edit_wanted && edit_flag=--edit
 
-  [[ -n $commit_message ]] || commit_message="$(get-commit-message)"
+  [[ $commit_message ]] || commit_message=$(get-commit-message)
 
   local edit_flag=
   $edit_wanted && edit_flag=--edit
 
   o "Commit to the '$original_head_branch' branch."
   if [[ $original_head_commit != none ]]; then
-    RUN git commit $edit_flag -m "$commit_message"
+    if [[ $commit_msg_file ]]; then
+      RUN git commit $edit_flag --file "$commit_msg_file"
+    else
+      RUN git commit $edit_flag -m "$commit_message"
+    fi
   else
     # We had cloned into an empty repo, side effect of prior git reset --mixed
     # command is that subrepo's history is now part of the index. Commit
     # without that history.
     OUT=true RUN git write-tree
-    OUT=true RUN git commit-tree $edit_flag -m "$commit_message" "$output"
+    if [[ $commit_msg_file ]]; then
+      OUT=true RUN git commit-tree $edit_flag --file "$commit_msg_file" "$output"
+    else
+      OUT=true RUN git commit-tree $edit_flag -m "$commit_message" "$output"
+    fi
     RUN git reset --hard "$output"
   fi
 
@@ -901,10 +980,10 @@ subrepo:status() {
       continue
     fi
 
-    refs_subrepo_fetch="refs/subrepo/$subref/fetch"
-    upstream_head_commit="$(
+    refs_subrepo_fetch=refs/subrepo/$subref/fetch
+    upstream_head_commit=$(
       git rev-parse --short "$refs_subrepo_fetch" 2> /dev/null || true
-    )"
+    )
     subrepo_remote=
     subrepo_branch=
 
@@ -921,27 +1000,31 @@ subrepo:status() {
     echo "Git subrepo '$subdir':"
     git:branch-exists "subrepo/$subref" &&
       echo "  Subrepo Branch:  subrepo/$subref"
-    local remote="subrepo/$subref"
+    local remote=subrepo/$subref
     FAIL=false OUT=true RUN git config "remote.$remote.url"
-    [[ -n $output ]] &&
+    [[ $output ]] &&
       echo "  Remote Name:     subrepo/$subref"
     echo "  Remote URL:      $subrepo_remote"
-    [[ -n $upstream_head_commit ]] &&
+    [[ $upstream_head_commit ]] &&
       echo "  Upstream Ref:    $upstream_head_commit"
     echo "  Tracking Branch: $subrepo_branch"
     [[ -z $subrepo_commit ]] ||
-      echo "  Pulled Commit:   $(git rev-parse --short $subrepo_commit)"
-    if [[ -n $subrepo_parent ]]; then
-      echo "  Pull Parent:     $(git rev-parse --short $subrepo_parent)"
+      echo "  Pulled Commit:   $(git rev-parse --short "$subrepo_commit")"
+    if [[ $subrepo_parent ]]; then
+      echo "  Pull Parent:     $(git rev-parse --short "$subrepo_parent")"
     # TODO Remove this eventually:
-    elif [[ -n $subrepo_former ]]; then
-      printf "  Former Commit:   $(git rev-parse --short $subrepo_former)"
+    elif [[ $subrepo_former ]]; then
+      printf "  Former Commit:   %s" "$(git rev-parse --short "$subrepo_former")"
       echo " *** DEPRECATED ***"
     fi
 
     # Grep for directory, branch can be in detached state due to conflicts
-    local _worktree=$(git worktree list | grep "$GIT_TMP/subrepo/$subdir")
-    if [[ -n $_worktree  ]]; then
+    local _worktree
+    _worktree=$(
+      git worktree list |
+        grep "$GIT_TMP/subrepo/$subdir "
+    ) || true
+    if [[ $_worktree  ]]; then
       echo "  Worktree: $_worktree"
     fi
 
@@ -955,9 +1038,9 @@ subrepo:status() {
 
 subrepo:clean() {
   # Remove subrepo branches if exist:
-  local branch="subrepo/$subref"
-  local ref="refs/heads/$branch"
-  local worktree="$GIT_TMP/$branch"
+  local branch=subrepo/$subref
+  local ref=refs/heads/$branch
+  local worktree=$GIT_TMP/$branch
 
   o "Clean $subdir"
   git:remove-worktree
@@ -969,12 +1052,17 @@ subrepo:clean() {
 
   if "$force_wanted"; then
     o "Remove all subrepo refs."
-    local suffix=""
+    local suffix=''
     if ! $all_wanted; then
-      suffix="$subref/"
+      suffix=$subref/
     fi
-    git show-ref | while read hash ref; do
-      if [[ "$ref" == refs/subrepo/$suffix* ]]; then
+    git show-ref | while read -r hash ref; do
+      if [[ $ref == "refs/subrepo/$suffix"* ]]; then
+        git update-ref -d "$ref"
+      fi
+    done
+    git show-ref | while read -r hash ref; do
+      if [[ $ref == "refs/original/refs/heads/subrepo/$suffix"* ]]; then
         git update-ref -d "$ref"
       fi
     done
@@ -994,9 +1082,9 @@ subrepo:clean() {
 get-command-options() {
   [[ $# -eq 0 ]] && set -- --help
 
-  [[ -n $GIT_SUBREPO_QUIET ]] && quiet_wanted=true
-  [[ -n $GIT_SUBREPO_VERBOSE ]] && verbose_wanted=true
-  [[ -n $GIT_SUBREPO_DEBUG ]] && debug_wanted=true
+  [[ ${GIT_SUBREPO_QUIET-} ]] && quiet_wanted=true
+  [[ ${GIT_SUBREPO_VERBOSE-} ]] && verbose_wanted=true
+  [[ ${GIT_SUBREPO_DEBUG-} ]] && debug_wanted=true
 
   eval "$(
     echo "$GETOPT_SPEC" |
@@ -1005,28 +1093,30 @@ get-command-options() {
   )"
 
   while [[ $# -gt 0 ]]; do
-    local option="$1"; shift
+    local option=$1; shift
     case "$option" in
       --) break ;;
       -a) all_wanted=true ;;
       -A) ALL_wanted=true
           all_wanted=true ;;
-      -b) subrepo_branch="$1"
-          override_branch="$1"
+      -b) subrepo_branch=$1
+          override_branch=$1
           commit_msg_args+=("--branch=$1")
           shift ;;
       -e) edit_wanted=true ;;
       -f) force_wanted=true
           commit_msg_args+=("--force") ;;
       -F) fetch_wanted=true ;;
-      -m) wanted_commit_message="$1"
-          shift;;
-      -M) join_method="$1"
+      -m)
+          if [[ $commit_msg_file ]]; then
+            error "fatal: options '-m' and '--file' cannot be used together"
+          fi
+          wanted_commit_message=$1
           shift;;
-      -M) join_method="$1"
+      -M) join_method=$1
           shift;;
-      -r) subrepo_remote="$1"
-          override_remote="$1"
+      -r) subrepo_remote=$1
+          override_remote=$1
           commit_msg_args+=("--remote=$1")
           shift ;;
       -s) squash_wanted=true ;;
@@ -1036,6 +1126,16 @@ get-command-options() {
       -v) verbose_wanted=true ;;
       -d) debug_wanted=true ;;
       -x) set -x ;;
+      --file)
+        if [[ $wanted_commit_message ]]; then
+          error "fatal: options '-m' and '--file' cannot be used together"
+        fi
+        if [ -f "$1" ]; then
+          commit_msg_file="$1"
+        else
+          error "Commit msg file at $1 not found"
+        fi
+        shift ;;
       --version)
         echo "$VERSION"
         exit ;;
@@ -1044,34 +1144,34 @@ get-command-options() {
   done
 
   # Set subrepo command:
-  command="$1"; shift
+  command=$1; shift
 
   # Make sure command exists:
   can "command:$command" ||
     usage-error "'$command' is not a command. See 'git subrepo help'."
 
   command_arguments=("$@")
-  if [[ ${#command_arguments} -gt 0 ]]; then
-    local first="${command_arguments[0]}"
-    first="${first%/}"
-    command_arguments[0]="$first"
+  if [[ ${command_arguments[*]-} && ${#command_arguments[@]} -gt 0 ]]; then
+    local first=${command_arguments[0]}
+    first=${first%/}
+    command_arguments[0]=$first
   fi
   commit_msg_args+=("${command_arguments[@]}")
 
   for option in all ALL edit fetch force squash; do
-    var="${option}_wanted"
+    var=${option}_wanted
     if ${!var}; then
       check_option $option
     fi
   done
 
-  if [[ -n $override_branch ]]; then
+  if [[ $override_branch ]]; then
     check_option branch
   fi
-  if [[ -n $override_remote ]]; then
+  if [[ $override_remote ]]; then
     check_option remote
   fi
-  if [[ -n $wanted_commit_message ]]; then
+  if [[ $wanted_commit_message || $commit_msg_file ]]; then
     check_option message
   fi
   if $update_wanted; then
@@ -1088,13 +1188,13 @@ options_clean='ALL all force'
 options_clone='branch edit force message method'
 options_config='force'
 options_commit='edit fetch force message'
-options_fetch='all branch remote'
+options_fetch='all branch force remote'
 options_init='branch remote method'
 options_pull='all branch edit force message remote update'
-options_push='all branch force remote squash update'
+options_push='all branch force message remote squash update'
 options_status='ALL all fetch'
 check_option() {
-  local var="options_${command//-/_}"
+  local var=options_${command//-/_}
   [[ ${!var} =~ $1 ]] ||
     usage-error "Invalid option '--$1' for '$command'."
 }
@@ -1107,8 +1207,8 @@ command-init() {
   # Export variable to let other processes (possibly git hooks) know that they
   # are running under git-subrepo. Set to current process pid, so it can be
   # further verified if need be:
-  export GIT_SUBREPO_RUNNING="$$"
-  export GIT_SUBREPO_COMMAND="$command"
+  export GIT_SUBREPO_RUNNING=$$
+  export GIT_SUBREPO_COMMAND=$command
 
   : "${GIT_SUBREPO_PAGER:=${PAGER:-less}}"
   if [[ $GIT_SUBREPO_PAGER == less ]]; then
@@ -1121,7 +1221,7 @@ command-prepare() {
   if git:rev-exists HEAD; then
     git:get-head-branch-commit
   fi
-  original_head_commit="${output:-none}"
+  original_head_commit=${output:-none}
 }
 
 # Do the setup steps needed by most of the subrepo subcommands:
@@ -1130,14 +1230,19 @@ command-setup() {
 
   check-and-normalize-subdir
   encode-subdir
-  gitrepo="$subdir/.gitrepo"
+  gitrepo=$subdir/.gitrepo
 
   if ! $force_wanted; then
     o "Check for worktree with branch subrepo/$subdir"
-    local _worktree=$(git worktree list | grep "\[subrepo/$subdir\]" | cut -d ' ' -f1)
+    local _worktree
+    _worktree=$(
+      git worktree list |
+        grep "\[subrepo/$subdir\]" |
+        cut -d ' ' -f1
+    ) || true
     if [[ $command =~ ^(commit)$ && -z $_worktree ]]; then
       error "There is no worktree available, use the branch command first"
-    elif [[ ! $command =~ ^(branch|clean|commit|push)$ && -n $_worktree ]]; then
+    elif [[ ! $command =~ ^(branch|clean|commit|push)$ && $_worktree ]]; then
       if [[ -e $gitrepo ]]; then
         error "There is already a worktree with branch subrepo/$subdir.
 Use the --force flag to override this check or perform a subrepo clean
@@ -1153,10 +1258,10 @@ Use the --force flag to override this check or remove the worktree with
   fi
 
   # Set refs_ variables:
-  refs_subrepo_branch="refs/subrepo/$subref/branch"
-  refs_subrepo_commit="refs/subrepo/$subref/commit"
-  refs_subrepo_fetch="refs/subrepo/$subref/fetch"
-  refs_subrepo_push="refs/subrepo/$subref/push"
+  refs_subrepo_branch=refs/subrepo/$subref/branch
+  refs_subrepo_commit=refs/subrepo/$subref/commit
+  refs_subrepo_fetch=refs/subrepo/$subref/fetch
+  refs_subrepo_push=refs/subrepo/$subref/push
 
   # Read/parse the .gitrepo file (unless clone/init; doesn't exist yet)
   if [[ ! $command =~ ^(clone|init)$ ]]; then
@@ -1167,33 +1272,34 @@ Use the --force flag to override this check or remove the worktree with
 }
 
 # Parse command line args according to a simple dsl spec:
+# shellcheck disable=2059
 get-params() {
   local i=0
   local num=${#command_arguments[@]}
-  for arg in $@; do
-    local value="${command_arguments[i]}"
-    value="${value//%/%%}"
-    value="${value//\\/\\\\}"
+  for arg in "$@"; do
+    local value=${command_arguments[i]-}
+    value=${value//%/%%}
+    value=${value//\\/\\\\}
     # If arg starts with '+' then it is required
     if [[ $arg == +* ]]; then
       if [[ $i -ge $num ]]; then
         usage-error "Command '$command' requires arg '${arg#+}'."
       fi
-      printf -v ${arg#+} -- "$value"
+      printf -v "${arg#+}" -- "$value"
     # Look for function name after ':' to provide a default value
     else
       if [[ $i -lt $num ]]; then
-        printf -v ${arg%:*} -- "$value"
+        printf -v "${arg%:*}" -- "$value"
       elif [[ $arg =~ : ]]; then
         "${arg#*:}"
       fi
     fi
-    let i=$((i+1))
+    : $((i++))
   done
 
   # Check for extra arguments:
   if [[ $num -gt $i ]]; then
-    set -- ${command_arguments[@]}
+    set -- "${command_arguments[@]}"
     for ((j = 1; j <= i; j++)); do shift; done
     error "Unknown argument(s) '$*' for '$command' command."
   fi
@@ -1201,24 +1307,24 @@ get-params() {
 
 check-and-normalize-subdir() {
   # Sanity check subdir:
-  [[ -n $subdir ]] ||
+  [[ $subdir ]] ||
     die "subdir not set"
   [[ $subdir =~ ^/ || $subdir =~ ^[A-Z]: ]] &&
     usage-error "The subdir '$subdir' should not be absolute path."
-  subdir="${subdir#./}"
-  subdir="${subdir%/}"
+  subdir=${subdir#./}
+  subdir=${subdir%/}
   [[ $subdir != *//* ]] || subdir=$(tr -s / <<< "$subdir")
 }
 
 # Determine the correct subdir path to use:
 guess-subdir() {
-  local dir="$subrepo_remote"
-  dir="${dir%.git}"
-  dir="${dir%/}"
-  dir="${dir##*/}"
+  local dir=$subrepo_remote
+  dir=${dir%.git}
+  dir=${dir%/}
+  dir=${dir##*/}
   [[ $dir =~ ^[-_a-zA-Z0-9]+$ ]] ||
     error "Can't determine subdir from '$subrepo_remote'."
-  subdir="$dir"
+  subdir=$dir
   check-and-normalize-subdir
   encode-subdir
 }
@@ -1265,7 +1371,8 @@ encode-subdir() {
   local i
   for (( i = 1; i < 32; ++i )); do
     # skip substitute NUL char (i=0), as bash will skip NUL in env
-    local x=$(printf "%02x" $i)
+    local x
+    x=$(printf "%02x" "$i")
     subref=${subref//$(printf "%b" "\x$x")/%$x}
   done
   subref=${subref//$'\177'/%7f}
@@ -1309,7 +1416,7 @@ encode-subdir() {
 
 # Set subdir and gitrepo vars:
 read-gitrepo-file() {
-  gitrepo="$subdir/.gitrepo"
+  gitrepo=$subdir/.gitrepo
 
   if [[ ! -f $gitrepo ]]; then
     error "No '$gitrepo' file."
@@ -1318,34 +1425,34 @@ read-gitrepo-file() {
   # Read .gitrepo values:
   if [[ -z $subrepo_remote ]]; then
     SAY=false OUT=true RUN git config --file="$gitrepo" subrepo.remote
-    subrepo_remote="$output"
+    subrepo_remote=$output
   fi
 
   if [[ -z $subrepo_branch ]]; then
     SAY=false OUT=true RUN git config --file="$gitrepo" subrepo.branch
-    subrepo_branch="$output"
+    subrepo_branch=$output
   fi
 
   SAY=false OUT=true RUN git config --file="$gitrepo" subrepo.commit
-  subrepo_commit="$output"
+  subrepo_commit=$output
 
   FAIL=false \
   SAY=false OUT=true RUN git config --file="$gitrepo" subrepo.parent
-  subrepo_parent="$output"
+  subrepo_parent=$output
 
   FAIL=false \
   SAY=false OUT=true RUN git config --file="$gitrepo" subrepo.method
-  if [[ $output == "rebase" ]]; then
-    join_method="rebase"
+  if [[ $output == rebase ]]; then
+    join_method=rebase
   else
     # This is the default method
-    join_method="merge"
+    join_method=merge
   fi
 
   if [[ -z $subrepo_parent ]]; then
     FAIL=false \
       SAY=false OUT=true RUN git config --file="$gitrepo" subrepo.former
-    subrepo_former="$output"
+    subrepo_former=$output
   fi
 }
 
@@ -1368,7 +1475,7 @@ update-gitrepo-file() {
 ; DO NOT EDIT (unless you know what you are doing)
 ;
 ; This subdirectory is a git "subrepo", and this file is maintained by the
-; git-subrepo command. See https://github.com/git-commands/git-subrepo#readme
+; git-subrepo command. See https://github.com/ingydotnet/git-subrepo#readme
 ;
 ...
     fi
@@ -1376,25 +1483,25 @@ update-gitrepo-file() {
 
 
   # TODO: only update remote and branch if supplied and $update_wanted
-  if $newfile || [[ $update_wanted && -n $override_remote ]]; then
+  if $newfile || [[ $update_wanted && $override_remote ]]; then
     RUN git config --file="$gitrepo" subrepo.remote "$subrepo_remote"
   fi
 
-  if $newfile || [[ $update_wanted && -n $override_branch ]]; then
+  if $newfile || [[ $update_wanted && $override_branch ]]; then
     RUN git config --file="$gitrepo" subrepo.branch "$subrepo_branch"
   fi
 
   RUN git config --file="$gitrepo" subrepo.commit "$upstream_head_commit"
   # Only write new parent when we are at the head of upstream
-  if [[ -n $upstream_head_commit && -n $subrepo_commit_ref ]]; then
+  if [[ $upstream_head_commit && $subrepo_commit_ref ]]; then
     OUT=true RUN git rev-parse "$subrepo_commit_ref"
     o "$upstream_head_commit == $output"
-    if [[ $upstream_head_commit == $output ]]; then
+    if [[ $upstream_head_commit == "$output" ]]; then
       RUN git config --file="$gitrepo" subrepo.parent "$original_head_commit"
     fi
   fi
 
-  [[ -z $join_method ]] && join_method="merge"
+  [[ -z $join_method ]] && join_method=merge
   RUN git config --file="$gitrepo" subrepo.method "$join_method"
 
   RUN git config --file="$gitrepo" subrepo.cmdver "$VERSION"
@@ -1413,16 +1520,20 @@ assert-environment-ok() {
 
   git_version=$(git --version | cut -d ' ' -f3)
 
-  if [[ $(
-          printf "$REQUIRED_GIT_VERSION\n$git_version" |
-          sort -t. -k 1,1n -k 2,2n -k 3,3n |
-          head -n1
-        ) == "$git_version" &&
-       $git_version != "$REQUIRED_GIT_VERSION"
-  ]]; then
+  version-check bash "$REQUIRED_BASH_VERSION" || {
+    echo "The 'bashplus' library requires that 'Bash ${REQUIRED_BASH_VERSION}+' is installed." >&2
+    echo "It doesn't need to be your shell, but it must be in your PATH." >&2
+    if [[ ${OSTYPE-} == darwin* ]]; then
+      echo "You appear to be on macOS." >&2
+      echo "Try: 'brew install bash'." >&2
+      echo "This will not change your user shell, it just installs 'Bash 5.x'." >&2
+    fi
+    exit 1
+  }
+
+  version-check git "$REQUIRED_GIT_VERSION" ||
     error "Requires git version $REQUIRED_GIT_VERSION or higher; "`
          `"you have '$git_version'."
-  fi
 
   if [[ ${BASH_VERSINFO[0]} -lt 4 ]] ; then
     echo "The git-subrepo command requires that 'Bash 4+' is installed."
@@ -1447,7 +1558,7 @@ assert-repo-is-ready() {
 
   # Get the original branch and commit:
   git:get-head-branch-name
-  original_head_branch="$output"
+  original_head_branch=$output
 
   # If a subrepo branch is currently checked out, then note it:
   if [[ $original_head_branch =~ ^subrepo/(.*) ]]; then
@@ -1470,7 +1581,7 @@ assert-repo-is-ready() {
   assert-working-copy-is-clean
 
   # For now, only support actions from top of repo:
-  if [[ -n "$(git rev-parse --show-prefix)" ]]; then
+  if [[ $(git rev-parse --show-prefix) ]]; then
     error "Need to run subrepo command from top level directory of the repo."
   fi
 }
@@ -1479,7 +1590,8 @@ assert-working-copy-is-clean() {
   # Repo is in a clean state:
   if [[ $command =~ ^(clone|init|pull|push|branch|commit)$ ]]; then
     # TODO: Should we check for untracked files?
-    local pwd=$(pwd)
+    local pwd
+    pwd=$(pwd)
     o "Assert that working copy is clean: $pwd"
     git update-index -q --ignore-submodules --refresh
     git diff-files --quiet --ignore-submodules ||
@@ -1507,14 +1619,14 @@ assert-subdir-ready-for-init() {
     error "The subdir '$subdir' is already a subrepo."
   fi
   # Check that subdir is part of the repo
-  if [[ -z $(git log -1 --date=default -- $subdir) ]]; then
+  if [[ -z $(git log -1 --date=default -- "$subdir") ]]; then
     error "The subdir '$subdir' is not part of this repo."
   fi
 }
 
 # If subdir exists, make sure it is empty:
 assert-subdir-empty() {
-  if [[ -e $subdir ]] && [[ -n $(ls -A $subdir) ]]; then
+  if [[ -e $subdir ]] && [[ $(ls -A "$subdir") ]]; then
     error "The subdir '$subdir' exists and is not empty."
   fi
 }
@@ -1526,7 +1638,8 @@ assert-subdir-empty() {
 # Find all the current subrepos by looking for all the subdirectories that
 # contain a `.gitrepo` file.
 get-all-subrepos() {
-  local paths=($(git ls-files | sed -n 's!/\.gitrepo$!!p' | sort))
+  local paths
+  mapfile -t paths < <(git ls-files | sed -n 's!/\.gitrepo$!!p' | sort)
   subrepos=()
   local path
   for path in "${paths[@]}"; do
@@ -1545,31 +1658,28 @@ add-subrepo() {
 
 # Determine the upstream's default head branch:
 get-upstream-head-branch() {
-  OUT=true RUN git ls-remote $subrepo_remote
-  local remotes="$output"
-  [[ -n $remotes ]] ||
-    error "Failed to 'git ls-remote $subrepo_remote'."
-  local commit="$(
-    echo "$remotes" |
-    grep HEAD |
-    cut -f1
-  )"
-  local branch="$(
+  local remotes branch
+  OUT=true RUN git ls-remote --symref "$subrepo_remote"
+  remotes=$output
+  [[ $remotes ]] ||
+    error "Failed to 'git ls-remote --symref $subrepo_remote'."
+
+  # 'ref: refs/heads/master  HEAD'
+  branch=$(
     echo "$remotes" |
-    grep -E "$commit[[:space:]]+refs/heads/" |
-    grep -v HEAD |
-    head -n1 |
-    cut -f2
-  )"
+    grep "^ref:" | grep 'HEAD$' | cut -f2 -d':' | cut -f1 |
+    head -n1
+  )
+  branch=${branch/ }
   [[ $branch =~ refs/heads/ ]] ||
     error "Problem finding remote default head branch."
-  output="${branch#refs/heads/}"
+  output=${branch#refs/heads/}
 }
 
 # Commit msg for an action commit:
 # Don't use RUN here as it will pollute commit message
 get-commit-message() {
-  local commit="none"
+  local commit=none
   if git:rev-exists "$upstream_head_commit"; then
     commit=$(git rev-parse --short "$upstream_head_commit")
   fi
@@ -1578,19 +1688,19 @@ get-commit-message() {
   if $all_wanted; then
     args+=("$subdir")
   fi
-  args+=(${commit_msg_args[@]})
+  args+=("${commit_msg_args[@]}")
 
   # Find the specific git-subrepo code used:
   local command_remote='???'
   local command_commit='???'
   get-command-info
 
-  local merged="none"
+  local merged=none
   if git:rev-exists "$subrepo_commit_ref"; then
     merged=$(git rev-parse --short "$subrepo_commit_ref")
   fi
 
-  local is_merge=""
+  local is_merge=''
   if [[ $command != push ]]; then
     if git:is_merge_commit "$subrepo_commit_ref"; then
       is_merge=" (merge)"
@@ -1601,7 +1711,7 @@ get-commit-message() {
 
   # Format subrepo commit message:
   cat <<...
-git subrepo $command$is_merge ${args[@]}
+git subrepo $command$is_merge ${args[*]}
 
 subrepo:
   subdir:   "$subdir"
@@ -1621,9 +1731,10 @@ git-subrepo:
 # info goes into commit messages, so we can find out exactly how the commits
 # were done.
 get-command-info() {
-  local bin="$0"
+  local bin=$0
   if [[ $bin =~ / ]]; then
-    local lib="$(dirname "$bin")"
+    local lib
+    lib=$(dirname "$bin")
     # XXX Makefile needs to install these symlinks:
     # If `git-subrepo` was system-installed (`make install`):
     if [[ -e $lib/git-subrepo.d/upstream ]] &&
@@ -1631,31 +1742,34 @@ get-command-info() {
       command_remote=$(readlink "$lib/git-subrepo.d/upstream")
       command_commit=$(readlink "$lib/git-subrepo.d/commit")
     elif [[ $lib =~ / ]]; then
-      lib="$(dirname "$lib")"
+      lib=$(dirname "$lib")
       if [[ -d $lib/.git ]]; then
-        local remote="$(
+        local remote
+        remote=$(
           GIT_DIR=$lib/.git git remote -v |
             grep '^origin' |
             head -n1 |
             cut -f2 |
             cut -d ' ' -f1
-        )"
-        if [[ -n $remote ]]; then
-          command_remote="$remote"
+        )
+        if [[ $remote ]]; then
+          command_remote=$remote
         else
-          local remote="$(
+          local remote
+          remote=$(
             GIT_DIR=$lib/.git git remote -v |
               head -n1 |
               cut -f2 |
               cut -d ' ' -f1
-          )"
-          if [[ -n $remote ]]; then
-            command_remote="$remote"
+          )
+          if [[ $remote ]]; then
+            command_remote=$remote
           fi
         fi
-        local commit="$(GIT_DIR="$lib/.git" git rev-parse --short HEAD)"
-        if [[ -n $commit ]]; then
-          command_commit="$commit"
+        local commit
+        commit=$(GIT_DIR=$lib/.git git rev-parse --short HEAD)
+        if [[ $commit ]]; then
+          command_commit=$commit
         fi
       fi
     fi
@@ -1680,7 +1794,7 @@ This is the common conflict resolution workflow:
   3. "git add" the resolved files.
 ...
 
-  if [[ "$join_method" == "rebase" ]]; then
+  if [[ $join_method == rebase ]]; then
     cat <<...
   4. git rebase --continue
 ...
@@ -1694,8 +1808,8 @@ This is the common conflict resolution workflow:
   5. If there are more conflicts, restart at step 2.
   6. cd $start_pwd
 ...
-  local branch_name="${branch:=subrepo/$subdir}"
-  if [[ "$command" == "push" ]]; then
+  local branch_name=${branch:=subrepo/$subdir}
+  if [[ $command == push ]]; then
     cat <<...
   7. git subrepo push $subdir $branch_name
 ...
@@ -1705,7 +1819,7 @@ This is the common conflict resolution workflow:
 ...
   fi
 
-  if [[ "$command" == "pull" && "$join_method" == "rebase" ]]; then
+  if [[ $command == pull && $join_method == rebase ]]; then
     cat <<...
 
 After you have performed the steps above you can push your local changes
@@ -1740,46 +1854,48 @@ git:rev-exists() {
 }
 
 git:ref-exists() {
-  test -n "$(git for-each-ref "$1")"
+  [[ $(git for-each-ref "$1") ]]
 }
 
 git:get-head-branch-name() {
   output=
-  local name="$(git symbolic-ref --short --quiet HEAD)"
+  local name
+  name=$(git symbolic-ref --short --quiet HEAD) || true
   [[ $name == HEAD ]] && return
-  output="$name"
+  output=$name
 }
 
 git:get-head-branch-commit() {
-  output="$(git rev-parse HEAD)"
+  output=$(git rev-parse HEAD)
 }
 
 git:commit-in-rev-list() {
-  local commit="$1"
-  local list_head="$2"
+  local commit=$1
+  local list_head=$2
   git rev-list "$list_head" | grep -q "^$commit"
 }
 
 git:make-ref() {
-  local ref_name="$1"
-  local commit="$(git rev-parse "$2")"
+  local ref_name=$1
+  local commit
+  commit=$(git rev-parse "$2")
   RUN git update-ref "$ref_name" "$commit"
 }
 
 git:is_merge_commit() {
-  local commit="$1"
+  local commit=$1
   git show --summary "$commit" | grep -q ^Merge:
 }
 
 git:create-worktree() {
-  local branch="$1"
-  worktree="$GIT_TMP/$branch"
+  local branch=$1
+  worktree=$GIT_TMP/$branch
   RUN git worktree add "$worktree" "$branch"
 }
 
 git:remove-worktree() {
   o "Remove worktree: $worktree"
-  if [[ -d "$worktree" ]]; then
+  if [[ -d $worktree ]]; then
     o "Check worktree for unsaved changes"
     cd "$worktree"
     assert-working-copy-is-clean
@@ -1792,7 +1908,7 @@ git:remove-worktree() {
 }
 
 git:delete-branch() {
-  local branch="$1"
+  local branch=$1
   o "Deleting old '$branch' branch."
   # Remove worktree first, otherwise you can't delete the branch
   git:remove-worktree
@@ -1806,7 +1922,7 @@ git:delete-branch() {
 
 # Smart command runner:
 RUN() {
-  $debug_wanted && $SAY && say '>>>' $*
+  $debug_wanted && $SAY && say ">>> $*"
   if $EXEC; then
     "$@"
     return $?
@@ -1820,9 +1936,9 @@ RUN() {
     "$@"
   else
     if $OUT; then
-      out="$("$@" 2>/dev/null)"
+      out=$("$@" 2>/dev/null)
     else
-      out="$("$@" 2>&1)"
+      out=$("$@" 2>&1)
     fi
   fi
   rc=$?
@@ -1832,7 +1948,7 @@ RUN() {
     OK=false
     $FAIL && error "Command failed: '$*'.\n$out"
   fi
-  output="$out"
+  output=$out
 }
 
 
@@ -1853,7 +1969,7 @@ CALL() {
 # Print verbose steps for commands with steps:
 o() {
   if $verbose_wanted; then
-    echo "$INDENT* $@"
+    echo "$INDENT* $*"
   fi
 }
 
@@ -1887,13 +2003,12 @@ usage-error() {
 
 # Nicely report common error messages:
 error() {
-  local msg="git-subrepo: $1" usage=
-  echo -e "$msg" >&2
+  echo -e "git-subrepo:" "$@" >&2
   exit 1
 }
 
 # Start at the end:
-[[ $BASH_SOURCE != "$0" ]] || main "$@"
+[[ ${BASH_SOURCE[0]} != "$0" ]] || main "$@"
 
 # Local Variables:
 # tab-width: 2