aboutsummaryrefslogtreecommitdiff
path: root/.local
diff options
context:
space:
mode:
Diffstat (limited to '.local')
-rwxr-xr-x.local/lib/git-core/git-subrepo1897
1 files changed, 0 insertions, 1897 deletions
diff --git a/.local/lib/git-core/git-subrepo b/.local/lib/git-core/git-subrepo
deleted file mode 100755
index 3865570..0000000
--- a/.local/lib/git-core/git-subrepo
+++ /dev/null
@@ -1,1897 +0,0 @@
-#!/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:
generated by cgit v1.2.3 (git 2.25.1) at 2024-11-15 07:55:37 +0000