aboutsummaryrefslogtreecommitdiff
path: root/dot_local
diff options
context:
space:
mode:
authorRyan Kavanagh <rak@rak.ac>2021-12-13 17:10:32 -0500
committerRyan Kavanagh <rak@rak.ac>2021-12-13 17:10:32 -0500
commit200c3638566c69c0bc0b48b9af38b101887371d7 (patch)
tree83a6882588f44cf64aeae486e4c796e7fad488dd /dot_local
parentdrop cruft (diff)
more moves
Diffstat (limited to 'dot_local')
-rwxr-xr-xdot_local/lib/git-core/git-subrepo1897
1 files changed, 1897 insertions, 0 deletions
diff --git a/dot_local/lib/git-core/git-subrepo b/dot_local/lib/git-core/git-subrepo
new file mode 100755
index 0000000..3865570
--- /dev/null
+++ b/dot_local/lib/git-core/git-subrepo
@@ -0,0 +1,1897 @@
+#!/usr/bin/env bash
+#
+#
+# Copyright 2013-2020 - Ingy döt Net <ingy@ingy.net>
+#
+
+
+# Exit on any errors:
+set -e
+
+# Import Bash+ helper functions:
+SOURCE="$BASH_SOURCE"
+while [[ -h $SOURCE ]]; do
+ DIR="$( cd -P "$( dirname "$SOURCE" )" && pwd )"
+ SOURCE="$(readlink "$SOURCE")"
+ [[ $SOURCE != /* ]] && SOURCE="$DIR/$SOURCE"
+done
+SOURCE_DIR="$(dirname "$SOURCE")"
+
+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
+
+VERSION=0.4.1
+REQUIRED_GIT_VERSION=2.7.0
+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="\
+git subrepo <command> <arguments> <options>
+
+Commands:
+ clone Clone a remote repository into a local subdirectory
+ init Turn a current subdirectory into a subrepo
+ pull Pull upstream changes to the subrepo
+ push Push local subrepo changes upstream
+
+ fetch Fetch a subrepo's remote branch (and create a ref for it)
+ branch Create a branch containing the local subrepo commits
+ commit Commit a merged subrepo branch into the mainline
+
+ status Get status of a subrepo (or all of them)
+ clean Remove branches, remotes and refs for a subrepo
+ config Set subrepo configuration properties
+
+ help Documentation for git-subrepo (or specific command)
+ version Display git-subrepo version info
+ upgrade Upgrade the git-subrepo software itself
+
+See 'git help subrepo' for complete documentation and usage of each command.
+
+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,message= Specify a commit message
+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
+x,DEBUG Turn on -x Bash debugging
+"
+
+#------------------------------------------------------------------------------
+# Top level function:
+#------------------------------------------------------------------------------
+main() {
+ # Define global variables:
+ local command= # Subrepo subcommand to run
+ local command_arguments=() # Command args after getopt parsing
+ local commit_msg_args=() # Arguments to show in the commit msg
+ local subrepos=() # List of multiple subrepos
+
+ local all_wanted=false # Apply command to all subrepos
+ local ALL_wanted=false # Apply command to all subrepos and subsubrepos
+ local force_wanted=false # Force certain operations
+ local fetch_wanted=false # Fetch requested before a command
+ local squash_wanted=false # Squash commits on push
+ local update_wanted=false # Update .gitrepo with --branch and/or --remote
+
+ local quiet_wanted=false # Output should be quiet
+ local verbose_wanted=false # Output should be verbose
+ local debug_wanted=false # Show debug messages
+
+ local subdir= # Subdirectory of the subrepo being used
+ 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 original_head_commit= # HEAD commit id at start of command
+ local original_head_branch= # HEAD ref at start of command
+ local upstream_head_commit= # HEAD commit id from a subrepo fetch
+
+ local subrepo_remote= # Remote url for subrepo's upstream repo
+ local subrepo_branch= # Upstream branch to clone/push/pull
+ local subrepo_commit= # Upstream HEAD from previous clone/pull
+ local subrepo_parent= # Local commit from before previous clone/pull
+ local subrepo_former= # A retired gitrepo key that might still exist
+
+ local refs_subrepo_branch= # A subrepo ref -> commit of branch/pull command
+ local refs_subrepo_commit= # A subrepo ref -> commit last merged
+ local refs_subrepo_fetch= # A subrepo ref -> FETCH_HEAD after fetch
+ local refs_subrepo_push= # A subrepo ref -> branch after push
+
+ local override_remote= # Remote specified with -r
+ local override_branch= # Remote specified with -b
+
+ local edit_wanted=false # Edit commit message using -e
+ local wanted_commit_message= # Custom commit message using -m
+
+ local join_method= # Current join method (rebase/merge)
+
+ local FAIL=true # Flag for RUN: fail on error
+ local OUT=false # Flag for RUN: put output in $output
+ local TTY=false # Flag for RUN: print output directly
+ local SAY=true # Flag for RUN: print command for verbose
+ local EXEC=false # Flag for RUN: run subprocess
+ local OK=true # Flag that commands have succeeded
+ local CODE=0 # Failure reason code
+ local INDENT= # Verbose indentation
+
+ local git_version= # Git version in use
+
+ # Check environment and parse CLI options:
+ assert-environment-ok
+
+ # Parse and validate command options:
+ get-command-options "$@"
+
+ # Make sure repo is in the proper state:
+ assert-repo-is-ready
+
+ command-init
+
+ if $all_wanted && [[ ! $command =~ ^(help|status)$ ]]; then
+ # Run the command on all subrepos
+ local args=( "${command_arguments[@]}" )
+ get-all-subrepos
+ for subdir in ${subrepos[*]}; do
+ command-prepare
+ subrepo_remote=
+ subrepo_branch=
+ command_arguments=( "$subdir" "${args[@]}" )
+ "command:$command"
+ done
+ else
+ # Run the command on a specific subrepo
+ command-prepare
+ "command:$command"
+ fi
+}
+
+#------------------------------------------------------------------------------
+# API command functions.
+#
+# Most of these commands call a subrepo:$command function to do the actual
+# work. The user facing output (via `say`) is done up here. The
+# subrepo:* worker functions are meant to be called internally and don't print
+# info to the user.
+#------------------------------------------------------------------------------
+
+# `git subrepo clone <url> [<subdir>]` command:
+command:clone() {
+ command-setup +subrepo_remote subdir:guess-subdir
+
+ # Clone (or reclone) the subrepo into the subdir:
+ local reclone_up_to_date=false
+ subrepo:clone
+ if "$reclone_up_to_date"; then
+ say "Subrepo '$subdir' is up to date."
+ return
+ fi
+
+ # Successful command output:
+ local re=
+ $force_wanted && re=re
+ 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}"
+
+ # Init new subrepo from the subdir:
+ subrepo:init
+ if OK; then
+ if [[ $remote == none ]]; then
+ say "Subrepo created from '$subdir' (with no remote)."
+ else
+ say "Subrepo created from '$subdir' with remote '$remote' ($branch)."
+ fi
+ else
+ die "Unknown init error code: '$CODE'"
+ fi
+ return 0
+}
+
+# `git subrepo pull <subdir>` command:
+command:pull() {
+ command-setup +subdir
+
+ subrepo:pull
+ if OK; then
+ say "Subrepo '$subdir' pulled from '$subrepo_remote' ($subrepo_branch)."
+ elif [[ $CODE -eq -1 ]]; then
+ say "Subrepo '$subdir' is up to date."
+ elif [[ $CODE -eq 1 ]]; then
+ error-join
+ return "$CODE"
+ else
+ die "Unknown pull error code: '$CODE'"
+ fi
+ return 0
+}
+
+# `git subrepo push <subdir>` command:
+command:push() {
+ local branch=
+ command-setup +subdir branch
+
+ subrepo:push
+ if OK; then
+ say "Subrepo '$subdir' pushed to '$subrepo_remote' ($subrepo_branch)."
+ elif [[ $CODE -eq -2 ]]; then
+ say "Subrepo '$subdir' has no new commits to push."
+ elif [[ $CODE -eq 1 ]]; then
+ error-join
+ return "$CODE"
+ else
+ die "Unknown push error code: '$CODE'"
+ fi
+ return 0
+}
+
+# `git subrepo fetch <subdir>` command
+command:fetch() {
+ command-setup +subdir
+ if [[ $subrepo_remote == "none" ]]; then
+ say "Ignored '$subdir', no remote."
+ else
+ subrepo:fetch
+ say "Fetched '$subdir' from '$subrepo_remote' ($subrepo_branch)."
+ fi
+}
+
+# `git subrepo branch <subdir>` command:
+command:branch() {
+ command-setup +subdir
+ if $fetch_wanted; then
+ CALL subrepo:fetch
+ fi
+
+ local branch="subrepo/$subref"
+ if $force_wanted; then
+ # We must make sure that the worktree is removed as well
+ worktree="$GIT_TMP/$branch"
+ git:delete-branch "$branch"
+ fi
+
+ if git:branch-exists "$branch"; then
+ error "Branch '$branch' already exists. Use '--force' to override."
+ fi
+
+ # Create the subrepo branch:
+ subrepo:branch
+
+ say "Created branch '$branch' and worktree '$worktree'."
+}
+
+# `git subrepo commit <subdir>` command
+command:commit() {
+ command-setup +subdir subrepo_commit_ref
+
+ if "$fetch_wanted"; then
+ CALL subrepo:fetch
+ 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")"
+
+ [[ -n $subrepo_commit_ref ]] ||
+ subrepo_commit_ref="subrepo/$subref"
+ subrepo:commit
+
+ say "Subrepo commit '$subrepo_commit_ref' committed as"
+ say "subdir '$subdir/' to branch '$original_head_branch'."
+}
+
+# `git subrepo status [<subdir>]` command:
+command:status() {
+ subrepo:status | ${GIT_SUBREPO_PAGER}
+}
+
+status-refs() {
+ local output=
+ while read 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"
+ if [[ $type == branch ]]; then
+ output+=" Branch Ref: $sha1 ($ref)"$'\n'
+ elif [[ $type == commit ]]; then
+ output+=" Commit Ref: $sha1 ($ref)"$'\n'
+ elif [[ $type == fetch ]]; then
+ output+=" Fetch Ref: $sha1 ($ref)"$'\n'
+ elif [[ $type == pull ]]; then
+ output+=" Pull Ref: $sha1 ($ref)"$'\n'
+ elif [[ $type == push ]]; then
+ output+=" Push Ref: $sha1 ($ref)"$'\n'
+ fi
+ done < <(git show-ref)
+ if [[ -n $output ]]; then
+ printf " Refs:\n$output"
+ fi
+}
+
+# `git subrepo clean <subdir>` command
+command:clean() {
+ command-setup +subdir
+ local clean_list=()
+ subrepo:clean
+ for item in "${clean_list[@]}"; do
+ say "Removed $item."
+ done
+}
+
+# Wrap git config $gitrepo
+command:config() {
+ command-setup +subdir +config_option config_value
+ 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
+ OUT=true RUN git config --file="$gitrepo" "subrepo.$config_option"
+ say "Subrepo '$subdir' option '$config_option' has value '$output'."
+ return
+ fi
+
+ if ! $force_wanted; then
+ # Only allow changing method without force
+ if [[ ! $config_option == "method" ]]; then
+ error "This option is autogenerated, use '--force' to override."
+ fi
+ fi
+
+ if [[ $config_option == "method" ]]; then
+ if [[ ! $config_value =~ ^(merge|rebase)$ ]]; then
+ error "Not a valid method. Valid options are 'merge' or 'rebase'."
+ fi
+ fi
+
+ RUN git config --file="$gitrepo" "subrepo.$config_option" "$config_value"
+ say "Subrepo '$subdir' option '$config_option' set to '$config_value'."
+}
+
+
+# Launch the manpage viewer:
+command:help() {
+ source "${SOURCE_DIR}/git-subrepo.d/help-functions.bash"
+ local cmd="${command_arguments[0]}"
+ if [[ -n $cmd ]]; then
+ if can "help:$cmd"; then
+ "help:$cmd"
+ echo
+ else
+ err "No help found for '$cmd'"
+ fi
+ elif $all_wanted; then
+ help:all
+ else
+ exec git help subrepo
+ fi
+ msg_ok=0
+}
+
+# Print version info.
+# TODO: Add short commit id after version.
+# Will need to get it from repo or make install can put it somewhere.
+command:version() {
+ cat <<...
+git-subrepo Version: $VERSION
+Copyright 2013-2020 Ingy döt Net
+https://github.com/ingydotnet/git-subrepo
+$BASH_SOURCE
+Git Version: $git_version
+
+...
+ :
+}
+
+command:upgrade() {
+ local path="$0"
+ if [[ $path =~ ^/ && $path =~ ^(.*/git-subrepo)/lib/git-subrepo$ ]]; then
+ 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
+ error "git-subrepo repo is not on the 'master' branch"
+ fi
+
+ o "'git pull' latest version."
+ RUN git pull --ff-only
+
+ say "git-subrepo is up to date."
+ )
+ else
+ die "\
+
+Sorry. Your installation can't use the 'git subrepo upgrade' command. The
+command only works if you installed git subrepo by adding
+'/path/to/git-subrepo' to your PATH.
+
+If you used 'make install' to install git-subrepo, then just do this:
+
+ cd /path/to/git-subrepo
+ git pull
+ make install
+
+"
+ fi
+}
+
+#------------------------------------------------------------------------------
+# Subrepo command worker functions.
+#------------------------------------------------------------------------------
+
+# 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"
+ fi
+
+ # Turn off force unless really a reclone:
+ if $force_wanted && [[ ! -f $gitrepo ]]; then
+ force_wanted=false
+ fi
+
+ if $force_wanted; then
+ o "--force indicates a reclone."
+ CALL subrepo:fetch
+ read-gitrepo-file
+ o "Check if we already are up to date."
+ if [[ $upstream_head_commit == $subrepo_commit ]]; then
+ reclone_up_to_date=true
+ return
+ fi
+ o "Remove the old subdir."
+ RUN git rm -r -- "$subdir"
+ else
+ assert-subdir-empty
+ if [[ -z $subrepo_branch ]]; then
+ o "Determine the upstream head branch."
+ get-upstream-head-branch
+ subrepo_branch="$output"
+ fi
+
+ CALL subrepo:fetch
+ fi
+
+ o "Make the directory '$subdir/' for the clone."
+ RUN mkdir -p -- "$subdir"
+
+ o "Commit the new '$subdir/' content."
+ subrepo_commit_ref="$upstream_head_commit"
+ CALL subrepo:commit
+}
+
+# Init a new subrepo from current repo:
+subrepo:init() {
+ local branch_name="subrepo/${subref:??}"
+ # Check if subdir is proper candidate for this init:
+ assert-subdir-ready-for-init
+
+ o "Put info into '$subdir/.gitrepo' file."
+ update-gitrepo-file
+
+ o "Add the new '$subdir/.gitrepo' file."
+ # -f from pull request #219. TODO needs test.
+ RUN git add -f -- "$gitrepo"
+
+ o "Commit new subrepo to the '$original_head_branch' branch."
+ subrepo_commit_ref="$original_head_commit"
+ RUN git commit -m "$(get-commit-message)"
+
+ o "Create ref '$refs_subrepo_commit'."
+ git:make-ref "$refs_subrepo_commit" "$subrepo_commit_ref"
+}
+
+# Properly merge a local subrepo branch with upstream and commit to mainline:
+subrepo:pull() {
+ CALL subrepo:fetch
+
+ # 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
+ OK=false; CODE=-1; return
+ fi
+
+ local branch_name="subrepo/$subref"
+ git:delete-branch "$branch_name"
+
+ subrepo_commit_ref="$branch_name"
+
+ o "Create subrepo branch '$branch_name'."
+ CALL subrepo:branch
+ cd "$worktree";
+
+ 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
+ say "The \"git rebase\" command failed:"
+ say
+ say " ${output//$'\n'/$'\n' }"
+ CODE=1
+ return
+ fi
+ else
+ o "Merge in changes from $refs_subrepo_fetch"
+ FAIL=false OUT=true RUN git merge "$refs_subrepo_fetch"
+ if ! OK; then
+ say "The \"git merge\" command failed:"
+ say
+ say " ${output//$'\n'/$'\n' }"
+ CODE=1
+ return
+ fi
+ fi
+
+ o "Back to $start_pwd"
+ cd "$start_pwd";
+
+ o "Create ref '$refs_subrepo_branch' for branch '$branch_name'."
+ git:make-ref "$refs_subrepo_branch" "$branch_name"
+
+ o "Commit the new '$subrepo_commit_ref' content."
+ CALL subrepo:commit
+}
+
+# Push a properly merged subrepo branch upstream:
+subrepo:push() {
+ local branch_name="$branch"
+ local new_upstream=false
+ local branch_created=false
+
+ if [[ -z $branch_name ]]; then
+ FAIL=false OUT=false CALL subrepo:fetch
+
+ if ! OK; then
+ # Check if we are pushing to a new upstream repo (or branch) and just
+ # push the commit directly. This is common after a `git subrepo init`:
+ # Force to case in
+ local re="(^|"$'\n'")fatal: couldn't find remote ref "
+ if [[ ${output,,} =~ $re ]]; then
+ o "Pushing to new upstream: $subrepo_remote ($subrepo_branch)."
+ new_upstream=true
+ else
+ error "Fetch for push failed: $output"
+ fi
+ else
+ # 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
+ error "There are new changes upstream, you need to pull first."
+ fi
+ fi
+ fi
+
+ branch_name="subrepo/$subref"
+ git:delete-branch "$branch_name"
+
+ if $squash_wanted; then
+ o "Squash commits"
+ subrepo_parent="HEAD^"
+ fi
+
+ o "Create subrepo branch '$branch_name'."
+ CALL subrepo:branch "$branch_name"
+ cd "$worktree";
+
+ 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
+ say "The \"git rebase\" command failed:"
+ say
+ say " ${output//$'\n'/$'\n' }"
+ CODE=1
+ return
+ fi
+ fi
+ branch_created=true
+ cd "$start_pwd"
+ else
+ if $squash_wanted; then
+ error "Squash option (-s) can't be used with branch parameter"
+ fi
+ fi
+
+ o "Make sure that '$branch_name' exists."
+ git:branch-exists "$branch_name" ||
+ 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")"
+ if ! $new_upstream; then
+ if [[ $upstream_head_commit == $new_upstream_head_commit ]]; then
+ OK=false
+ CODE=-2
+ return
+ fi
+ fi
+
+ if ! $force_wanted; then
+ o "Make sure '$branch_name' contains the '$refs_subrepo_fetch' HEAD."
+ if ! git:commit-in-rev-list "$upstream_head_commit" "$branch_name"; then
+ error "Can't commit: '$branch_name' doesn't contain upstream HEAD: " \
+ "$upstream_head_commit"
+ fi
+ fi
+
+ local force=''
+ "$force_wanted" && force=' --force'
+
+ o "Push$force branch '$branch_name' to '$subrepo_remote' ($subrepo_branch)."
+ RUN git push$force "$subrepo_remote" "$branch_name":"$subrepo_branch"
+
+ o "Create ref '$refs_subrepo_push' for branch '$branch_name'."
+ git:make-ref "$refs_subrepo_push" "$branch_name"
+
+ if $branch_created; then
+ o "Remove branch '$branch_name'."
+ git:delete-branch "$branch_name"
+ fi
+
+ o "Put updates into '$subdir/.gitrepo' file."
+ upstream_head_commit="$new_upstream_head_commit"
+ subrepo_commit_ref="$upstream_head_commit"
+ update-gitrepo-file
+ RUN git commit -m "$(get-commit-message)"
+}
+
+# Fetch the subrepo's remote branch content:
+subrepo:fetch() {
+ if [[ $subrepo_remote == none ]]; then
+ error "Can't fetch subrepo. Remote is 'none' in '$subdir/.gitrepo'."
+ fi
+
+ o "Fetch the upstream: $subrepo_remote ($subrepo_branch)."
+ RUN git fetch --no-tags --quiet "$subrepo_remote" "$subrepo_branch"
+ OK || return
+
+ o "Get the upstream subrepo HEAD commit."
+ OUT=true RUN git rev-parse FETCH_HEAD^0
+ 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
+subrepo:branch() {
+ local branch="${1:-"subrepo/$subref"}"
+ o "Check if the '$branch' branch already exists."
+ git:branch-exists "$branch" && return
+
+ local last_gitrepo_commit=
+ local first_gitrepo_commit=
+
+ o "Subrepo parent: $subrepo_parent"
+ if [[ -n "$subrepo_parent" ]]; then
+ 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"
+ 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
+ o "Ignore commit, no .gitrepo file"
+ continue
+ fi
+
+ 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")
+ o "is child: $is_direct_child"
+ 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"
+
+ o "Check for rebase"
+ if git:rev-exists "$refs_subrepo_fetch"; then
+ if ! git:commit-in-rev-list "$gitrepo_commit" "$refs_subrepo_fetch"; then
+ error "Local repository does not contain $gitrepo_commit. Try to 'git subrepo fetch $subref' or add the '-F' flag to always fetch the latest content."
+ fi
+ 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"
+ fi
+
+ 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"
+ fi
+ fi
+
+ 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 --format=%ad%n%ae%n%an "$commit") )
+ IFS=$PREVIOUS_IFS
+
+ # When we create new commits we leave the author information unchanged
+ # the committer will though be updated to the current user
+ # This should be analog how cherrypicking is handled allowing git
+ # 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 --format=%B "$commit" |
+ GIT_AUTHOR_DATE="${author_info[0]}" \
+ GIT_AUTHOR_EMAIL="${author_info[1]}" \
+ GIT_AUTHOR_NAME="${author_info[2]}" \
+ 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")
+ fi
+ done
+
+ o "Create branch '$branch' for this new commit set $prev_commit."
+ RUN git branch "$branch" "$prev_commit"
+ else
+ o "No parent setting, use the subdir content."
+ RUN git branch "$branch" HEAD
+ TTY=true FAIL=false RUN git filter-branch -f --subdirectory-filter \
+ "$subref" "$branch"
+ fi
+
+ o "Remove the .gitrepo file from $first_gitrepo_commit..$branch"
+ local filter="$branch"
+ [[ -n "$first_gitrepo_commit" ]] && filter="$first_gitrepo_commit..$branch"
+ FAIL=false RUN git filter-branch -f --prune-empty --tree-filter \
+ "rm -f .gitrepo" "$filter"
+
+ git:create-worktree "$branch"
+
+ o "Create ref '$refs_subrepo_branch'."
+ git:make-ref "$refs_subrepo_branch" "$branch"
+}
+
+# Commit a merged subrepo branch:
+subrepo:commit() {
+ o "Check that '$subrepo_commit_ref' exists."
+ git:rev-exists "$subrepo_commit_ref" ||
+ error "Commit ref '$subrepo_commit_ref' does not exist."
+
+ if ! "$force_wanted"; then
+ 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 \
+ "Can't commit: '$subrepo_commit_ref' doesn't contain upstream HEAD."
+ fi
+ fi
+
+ if git ls-files -- "$subdir" | grep -q .; then
+ o "Remove old content of the subdir."
+ RUN git rm -r -- "$subdir"
+ fi
+
+ o "Put remote subrepo content into '$subdir/'."
+ RUN git read-tree --prefix="$subdir" -u "$subrepo_commit_ref"
+
+ o "Put info into '$subdir/.gitrepo' file."
+ update-gitrepo-file
+ RUN git add -f -- "$gitrepo"
+
+ local commit_message
+ if [[ -n "$wanted_commit_message" ]]; then
+ commit_message="$wanted_commit_message"
+ else
+ commit_message="$(get-commit-message)"
+ fi
+
+ local edit_flag=
+ $edit_wanted && edit_flag=--edit
+
+ [[ -n $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"
+ 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"
+ RUN git reset --hard "$output"
+ fi
+
+ # Clean up worktree to indicate that we are ready
+ git:remove-worktree
+
+ o "Create ref '$refs_subrepo_commit'."
+ git:make-ref "$refs_subrepo_commit" "$subrepo_commit_ref"
+}
+
+subrepo:status() {
+ if [[ ${#command_arguments[@]} -eq 0 ]]; then
+ get-all-subrepos
+ local count=${#subrepos[@]}
+ if ! "$quiet_wanted"; then
+ if [[ $count -eq 0 ]]; then
+ echo "No subrepos."
+ return
+ else
+ local s=; [[ $count -eq 1 ]] || s=s
+ echo "$count subrepo$s:"
+ echo
+ fi
+ fi
+ else
+ subrepos=("${command_arguments[@]}")
+ fi
+
+ for subdir in "${subrepos[@]}"; do
+ check-and-normalize-subdir
+ encode-subdir
+
+ if [[ ! -f $subdir/.gitrepo ]]; then
+ echo "'$subdir' is not a subrepo"
+ echo
+ continue
+ fi
+
+ 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=
+
+ read-gitrepo-file
+ if $fetch_wanted; then
+ subrepo:fetch
+ fi
+
+ if $quiet_wanted; then
+ echo "$subdir"
+ continue
+ fi
+
+ echo "Git subrepo '$subdir':"
+ git:branch-exists "subrepo/$subref" &&
+ echo " Subrepo Branch: subrepo/$subref"
+ local remote="subrepo/$subref"
+ FAIL=false OUT=true RUN git config "remote.$remote.url"
+ [[ -n $output ]] &&
+ echo " Remote Name: subrepo/$subref"
+ echo " Remote URL: $subrepo_remote"
+ [[ -n $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)"
+ # TODO Remove this eventually:
+ elif [[ -n $subrepo_former ]]; then
+ printf " Former Commit: $(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
+ echo " Worktree: $_worktree"
+ fi
+
+ if "$verbose_wanted"; then
+ status-refs
+ fi
+
+ echo
+ done
+}
+
+subrepo:clean() {
+ # Remove subrepo branches if exist:
+ local branch="subrepo/$subref"
+ local ref="refs/heads/$branch"
+ local worktree="$GIT_TMP/$branch"
+
+ o "Clean $subdir"
+ git:remove-worktree
+ if [[ -e .git/$ref ]]; then
+ o "Remove branch '$branch'."
+ RUN git update-ref -d "$ref"
+ clean_list+=("branch '$branch'")
+ fi
+
+ if "$force_wanted"; then
+ o "Remove all subrepo refs."
+ local suffix=""
+ if ! $all_wanted; then
+ suffix="$subref/"
+ fi
+ git show-ref | while read hash ref; do
+ if [[ "$ref" == refs/subrepo/$suffix* ]]; then
+ git update-ref -d "$ref"
+ fi
+ done
+ fi
+}
+
+#------------------------------------------------------------------------------
+# Support functions:
+#------------------------------------------------------------------------------
+
+
+# TODO:
+# Collect original options and arguments into an array for commit message
+# They should be normalized and pruned
+
+# Parse command line options:
+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
+
+ eval "$(
+ echo "$GETOPT_SPEC" |
+ git rev-parse --parseopt -- "$@" ||
+ echo exit $?
+ )"
+
+ while [[ $# -gt 0 ]]; do
+ 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"
+ 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"
+ shift;;
+ -M) join_method="$1"
+ shift;;
+ -r) subrepo_remote="$1"
+ override_remote="$1"
+ commit_msg_args+=("--remote=$1")
+ shift ;;
+ -s) squash_wanted=true ;;
+ -u) update_wanted=true
+ commit_msg_args+=("--update") ;;
+ -q) quiet_wanted=true ;;
+ -v) verbose_wanted=true ;;
+ -d) debug_wanted=true ;;
+ -x) set -x ;;
+ --version)
+ echo "$VERSION"
+ exit ;;
+ *) usage-error "Unexpected option: '$option'." ;;
+ esac
+ done
+
+ # Set subrepo command:
+ 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"
+ fi
+ commit_msg_args+=("${command_arguments[@]}")
+
+ for option in all ALL edit fetch force squash; do
+ var="${option}_wanted"
+ if ${!var}; then
+ check_option $option
+ fi
+ done
+
+ if [[ -n $override_branch ]]; then
+ check_option branch
+ fi
+ if [[ -n $override_remote ]]; then
+ check_option remote
+ fi
+ if [[ -n $wanted_commit_message ]]; then
+ check_option message
+ fi
+ if $update_wanted; then
+ check_option update
+ if [[ -z $subrepo_branch && -z $subrepo_remote ]]; then
+ usage-error "Can't use '--update' without '--branch' or '--remote'."
+ fi
+ fi
+}
+
+options_help='all'
+options_branch='all fetch force'
+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_init='branch remote method'
+options_pull='all branch edit force message remote update'
+options_push='all branch force remote squash update'
+options_status='ALL all fetch'
+check_option() {
+ local var="options_${command//-/_}"
+ [[ ${!var} =~ $1 ]] ||
+ usage-error "Invalid option '--$1' for '$command'."
+}
+
+#------------------------------------------------------------------------------
+# Command argument validation:
+#------------------------------------------------------------------------------
+
+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"
+
+ : "${GIT_SUBREPO_PAGER:=${PAGER:-less}}"
+ if [[ $GIT_SUBREPO_PAGER == less ]]; then
+ GIT_SUBREPO_PAGER='less -FRX'
+ fi
+}
+
+command-prepare() {
+ local output=
+ if git:rev-exists HEAD; then
+ git:get-head-branch-commit
+ fi
+ original_head_commit="${output:-none}"
+}
+
+# Do the setup steps needed by most of the subrepo subcommands:
+command-setup() {
+ get-params "$@"
+
+ check-and-normalize-subdir
+ encode-subdir
+ 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)
+ 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
+ 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
+to remove the worktree."
+ else
+ error "There is already a worktree with branch subrepo/$subdir.
+Use the --force flag to override this check or remove the worktree with
+1. rm -rf $_worktree
+2. git worktree prune
+"
+ fi
+ fi
+ 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"
+
+ # Read/parse the .gitrepo file (unless clone/init; doesn't exist yet)
+ if [[ ! $command =~ ^(clone|init)$ ]]; then
+ read-gitrepo-file
+ fi
+
+ true
+}
+
+# Parse command line args according to a simple dsl spec:
+get-params() {
+ local i=0
+ local num=${#command_arguments[@]}
+ 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"
+ # Look for function name after ':' to provide a default value
+ else
+ if [[ $i -lt $num ]]; then
+ printf -v ${arg%:*} -- "$value"
+ elif [[ $arg =~ : ]]; then
+ "${arg#*:}"
+ fi
+ fi
+ let i=$((i+1))
+ done
+
+ # Check for extra arguments:
+ if [[ $num -gt $i ]]; then
+ set -- ${command_arguments[@]}
+ for ((j = 1; j <= i; j++)); do shift; done
+ error "Unknown argument(s) '$*' for '$command' command."
+ fi
+}
+
+check-and-normalize-subdir() {
+ # Sanity check subdir:
+ [[ -n $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=$(tr -s / <<< "$subdir")
+}
+
+# Determine the correct subdir path to use:
+guess-subdir() {
+ 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"
+ check-and-normalize-subdir
+ encode-subdir
+}
+
+# Encode the subdir as a valid git ref format
+#
+# Input: env $subdir
+# Output: env $subref
+#
+# For detail rules about valid git refs, see the manual of git-check-ref-format:
+# URL: https://www.kernel.org/pub/software/scm/git/docs/git-check-ref-format.html
+# Shell: git check-ref-format --help
+#
+encode-subdir() {
+ subref=$subdir
+ if [[ ! $subref ]] || git check-ref-format "subrepo/$subref"; then
+ return
+ fi
+
+ ## 0. escape %, ensure the subref can be (almost) decoded back to subdir
+ subref=${subref//%/%25}
+
+ ## 1. They can include slash / for hierarchical (directory) grouping,
+ ## but no slash-separated component can begin with a dot . or
+ ## end with the sequence .lock.
+ subref=/$subref/
+ subref=${subref//\/.//%2e}
+ subref=${subref//.lock\//%2elock/}
+ subref=${subref#/}
+ subref=${subref%/}
+
+ ## 2. They must contain at least one /.
+ ## Note: 'subrepo/' be will prefixed, so this is always true.
+ ## 3. They cannot have two consecutive dots .. anywhere.
+ subref=${subref//../%2e%2e}
+ subref=${subref//%2e./%2e%2e}
+ subref=${subref//.%2e/%2e%2e}
+
+ ## 4. They cannot have ASCII control characters
+ ## (i.e. bytes whose values are lower than \040, or \177 DEL), space,
+ ## tilde ~, caret ^, or colon : anywhere.
+ ## 5. They cannot have question-mark ?, asterisk *,
+ ## or open bracket [ anywhere.
+ 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)
+ subref=${subref//$(printf "%b" "\x$x")/%$x}
+ done
+ subref=${subref//$'\177'/%7f}
+ subref=${subref// /%20}
+ subref=${subref//\~/%7e}
+ subref=${subref//^/%5e}
+ subref=${subref//:/%3a}
+ subref=${subref//\?/%3f}
+ subref=${subref//\*/%2a}
+ subref=${subref//\[/%5b}
+ subref=${subref//$'\n'/%0a}
+
+ ## 6. They cannot begin or end with a slash / or contain multiple
+ ## consecutive slashes.
+ ## Note: This rule is not revertable.
+ [[ $subref != *//* ]] || subref=$(tr -s / <<< "$subref")
+
+ ## 7. They cannot end with a dot ..
+ case "$subref" in
+ *.) subref=${subref%.}
+ subref+=%2e
+ ;;
+ esac
+
+ ## 8. They cannot contain a sequence @\{.
+ subref=${subref//@\{/%40\{}
+
+ ## 9. They cannot be the single character @.
+ ## Note: 'subrepo/' be will prefixed, so this is always true.
+
+ ## 10. They cannot contain a \.
+ subref=${subref//\\/%5c}
+
+ subref=$(git check-ref-format --normalize --allow-onelevel "$subref") ||
+ error "Can't determine valid subref from '$subdir'."
+}
+
+#------------------------------------------------------------------------------
+# State file (`.gitrepo`) functions:
+#------------------------------------------------------------------------------
+
+# Set subdir and gitrepo vars:
+read-gitrepo-file() {
+ gitrepo="$subdir/.gitrepo"
+
+ if [[ ! -f $gitrepo ]]; then
+ error "No '$gitrepo' file."
+ fi
+
+ # Read .gitrepo values:
+ if [[ -z $subrepo_remote ]]; then
+ SAY=false OUT=true RUN git config --file="$gitrepo" subrepo.remote
+ subrepo_remote="$output"
+ fi
+
+ if [[ -z $subrepo_branch ]]; then
+ SAY=false OUT=true RUN git config --file="$gitrepo" subrepo.branch
+ subrepo_branch="$output"
+ fi
+
+ SAY=false OUT=true RUN git config --file="$gitrepo" subrepo.commit
+ subrepo_commit="$output"
+
+ FAIL=false \
+ SAY=false OUT=true RUN git config --file="$gitrepo" subrepo.parent
+ subrepo_parent="$output"
+
+ FAIL=false \
+ SAY=false OUT=true RUN git config --file="$gitrepo" subrepo.method
+ if [[ $output == "rebase" ]]; then
+ join_method="rebase"
+ else
+ # This is the default method
+ 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"
+ fi
+}
+
+
+# Update the subdir/.gitrepo state file:
+update-gitrepo-file() {
+ local short_commit=
+
+ local newfile=false
+ if [[ ! -e $gitrepo ]]; then
+
+ FAIL=false RUN git cat-file -e "$original_head_commit":"$gitrepo"
+
+ if OK; then
+ o "Try to recreate gitrepo file from $original_head_commit"
+ git cat-file -p "$original_head_commit":"$gitrepo" > "$gitrepo"
+ else
+ newfile=true
+ cat <<... > "$gitrepo"
+; 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
+;
+...
+ fi
+ fi
+
+
+ # TODO: only update remote and branch if supplied and $update_wanted
+ if $newfile || [[ $update_wanted && -n $override_remote ]]; then
+ RUN git config --file="$gitrepo" subrepo.remote "$subrepo_remote"
+ fi
+
+ if $newfile || [[ $update_wanted && -n $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
+ OUT=true RUN git rev-parse "$subrepo_commit_ref"
+ o "$upstream_head_commit == $output"
+ if [[ $upstream_head_commit == $output ]]; then
+ RUN git config --file="$gitrepo" subrepo.parent "$original_head_commit"
+ fi
+ fi
+
+ [[ -z $join_method ]] && join_method="merge"
+ RUN git config --file="$gitrepo" subrepo.method "$join_method"
+
+ RUN git config --file="$gitrepo" subrepo.cmdver "$VERSION"
+
+ RUN git add -f -- "$gitrepo"
+}
+
+#------------------------------------------------------------------------------
+# Enviroment checks:
+#------------------------------------------------------------------------------
+
+# Check that system is ok for this command:
+assert-environment-ok() {
+ type git &> /dev/null ||
+ error "Can't find your 'git' command in '$PATH'."
+
+ 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
+ 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."
+ echo "It doesn't need to be your shell, but it must be in your PATH."
+ if [[ $OSTYPE == darwin* ]]; then
+ echo "You appear to be on macOS."
+ echo "Try: 'brew install bash'."
+ echo "This will not change your user shell, it just installs 'Bash 5.x'."
+ fi
+ exit 1
+ fi
+}
+
+# Make sure git repo is ready:
+assert-repo-is-ready() {
+ # Skip this for trivial info commands:
+ [[ $command =~ ^(help|version|upgrade)$ ]] && return
+
+ # We must be inside a git repo:
+ git rev-parse --git-dir &> /dev/null ||
+ error "Not inside a git repository."
+
+ # Get the original branch and commit:
+ git:get-head-branch-name
+ original_head_branch="$output"
+
+ # If a subrepo branch is currently checked out, then note it:
+ if [[ $original_head_branch =~ ^subrepo/(.*) ]]; then
+ error "Can't '$command' while subrepo branch is checked out."
+ fi
+
+ # Make sure we are on a branch:
+ [[ $original_head_branch == HEAD || -z $original_head_branch ]] &&
+ error "Must be on a branch to run this command."
+
+ # In a work-tree:
+ SAY=false OUT=true RUN git rev-parse --is-inside-work-tree
+ [[ $output == true ]] ||
+ error "Can't 'subrepo $command' outside a working tree."
+
+ # HEAD exists:
+ [[ $command == clone ]] ||
+ RUN git rev-parse --verify HEAD
+
+ assert-working-copy-is-clean
+
+ # For now, only support actions from top of repo:
+ if [[ -n "$(git rev-parse --show-prefix)" ]]; then
+ error "Need to run subrepo command from top level directory of the repo."
+ fi
+}
+
+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)
+ o "Assert that working copy is clean: $pwd"
+ git update-index -q --ignore-submodules --refresh
+ git diff-files --quiet --ignore-submodules ||
+ error "Can't $command subrepo. Unstaged changes. ($pwd)"
+ if [[ $command != clone ]] || git:rev-exists HEAD; then
+ git diff-index --quiet --ignore-submodules HEAD ||
+ error "Can't $command subrepo. Working tree has changes. ($pwd)"
+ git diff-index --quiet --cached --ignore-submodules HEAD ||
+ error "Can't $command subrepo. Index has changes. ($pwd)"
+ else
+ # Repo has no commits and we're cloning a subrepo. Working tree won't
+ # possibly have changes as there was nothing initial to change.
+ [[ -z $(git ls-files) ]] ||
+ error "Can't $command subrepo. Index has changes. ($pwd)"
+ fi
+ fi
+}
+
+# If subdir exists, make sure it is empty:
+assert-subdir-ready-for-init() {
+ if [[ ! -e $subdir ]]; then
+ error "The subdir '$subdir' does not exist."
+ fi
+ if [[ -e $subdir/.gitrepo ]]; then
+ error "The subdir '$subdir' is already a subrepo."
+ fi
+ # Check that subdir is part of the repo
+ if [[ -z $(git log -1 -- $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
+ error "The subdir '$subdir' exists and is not empty."
+ fi
+}
+
+#------------------------------------------------------------------------------
+# Getters of various information:
+#------------------------------------------------------------------------------
+
+# 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))
+ subrepos=()
+ local path
+ for path in "${paths[@]}"; do
+ add-subrepo "$path"
+ done
+}
+
+add-subrepo() {
+ if ! $ALL_wanted; then
+ for path in "${subrepos[@]}"; do
+ [[ $1 =~ ^$path ]] && return
+ done
+ fi
+ subrepos+=("$1")
+}
+
+# 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="$(
+ echo "$remotes" |
+ grep -E "$commit[[:space:]]+refs/heads/" |
+ grep -v HEAD |
+ head -n1 |
+ cut -f2
+ )"
+ [[ $branch =~ refs/heads/ ]] ||
+ error "Problem finding remote default head branch."
+ 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"
+ if git:rev-exists "$upstream_head_commit"; then
+ commit=$(git rev-parse --short "$upstream_head_commit")
+ fi
+
+ local args=() debug_wanted=false
+ if $all_wanted; then
+ args+=("$subdir")
+ fi
+ args+=(${commit_msg_args[@]})
+
+ # Find the specific git-subrepo code used:
+ local command_remote='???'
+ local command_commit='???'
+ get-command-info
+
+ local merged="none"
+ if git:rev-exists "$subrepo_commit_ref"; then
+ merged=$(git rev-parse --short "$subrepo_commit_ref")
+ fi
+
+ local is_merge=""
+ if [[ $command != push ]]; then
+ if git:is_merge_commit "$subrepo_commit_ref"; then
+ is_merge=" (merge)"
+ fi
+ fi
+
+ # TODO: Consider output for push!
+
+ # Format subrepo commit message:
+ cat <<...
+git subrepo $command$is_merge ${args[@]}
+
+subrepo:
+ subdir: "$subdir"
+ merged: "$merged"
+upstream:
+ origin: "$subrepo_remote"
+ branch: "$subrepo_branch"
+ commit: "$commit"
+git-subrepo:
+ version: "$VERSION"
+ origin: "$command_remote"
+ commit: "$command_commit"
+...
+}
+
+# Get location and version info about the git-subrepo command itself. This
+# info goes into commit messages, so we can find out exactly how the commits
+# were done.
+get-command-info() {
+ local bin="$0"
+ if [[ $bin =~ / ]]; then
+ local 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 ]] &&
+ [[ -e $lib/git-subrepo.d/commit ]]; then
+ command_remote=$(readlink "$lib/git-subrepo.d/upstream")
+ command_commit=$(readlink "$lib/git-subrepo.d/commit")
+ elif [[ $lib =~ / ]]; then
+ lib="$(dirname "$lib")"
+ if [[ -d $lib/.git ]]; then
+ local remote="$(
+ GIT_DIR=$lib/.git git remote -v |
+ grep '^origin' |
+ head -n1 |
+ cut -f2 |
+ cut -d ' ' -f1
+ )"
+ if [[ -n $remote ]]; then
+ command_remote="$remote"
+ else
+ local remote="$(
+ GIT_DIR=$lib/.git git remote -v |
+ head -n1 |
+ cut -f2 |
+ cut -d ' ' -f1
+ )"
+ if [[ -n $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"
+ fi
+ fi
+ fi
+ fi
+}
+
+#------------------------------------------------------------------------------
+# Instructional errors:
+#------------------------------------------------------------------------------
+
+error-join() {
+ cat <<...
+
+You will need to finish the $command by hand. A new working tree has been
+created at $worktree so that you can resolve the conflicts
+shown in the output above.
+
+This is the common conflict resolution workflow:
+
+ 1. cd $worktree
+ 2. Resolve the conflicts (see "git status").
+ 3. "git add" the resolved files.
+...
+
+ if [[ "$join_method" == "rebase" ]]; then
+ cat <<...
+ 4. git rebase --continue
+...
+ else
+ cat <<...
+ 4. git commit
+...
+ fi
+
+ cat <<...
+ 5. If there are more conflicts, restart at step 2.
+ 6. cd $start_pwd
+...
+ local branch_name="${branch:=subrepo/$subdir}"
+ if [[ "$command" == "push" ]]; then
+ cat <<...
+ 7. git subrepo push $subdir $branch_name
+...
+ else
+ cat <<...
+ 7. git subrepo commit $subdir
+...
+ fi
+
+ if [[ "$command" == "pull" && "$join_method" == "rebase" ]]; then
+ cat <<...
+
+After you have performed the steps above you can push your local changes
+without repeating the rebase by:
+ 1. git subrepo push $subdir $branch_name
+
+...
+ fi
+
+cat <<...
+See "git help $join_method" for details.
+
+Alternatively, you can abort the $command and reset back to where you started:
+
+ 1. git subrepo clean $subdir
+
+See "git help subrepo" for more help.
+
+...
+}
+
+#------------------------------------------------------------------------------
+# Git command wrappers:
+#------------------------------------------------------------------------------
+
+git:branch-exists() {
+ git:rev-exists "refs/heads/$1"
+}
+
+git:rev-exists() {
+ git rev-list "$1" -1 &> /dev/null
+}
+
+git:ref-exists() {
+ test -n "$(git for-each-ref "$1")"
+}
+
+git:get-head-branch-name() {
+ output=
+ local name="$(git symbolic-ref --short --quiet HEAD)"
+ [[ $name == HEAD ]] && return
+ output="$name"
+}
+
+git:get-head-branch-commit() {
+ output="$(git rev-parse HEAD)"
+}
+
+git:commit-in-rev-list() {
+ 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")"
+ RUN git update-ref "$ref_name" "$commit"
+}
+
+git:is_merge_commit() {
+ local commit="$1"
+ git show --summary "$commit" | grep -q ^Merge:
+}
+
+git:create-worktree() {
+ local branch="$1"
+ worktree="$GIT_TMP/$branch"
+ RUN git worktree add "$worktree" "$branch"
+}
+
+git:remove-worktree() {
+ o "Remove worktree: $worktree"
+ if [[ -d "$worktree" ]]; then
+ o "Check worktree for unsaved changes"
+ cd "$worktree"
+ assert-working-copy-is-clean
+ cd "$start_pwd"
+
+ o "Clean up worktree $worktree"
+ rm -rf "$worktree"
+ RUN git worktree prune
+ fi
+}
+
+git:delete-branch() {
+ local branch="$1"
+ o "Deleting old '$branch' branch."
+ # Remove worktree first, otherwise you can't delete the branch
+ git:remove-worktree
+ FAIL=false RUN git branch -D "$branch"
+}
+
+
+#------------------------------------------------------------------------------
+# Low level sugar commands:
+#------------------------------------------------------------------------------
+
+# Smart command runner:
+RUN() {
+ $debug_wanted && $SAY && say '>>>' $*
+ if $EXEC; then
+ "$@"
+ return $?
+ fi
+
+ OK=true
+ set +e
+ local rc=
+ local out=
+ if $debug_wanted && $TTY && interactive; then
+ "$@"
+ else
+ if $OUT; then
+ out="$("$@" 2>/dev/null)"
+ else
+ out="$("$@" 2>&1)"
+ fi
+ fi
+ rc=$?
+ set -e
+
+ if [[ $rc -ne 0 ]]; then
+ OK=false
+ $FAIL && error "Command failed: '$*'.\n$out"
+ fi
+ output="$out"
+}
+
+
+interactive() {
+ if [[ -t 0 && -t 1 ]]; then
+ return 0
+ else
+ return 1
+ fi
+}
+
+# Call a function with indent increased:
+CALL() {
+ local INDENT=" $INDENT"
+ "$@" || true
+}
+
+# Print verbose steps for commands with steps:
+o() {
+ if $verbose_wanted; then
+ echo "$INDENT* $@"
+ fi
+}
+
+# Print unless quiet mode:
+say() {
+ $quiet_wanted || echo "$@"
+}
+
+# Print to stderr:
+err() {
+ echo "$@" >&2
+}
+
+# Check if OK:
+OK() {
+ $OK
+}
+
+# Nicely report common error messages:
+usage-error() {
+ local msg="git-subrepo: $1" usage=
+ if [[ $GIT_SUBREPO_TEST_ERRORS != true ]]; then
+ source "${SOURCE_DIR}/git-subrepo.d/help-functions.bash"
+ if can "help:$command"; then
+ msg=$'\n'"$msg"$'\n'"$("help:$command")"$'\n'
+ fi
+ fi
+ echo "$msg" >&2
+ exit 1
+}
+
+# Nicely report common error messages:
+error() {
+ local msg="git-subrepo: $1" usage=
+ echo -e "$msg" >&2
+ exit 1
+}
+
+# Start at the end:
+[[ $BASH_SOURCE != "$0" ]] || main "$@"
+
+# Local Variables:
+# tab-width: 2
+# sh-indentation: 2
+# sh-basic-offset: 2
+# End:
+# vim: set ft=sh sw=2 lisp: