diff options
Diffstat (limited to '.local')
| -rwxr-xr-x | .local/lib/git-core/git-subrepo | 1897 |
1 files changed, 1897 insertions, 0 deletions
diff --git a/.local/lib/git-core/git-subrepo b/.local/lib/git-core/git-subrepo new file mode 100755 index 0000000..3865570 --- /dev/null +++ b/.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: |