sda-php
/
nulib
11
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

modifs.mineures sans commentaires

This commit is contained in:
Jephté Clain 2024-06-09 12:30:03 +04:00
parent a8d8acaa3c
commit 13de7abd40
2 changed files with 130 additions and 497 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

487
bash/src/git.sh
View File

@ -215,490 +215,3 @@ function git_is_merged() {
[ -n "$(git merge-base "$b" "$d")" ] || return 1
[ -z "$(git rev-list "$d..$b")" ]
}
################################################################################
# git annex
NULIB_GIT_SSH_WRAPPER=
function: git_annex_use_ssh_wrapper ""
function git_annex_use_ssh_wrapper() {
[ -n "$NULIB_GIT_SSH_WRAPPER" ] && return
NULIB_GIT_FORCE_PATH="$PATH"
NULIB_GIT_FORCE_SSH="${GIT_SSH:-ssh}"
export NULIB_GIT_FORCE_PATH NULIB_GIT_FORCE_SSH
base_delpath "$NULIBDIR/ssh-wrapper" NULIB_GIT_FORCE_PATH
base_inspath "$NULIBDIR/ssh-wrapper" PATH
NULIB_GIT_SSH_WRAPPER=1
}
function: git_annex_initial "sur le dépôt \$1 fraichement cloné, vérifier s'il faut faire git annex init. Si oui, l'initialiser avec le nom d'hôte, et récupérer tous les fichiers annexés
@return 1 si une erreur s'est produite"
function git_annex_initial() {
local repodir="${1:-.}"
[ -d "$repodir" ] || return 1
repodir="$(abspath "$repodir")"
local GIT_DIR GIT_WORK_TREE
[ "$(cd "$repodir"; git rev-parse --is-bare-repository)" == false ] || return 0
[ -n "$(GIT_DIR="$repodir/.git" git config --get annex.uuid)" ] && return 0
# ici, on sait que git annex n'a pas encore été configuré
# vérifier s'il existe des fichiers annexés
local -a links
base_array_splitl links "$(find "$repodir" -type l)"
local link hasannex=
for link in "${links[@]}"; do
link="$(readlink "$link")"
if [ "${link#.git/annex/}" != "$link" ]; then
hasannex=1
break
elif [[ "$link" == */.git/annex/* ]]; then
hasannex=1
break
fi
done
if [ -n "$hasannex" ]; then
base_in_path git-annex || edie "Vous devez installer git-annex" || return
local cwd; base_push_cwd "$repodir" &&
git annex init "$MYHOSTNAME" &&
git annex get &&
git annex sync &&
base_pop_cwd || base_pop_cwd 1 || return
fi
}
################################################################################
# Outils de haut niveau
function: git_commit ""
function git_commit() {
local all=auto allnew push=auto nopush args
setyesval nopush "$NULIB_GIT_OFFLINE"
[ -n "$nopush" ] && push=
parse_opts + "${PRETTYOPTS[@]}" \
-a,--all all=1 \
-A,--all-new allnew=1 \
-c,--cached all= \
-p,--push push=1 \
-l,--local push= \
@ args -- "$@" && set -- "${args[@]}" || {
eerror "$args"
return 1
}
if [ -n "$allnew" ]; then
git add -A
all=
fi
local message="$1"; shift
local -a cmd
cmd=(git commit)
[ -n "$message" ] && cmd=("${cmd[@]}" -m "$message")
if [ "$all" == "auto" ]; then
# Si des fichiers sont spécifiés, prendre ceux-là.
if [ -z "$*" ]; then
# Sinon, s'il y a des fichiers dans l'index, commiter uniquement ces
# fichiers
# Sinon, committer tous les fichiers modifiés
# le code suivant retourne vrai si l'index contient au moins fichier
git status --porcelain 2>/dev/null | lawk '
BEGIN { ec = 1 }
substr($0, 1, 1) ~ /[^ ?]/ { ec = 0; exit }
END { exit ec }' ||
cmd=("${cmd[@]}" -a)
fi
else
[ -n "$all" ] && cmd=("${cmd[@]}" -a)
fi
if ! "${cmd[@]}" "$@"; then
[ "$push" == auto ] && return 1
fi
if [ "$push" == auto ]; then
git_push --auto || return
elif [ -n "$push" ]; then
git_push --force || return
fi
return 0
}
function: git_update ""
function git_update() {
local args autoff=1
parse_opts + "${PRETTYOPTS[@]}" \
-n,--no-autoff autoff= \
@ args -- "$@" && set -- "${args[@]}" || {
eerror "$args"
return 1
}
if [ -z "$autoff" ]; then
git pull "$@"
return $?
fi
local branch orig_branch restore_branch remote rbranch pbranch
local -a branches prbranches crbranches dbranches
base_array_splitl prbranches "$(git_list_rbranches)"
git fetch -p "$@" || return
base_array_splitl crbranches "$(git_list_rbranches)"
# vérifier s'il n'y a pas des branches distantes qui ont été supprimées
for branch in "${prbranches[@]}"; do
if ! base_array_contains crbranches "$branch"; then
base_array_add dbranches "${branch#*/}"
fi
done
if [ ${#dbranches[*]} -gt 0 ]; then
eimportant "One or more distant branches where deleted"
for branch in "${dbranches[@]}"; do
if git_have_branch "$branch"; then
if ! ask_yesno "Do you want to delete local branch $branch?" X; then
base_array_del dbranches "$branch"
fi
fi
done
fi
if [ ${#dbranches[*]} -gt 0 ]; then
base_array_splitl branches "$(git_list_branches)"
branch="$(git_get_branch)"
if base_array_contains dbranches "$branch"; then
# si la branche courante est l'une des branches à supprimer, il faut
# basculer vers develop ou master
local swto
if [ -z "$swto" ] && base_array_contains branches develop && ! base_array_contains dbranches develop; then
swto=develop
fi
if [ -z "$swto" ] && base_array_contains branches master && ! base_array_contains dbranches master; then
swto=master
fi
if ! git_check_cleancheckout; then
echo "* There are uncommitted local changes. However current branch is slated for removal.
Make your verifications then delete the local branches:
${swto:+$(qvals git checkout "$swto")
}$(qvals git branch -D "${dbranches[@]}")"
return 1
fi
if [ -n "$swto" ]; then
git checkout -q "$swto"
else
echo "* Current branch is slated for removal but I don't know to which branch I should switch first.
Make your choice then delete the local branches:
$(qvals git branch -D "${dbranches[@]}")"
return 1
fi
fi
for branch in "${dbranches[@]}"; do
git branch -D "$branch"
done
fi
# intégrer les modifications dans les branches locales
if ! git_check_cleancheckout; then
branch="$(git_get_branch)"
remote="$(git_get_branch_remote "$branch")"
rbranch="$(git_get_branch_rbranch "$branch" "$remote")"
pbranch="${rbranch#refs/remotes/}"
if git merge -q --ff-only "$rbranch"; then
echo "* There are uncommitted local changes: only CURRENT branch were updated"
fi
return 0
fi
orig_branch="$(git_get_branch)"
base_array_splitl branches "$(git_list_branches)"
for branch in "${branches[@]}"; do
remote="$(git_get_branch_remote "$branch")"
rbranch="$(git_get_branch_rbranch "$branch" "$remote")"
pbranch="${rbranch#refs/remotes/}"
[ -n "$remote" -a -n "$rbranch" ] || continue
if git_is_ancestor "$branch" "$rbranch"; then
if git_should_ff "$branch" "$rbranch"; then
echo "* Fast-forwarding $branch -> $pbranch"
git checkout -q "$branch"
git merge -q --ff-only "$rbranch"
restore_branch=1
fi
else
if [ "$branch" == "$orig_branch" ]; then
echo "* Cannot fast-forward CURRENT branch $branch from $pbranch
Try to merge manually with: git merge $pbranch"
else
echo "* Cannot fast-forward local branch $branch from $pbranch
You can merge manually with: git checkout $branch; git merge $pbranch"
fi
fi
done
[ -n "$restore_branch" ] && git checkout -q "$orig_branch"
return 0
}
function: git_push ""
function git_push() {
local all all_branches all_tags auto force args no_annex
parse_opts + "${PRETTYOPTS[@]}" \
-a,--all all=1 \
-b,--branches,--all-branches all_branches=1 \
-t,--tags,--all-tags all_tags=1 \
--auto auto=1 \
-f,--force force=1 \
-n,--no-annex no_annex=1 \
@ args -- "$@" && set -- "${args[@]}" || {
eerror "$args"
return 1
}
if [ -n "$all" ]; then
# On a demandé à pusher toutes les branches et tous les tags
local r
git push --all "$@"; r=$?
if [ $r -eq 0 ]; then
git push --tags "$@"; r=$?
fi
return $r
elif [ -n "$all_branches" ]; then
# On a demandé à pusher toutes les branches
git push --all "$@"
return $?
elif [ -n "$all_tags" ]; then
# On a demandé à pusher tous les tags
git push --tags "$@"
return $?
elif [ $# -gt 0 ]; then
# Sinon, si des arguments sont spécifiés, les passer à git sans
# modification
git push "$@"
return $?
elif git_have_annex; then
# Si une annexe existe dans le dépôt, demander à git-annex de faire la
# synchronisation, sauf si --no-annex est spécifié ou si on est en mode
# automatique
if [ -z "$no_annex" -a -z "$auto" ]; then
git annex sync
return $?
fi
fi
# sinon on push vers origin. vérifier la présence du remote
[ -n "$(git config --get remote.origin.url)" ] || {
if [ -n "$auto" ]; then
# en mode automatique, ignorer l'absence de remote
return 0
else
eerror "Aucun remote origin n'est défini"
return 1
fi
}
# puis calculer la branche à pusher
local branch="$(git rev-parse --abbrev-ref HEAD 2>/dev/null)"
local origin="$(git config --get "branch.$branch.remote")"
if [ -n "$branch" -a "$origin" == origin ]; then
if [ -n "$auto" ]; then
# en mode automatique, ne pousser que la branche courante
git push "$origin" "$branch" || return
else
# utiliser la configuration par défaut, qui est sous debian squeeze
# de pousser toutes les branches
git push || return
fi
elif [ -n "$force" ]; then
# utiliser la configuration par défaut, qui est sous debian squeeze de
# pousser toutes les branches
git push || return
fi
return 0
}
function git__pclone() {
estep "$1 --> $(ppath "$2")"
mkdirof "$2" || return 1
git clone "$1" "$2" || return 1
if [ -z "$3" ]; then
(
cd "$2"
if git_have_rbranch develop; then
git checkout develop || exit 1
fi
) || return 1
fi
git_annex_initial "$2" || return 1
}
function git__gitolite_info() {
local mode="$1" urlbase="$2" pattern="$3"
case "$mode" in
http) curl -fs "$urlbase/info${pattern:+"?$pattern"}";;
ssh) ssh -q "$urlbase" info ${pattern:+"$pattern"} 2>/dev/null;;
esac
}
function git__filter_repos() {
lawk -v prefix="$1" '
NR <= 2 { next }
{
# filtrer les projets qui ne sont pas encore créés
if (substr($0, 5, 2) == " C") next
repo = substr($0, 6)
# filtrer les projets de type wildcard
if (repo ~ /[\[\]\*]/) next
# enlever le prefixe
if (prefix != "" && substr(repo, 1, length(prefix)) != prefix) next
print repo
}'
}
function: git_clone ""
function git_clone() {
no_clone=
update=
nodevelop=
recursive=
parse_opts "${PRETTYOPTS[@]}" \
-n,--no-clone no_clone=1 \
-u,--update update=1 \
-m,--master nodevelop=1 \
-r,--recursive recursive=1 \
@ args -- "$@" && set -- "${args[@]}" || edie "$args" || return
if [ -n "$recursive" ]; then
repobase="$1"
[ -n "$repobase" ] || edie "Vous devez spécifier l'url de base des dépôts à cloner" || return
if [ "${repobase#http://}" != "$repobase" -o "${repobase#https://}" != "$repobase" ]; then
# accès par http
mode=http
splitfsep "$repobase" :// scheme hostuserpath
splitfsep "$hostuserpath" / host userpath
splitfsep "$userpath" / user basepath
[ -n "$host" -a -n "$user" ] || edie "Vous devez spécifier l'hôte e.g http://host/git/basepath" || return
urlbase="$scheme://$host/$user"
else
# accès par ssh
mode=ssh
splitfsep "$repobase" : userhost basepath
splituserhost "$userhost" user host
[ -n "$user" ] || user=git
[ -n "$host" ] || edie "Vous devez spécifier l'hôte" || return
urlbase="$user@$host"
fi
basepath="${basepath%/}"
destbase="${2:-.}"
git_annex_use_ssh_wrapper
prefix="${basepath:+$basepath/}"
base_array_splitl repos "$(set -o pipefail; git__gitolite_info "$mode" "$urlbase" "$prefix" | git__filter_repos "$prefix")" || edie || return
for repo in "${repos[@]}"; do
case "$mode" in
http) repourl="$urlbase/$repo";;
ssh) repourl="$urlbase:$repo";;
esac
setx destdir=abspath "$destbase/${repo#$prefix}"
if [ -d "$destdir" ]; then
if [ -n "$update" ]; then
(
${no_clone:+qvals} cd "$destdir"
${no_clone:+qvals} git pull
) || edie || return
else
estepe "$(ppath2 "$destdir"): répertoire existant"
fi
elif [ -n "$no_clone" ]; then
qvals git clone "$repourl" "$destdir"
else
git__pclone "$repourl" "$destdir" "$nodevelop" || edie || return
fi
done
else
repourl="${1%.git}"
[ -n "$repourl" ] || edie "Vous devez spécifier l'url du dépôt git" || return
destdir="$2"
if [ -z "$destdir" ]; then
splitfsep "$repourl" : userhost path
setx destdir=basename -- "$path"
destdir="${destdir%.git}"
fi
setx destdir=abspath "$destdir"
git_annex_use_ssh_wrapper
if [ -d "$destdir" ]; then
if [ -n "$update" ]; then
(
${no_clone:+qvals} cd "$destdir"
${no_clone:+qvals} git pull
) || edie || return
else
estepe "$(ppath2 "$destdir"): répertoire existant"
fi
elif [ -n "$no_clone" ]; then
qvals git clone "$repourl" "$destdir"
else
git__pclone "$repourl" "$destdir" "$nodevelop" || edie || return
fi
fi
}
function: git_crone ""
function git_crone() {
repourl="${1%.git}"
[ -n "$repourl" ] || edie "Vous devez spécifier l'url du dépôt git" || return
if [ "${repourl#http://}" != "$repourl" -o "${repourl#https://}" != "$repourl" ]; then
# accès par http
mode=http
splitfsep "$repourl" :// scheme hostuserpath
splitfsep "$hostuserpath" / host userpath
splitfsep "$userpath" / user path
[ -n "$host" -a -n "$user" ] || edie "Vous devez spécifier l'hôte e.g http://host/git/repo" || return
hostuser="$scheme://$host/$user"
else
# accès par ssh
mode=ssh
splitfsep "$repourl" : userhost path
splituserhost "$userhost" user host
[ -n "$user" ] || user=git
[ -n "$host" ] || edie "Vous devez spécifier l'hôte" || return
userhost="$user@$host"
fi
[ -n "$path" ] || edie "Vous devez spécifier le chemin du dépôt git" || return
destdir="$2"
if [ -z "$destdir" ]; then
setx destdir=basename -- "$path"
destdir="${destdir%.git}"
fi
tmpdestdir=
if [ -d "$destdir" ]; then
[ -d "$destdir/.git" ] && edie "$(ppath2 "$destdir"): un dépôt existe déjà" || return
ac_set_tmpdir tmpdestdir
fi
if [ "$mode" == http ]; then
setx result=curl -fs "$hostuser/create?$path" || edie || return
echo "$result"
[[ "$result" == FATAL:* ]] && edie || return
if [ -n "$tmpdestdir" ]; then
setxx destname=abspath "$destdir" // basename
git clone "$hostuser/$path" "$tmpdestdir/$destname" || edie || return
mv "$tmpdestdir/$destname/.git" "$destdir" || edie || return
ac_clean "$tmpdestdir"
else
git clone "$hostuser/$path" "$destdir" || edie || return
fi
elif [ "$mode" == ssh ]; then
git_annex_use_ssh_wrapper
ssh "$userhost" create "$path" || edie || return
if [ -n "$tmpdestdir" ]; then
setxx destname=abspath "$destdir" // basename
git clone "$userhost:$path" "$tmpdestdir/$destname" || edie || return
mv "$tmpdestdir/$destname/.git" "$destdir" || edie || return
ac_clean "$tmpdestdir"
else
git clone "$userhost:$path" "$destdir" || edie || return
fi
else
edie "$mode: mode non supporté" || return
fi
git_annex_initial "$destdir" || edie || return
}

140
bin/npu
View File

@ -3,11 +3,101 @@
source "$(dirname -- "$0")/../load.sh" || exit 1
require: git
basedir=
function _git_update() {
local branch
local -a prbranches crbranches dbranches
setx -a prbranches=git_list_rbranches
git fetch -p "$@" || return
setx -a crbranches=git_list_rbranches
# vérifier s'il y a des branches distantes qui ont été supprimées
for branch in "${prbranches[@]}"; do
if ! array_contains crbranches "$branch"; then
array_add dbranches "${branch#*/}"
fi
done
if [ ${#dbranches[*]} -gt 0 ]; then
setx -a branches=git_list_branches
setx branch=git_get_branch
eimportant "One or more distant branches where deleted"
if git_check_cleancheckout; then
einfo "Delete the obsolete local branches with these commands:"
else
ewarn "Take care of uncommitted local changes first"
einfo "Then delete the obsolete local branches with these commands:"
fi
if array_contains dbranches "$branch"; then
# si la branche courante est l'une des branches à supprimer, il faut
# basculer vers develop ou master
local swto
if [ -z "$swto" ] && array_contains branches develop && ! array_contains dbranches develop; then
swto=develop
fi
if [ -z "$swto" ] && array_contains branches master && ! array_contains dbranches master; then
swto=master
fi
[ -n "$swto" ] && qvals git checkout "$swto"
fi
qvals git branch -D "${dbranches[@]}"
return 1
fi
# intégrer les modifications des branches locales
if ! git_check_cleancheckout; then
setx branch=git_get_branch
setx remote=git_get_branch_remote "$branch"
setx rbranch=git_get_branch_rbranch "$branch" "$remote"
pbranch="${rbranch#refs/remotes/}"
if git merge -q --ff-only "$rbranch"; then
enote "There are uncommitted local changes: only CURRENT branch were updated"
fi
return 0
fi
setx -a branches=git_list_branches
restore_branch=
for branch in "${branches[@]}"; do
setx remote=git_get_branch_remote "$branch"
setx rbranch=git_get_branch_rbranch "$branch" "$remote"
pbranch="${rbranch#refs/remotes/}"
[ -n "$remote" -a -n "$rbranch" ] || continue
if git_is_ancestor "$branch" "$rbranch"; then
if git_should_ff "$branch" "$rbranch"; then
einfo "Fast-forwarding $branch -> $pbranch"
git checkout -q "$branch"
git merge -q --ff-only "$rbranch"
restore_branch=1
fi
else
if [ "$branch" == "$orig_branch" ]; then
echo "* Cannot fast-forward CURRENT branch $branch from $pbranch
Try to merge manually with: git merge $pbranch"
else
echo "* Cannot fast-forward local branch $branch from $pbranch
You can merge manually with: git checkout $branch; git merge $pbranch"
fi
fi
done
[ -n "$restore_branch" ] && git checkout -q "$orig_branch"
return 0
}
function git_update() {
local cwd r
setx cwd=ppath2 "$(pwd)" "$OrigCwd"
etitle "$cwd"
_git_update "$@"; r=$?
eend
return $r
}
chdir=
all=
remote=
autoff=1
reset=ask
Remote=
Autoff=1
Reset=ask
args=(
"\
mettre à jour les branches locales
@ -15,13 +105,43 @@ mettre à jour les branches locales
si la branche courante est une branche wip, écraser les modifications locales éventuelles après un avertissement.
sinon, ne mettre à jour la branche locale qu'en mode fast-forward"
#"usage"
-d:,--chdir:BASEDIR basedir= "répertoire dans lequel se placer avant de lancer les opérations"
-d:,--chdir:BASEDIR chdir= "répertoire dans lequel se placer avant de lancer les opérations"
-a,--all all=1 "faire l'opération sur tous les sous-répertoires de BASEDIR qui sont des dépôts git"
-o:,--remote remote= "spécifier le remote depuis lequel faire le fetch"
--autoff autoff=1 "s'il n'y a pas de modifications locales, faire un fast-forward de toutes les branches traquées. c'est l'option par défaut."
-l,--no-autoff autoff= "ne pas faire de fast-forward automatique des branches traquées. seule la branche courante est mise à jour"
--reset reset=1 "écraser les modifications locales si la branche courante est une branche wip"
-n,--no-reset reset= "ne jamais écraser les modifications locales, même si la branche courante est une branche wip"
-o:,--remote Remote= "spécifier le remote depuis lequel faire le fetch"
--autoff Autoff=1 "s'il n'y a pas de modifications locales, faire un fast-forward de toutes les branches traquées. c'est l'option par défaut."
-l,--no-autoff Autoff= "ne pas faire de fast-forward automatique des branches traquées. seule la branche courante est mise à jour"
--reset Reset=1 "écraser les modifications locales si la branche courante est une branche wip"
-n,--no-reset Reset= "ne jamais écraser les modifications locales, même si la branche courante est une branche wip"
)
parse_args "$@"; set -- "${args[@]}"
setx OrigCwd=pwd
if [ -n "$chdir" ]; then
cd "$chdir" || die
fi
if [ -n "$all" ]; then
# liste de sous répertoires
if [ $# -gt 0 ]; then
# si on a une liste de patterns, l'utiliser
setx -a dirs=ls_dirs . "$@"
else
dirs=()
for dir in */.git; do
[ -d "$dir" ] || continue
dirs+=("${dir%/.git}")
done
fi
setx cwd=pwd
for dir in "${dirs[@]}"; do
cd "$dir" || die
git_update || die
cd "$cwd"
done
else
# répertoire courant uniquement
args=()
isatty || args+=(--porcelain)
git_update "${args[@]}"
fi