Commit cd94dd02 authored by Junio C Hamano's avatar Junio C Hamano

Merge branch 'ab/drop-contrib-examples'

* ab/drop-contrib-examples:
  Remove contrib/examples/*
parents 0b0cc9f8 49eb8d39
These are original scripted implementations, kept primarily for their This directory used to contain scripted implementations of builtins
reference value to any aspiring plumbing users who want to learn how that have since been rewritten in C.
pieces can be fit together.
They have now been removed, but can be retrieved from an older commit
that removed them from this directory.
They're interesting for their reference value to any aspiring plumbing
users who want to learn how pieces can be fit together, but in many
cases have drifted enough from the actual implementations Git uses to
be instructive.
Other things that can be useful:
* Some commands such as git-gc wrap other commands, and what they're
doing behind the scenes can be seen by running them under
GIT_TRACE=1
* Doing `git log` on paths matching '*--helper.c' will show
incremental effort in the direction of moving existing shell
scripts to C.
This diff is collapsed.
This diff is collapsed.
#!/bin/sh
OPTIONS_KEEPDASHDASH=t
OPTIONS_SPEC="\
git-checkout [options] [<branch>] [<paths>...]
--
b= create a new branch started at <branch>
l create the new branch's reflog
track arrange that the new branch tracks the remote branch
f proceed even if the index or working tree is not HEAD
m merge local modifications into the new branch
q,quiet be quiet
"
SUBDIRECTORY_OK=Sometimes
. git-sh-setup
require_work_tree
old_name=HEAD
old=$(git rev-parse --verify $old_name 2>/dev/null)
oldbranch=$(git symbolic-ref $old_name 2>/dev/null)
new=
new_name=
force=
branch=
track=
newbranch=
newbranch_log=
merge=
quiet=
v=-v
LF='
'
while test $# != 0; do
case "$1" in
-b)
shift
newbranch="$1"
[ -z "$newbranch" ] &&
die "git checkout: -b needs a branch name"
git show-ref --verify --quiet -- "refs/heads/$newbranch" &&
die "git checkout: branch $newbranch already exists"
git check-ref-format "heads/$newbranch" ||
die "git checkout: we do not like '$newbranch' as a branch name."
;;
-l)
newbranch_log=-l
;;
--track|--no-track)
track="$1"
;;
-f)
force=1
;;
-m)
merge=1
;;
-q|--quiet)
quiet=1
v=
;;
--)
shift
break
;;
*)
usage
;;
esac
shift
done
arg="$1"
rev=$(git rev-parse --verify "$arg" 2>/dev/null)
if rev=$(git rev-parse --verify "$rev^0" 2>/dev/null)
then
[ -z "$rev" ] && die "unknown flag $arg"
new_name="$arg"
if git show-ref --verify --quiet -- "refs/heads/$arg"
then
rev=$(git rev-parse --verify "refs/heads/$arg^0")
branch="$arg"
fi
new="$rev"
shift
elif rev=$(git rev-parse --verify "$rev^{tree}" 2>/dev/null)
then
# checking out selected paths from a tree-ish.
new="$rev"
new_name="$rev^{tree}"
shift
fi
[ "$1" = "--" ] && shift
case "$newbranch,$track" in
,--*)
die "git checkout: --track and --no-track require -b"
esac
case "$force$merge" in
11)
die "git checkout: -f and -m are incompatible"
esac
# The behaviour of the command with and without explicit path
# parameters is quite different.
#
# Without paths, we are checking out everything in the work tree,
# possibly switching branches. This is the traditional behaviour.
#
# With paths, we are _never_ switching branch, but checking out
# the named paths from either index (when no rev is given),
# or the named tree-ish (when rev is given).
if test "$#" -ge 1
then
hint=
if test "$#" -eq 1
then
hint="
Did you intend to checkout '$@' which can not be resolved as commit?"
fi
if test '' != "$newbranch$force$merge"
then
die "git checkout: updating paths is incompatible with switching branches/forcing$hint"
fi
if test '' != "$new"
then
# from a specific tree-ish; note that this is for
# rescuing paths and is never meant to remove what
# is not in the named tree-ish.
git ls-tree --full-name -r "$new" "$@" |
git update-index --index-info || exit $?
fi
# Make sure the request is about existing paths.
git ls-files --full-name --error-unmatch -- "$@" >/dev/null || exit
git ls-files --full-name -- "$@" |
(cd_to_toplevel && git checkout-index -f -u --stdin)
# Run a post-checkout hook -- the HEAD does not change so the
# current HEAD is passed in for both args
if test -x "$GIT_DIR"/hooks/post-checkout; then
"$GIT_DIR"/hooks/post-checkout $old $old 0
fi
exit $?
else
# Make sure we did not fall back on $arg^{tree} codepath
# since we are not checking out from an arbitrary tree-ish,
# but switching branches.
if test '' != "$new"
then
git rev-parse --verify "$new^{commit}" >/dev/null 2>&1 ||
die "Cannot switch branch to a non-commit."
fi
fi
# We are switching branches and checking out trees, so
# we *NEED* to be at the toplevel.
cd_to_toplevel
[ -z "$new" ] && new=$old && new_name="$old_name"
# If we don't have an existing branch that we're switching to,
# and we don't have a new branch name for the target we
# are switching to, then we are detaching our HEAD from any
# branch. However, if "git checkout HEAD" detaches the HEAD
# from the current branch, even though that may be logically
# correct, it feels somewhat funny. More importantly, we do not
# want "git checkout" or "git checkout -f" to detach HEAD.
detached=
detach_warn=
describe_detached_head () {
test -n "$quiet" || {
printf >&2 "$1 "
GIT_PAGER= git log >&2 -1 --pretty=oneline --abbrev-commit "$2" --
}
}
if test -z "$branch$newbranch" && test "$new_name" != "$old_name"
then
detached="$new"
if test -n "$oldbranch" && test -z "$quiet"
then
detach_warn="Note: moving to \"$new_name\" which isn't a local branch
If you want to create a new branch from this checkout, you may do so
(now or later) by using -b with the checkout command again. Example:
git checkout -b <new_branch_name>"
fi
elif test -z "$oldbranch" && test "$new" != "$old"
then
describe_detached_head 'Previous HEAD position was' "$old"
fi
if [ "X$old" = X ]
then
if test -z "$quiet"
then
echo >&2 "warning: You appear to be on a branch yet to be born."
echo >&2 "warning: Forcing checkout of $new_name."
fi
force=1
fi
if [ "$force" ]
then
git read-tree $v --reset -u $new
else
git update-index --refresh >/dev/null
git read-tree $v -m -u --exclude-per-directory=.gitignore $old $new || (
case "$merge,$v" in
,*)
exit 1 ;;
1,)
;; # quiet
*)
echo >&2 "Falling back to 3-way merge..." ;;
esac
# Match the index to the working tree, and do a three-way.
git diff-files --name-only | git update-index --remove --stdin &&
work=$(git write-tree) &&
git read-tree $v --reset -u $new || exit
eval GITHEAD_$new='${new_name:-${branch:-$new}}' &&
eval GITHEAD_$work=local &&
export GITHEAD_$new GITHEAD_$work &&
git merge-recursive $old -- $new $work
# Do not register the cleanly merged paths in the index yet.
# this is not a real merge before committing, but just carrying
# the working tree changes along.
unmerged=$(git ls-files -u)
git read-tree $v --reset $new
case "$unmerged" in
'') ;;
*)
(
z40=0000000000000000000000000000000000000000
echo "$unmerged" |
sed -e 's/^[0-7]* [0-9a-f]* /'"0 $z40 /"
echo "$unmerged"
) | git update-index --index-info
;;
esac
exit 0
)
saved_err=$?
if test "$saved_err" = 0 && test -z "$quiet"
then
git diff-index --name-status "$new"
fi
(exit $saved_err)
fi
#
# Switch the HEAD pointer to the new branch if we
# checked out a branch head, and remove any potential
# old MERGE_HEAD's (subsequent commits will clearly not
# be based on them, since we re-set the index)
#
if [ "$?" -eq 0 ]; then
if [ "$newbranch" ]; then
git branch $track $newbranch_log "$newbranch" "$new_name" || exit
branch="$newbranch"
fi
if test -n "$branch"
then
old_branch_name=$(expr "z$oldbranch" : 'zrefs/heads/\(.*\)')
GIT_DIR="$GIT_DIR" git symbolic-ref -m "checkout: moving from ${old_branch_name:-$old} to $branch" HEAD "refs/heads/$branch"
if test -n "$quiet"
then
true # nothing
elif test "refs/heads/$branch" = "$oldbranch"
then
echo >&2 "Already on branch \"$branch\""
else
echo >&2 "Switched to${newbranch:+ a new} branch \"$branch\""
fi
elif test -n "$detached"
then
old_branch_name=$(expr "z$oldbranch" : 'zrefs/heads/\(.*\)')
git update-ref --no-deref -m "checkout: moving from ${old_branch_name:-$old} to $arg" HEAD "$detached" ||
die "Cannot detach HEAD"
if test -n "$detach_warn"
then
echo >&2 "$detach_warn"
fi
describe_detached_head 'HEAD is now at' HEAD
fi
rm -f "$GIT_DIR/MERGE_HEAD"
else
exit 1
fi
# Run a post-checkout hook
if test -x "$GIT_DIR"/hooks/post-checkout; then
"$GIT_DIR"/hooks/post-checkout $old $new 1
fi
#!/bin/sh
#
# Copyright (c) 2005-2006 Pavel Roskin
#
OPTIONS_KEEPDASHDASH=
OPTIONS_SPEC="\
git-clean [options] <paths>...
Clean untracked files from the working directory
When optional <paths>... arguments are given, the paths
affected are further limited to those that match them.
--
d remove directories as well
f override clean.requireForce and clean anyway
n don't remove anything, just show what would be done
q be quiet, only report errors
x remove ignored files as well
X remove only ignored files"
SUBDIRECTORY_OK=Yes
. git-sh-setup
require_work_tree
ignored=
ignoredonly=
cleandir=
rmf="rm -f --"
rmrf="rm -rf --"
rm_refuse="echo Not removing"
echo1="echo"
disabled=$(git config --bool clean.requireForce)
while test $# != 0
do
case "$1" in
-d)
cleandir=1
;;
-f)
disabled=false
;;
-n)
disabled=false
rmf="echo Would remove"
rmrf="echo Would remove"
rm_refuse="echo Would not remove"
echo1=":"
;;
-q)
echo1=":"
;;
-x)
ignored=1
;;
-X)
ignoredonly=1
;;
--)
shift
break
;;
*)
usage # should not happen
;;
esac
shift
done
# requireForce used to default to false but now it defaults to true.
# IOW, lack of explicit "clean.requireForce = false" is taken as
# "clean.requireForce = true".
case "$disabled" in
"")
die "clean.requireForce not set and -n or -f not given; refusing to clean"
;;
"true")
die "clean.requireForce set and -n or -f not given; refusing to clean"
;;
esac
if [ "$ignored,$ignoredonly" = "1,1" ]; then
die "-x and -X cannot be set together"
fi
if [ -z "$ignored" ]; then
excl="--exclude-per-directory=.gitignore"
excl_info= excludes_file=
if [ -f "$GIT_DIR/info/exclude" ]; then
excl_info="--exclude-from=$GIT_DIR/info/exclude"
fi
if cfg_excl=$(git config core.excludesfile) && test -f "$cfg_excl"
then
excludes_file="--exclude-from=$cfg_excl"
fi
if [ "$ignoredonly" ]; then
excl="$excl --ignored"
fi
fi
git ls-files --others --directory \
$excl ${excl_info:+"$excl_info"} ${excludes_file:+"$excludes_file"} \
-- "$@" |
while read -r file; do
if [ -d "$file" -a ! -L "$file" ]; then
if [ -z "$cleandir" ]; then
$rm_refuse "$file"
continue
fi
$echo1 "Removing $file"
$rmrf "$file"
else
$echo1 "Removing $file"
$rmf "$file"
fi
done
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
#!/bin/sh
#
USAGE='<fetch-options> <repository> <refspec>...'
SUBDIRECTORY_OK=Yes
. git-sh-setup
set_reflog_action "fetch $*"
cd_to_toplevel ;# probably unnecessary...
. git-parse-remote
_x40='[0-9a-f][0-9a-f][0-9a-f][0-9a-f][0-9a-f]'
_x40="$_x40$_x40$_x40$_x40$_x40$_x40$_x40$_x40"
LF='
'
IFS="$LF"
no_tags=
tags=
append=
force=
verbose=
update_head_ok=
exec=
keep=
shallow_depth=
no_progress=
test -t 1 || no_progress=--no-progress
quiet=
while test $# != 0
do
case "$1" in
-a|--a|--ap|--app|--appe|--appen|--append)
append=t
;;
--upl|--uplo|--uploa|--upload|--upload-|--upload-p|\
--upload-pa|--upload-pac|--upload-pack)
shift
exec="--upload-pack=$1"
;;
--upl=*|--uplo=*|--uploa=*|--upload=*|\
--upload-=*|--upload-p=*|--upload-pa=*|--upload-pac=*|--upload-pack=*)
exec=--upload-pack=$(expr "z$1" : 'z-[^=]*=\(.*\)')
shift
;;
-f|--f|--fo|--for|--forc|--force)
force=t
;;
-t|--t|--ta|--tag|--tags)
tags=t
;;
-n|--n|--no|--no-|--no-t|--no-ta|--no-tag|--no-tags)
no_tags=t
;;
-u|--u|--up|--upd|--upda|--updat|--update|--update-|--update-h|\
--update-he|--update-hea|--update-head|--update-head-|\
--update-head-o|--update-head-ok)
update_head_ok=t
;;
-q|--q|--qu|--qui|--quie|--quiet)
quiet=--quiet
;;
-v|--verbose)
verbose="$verbose"Yes
;;
-k|--k|--ke|--kee|--keep)
keep='-k -k'
;;
--depth=*)
shallow_depth="--depth=$(expr "z$1" : 'z-[^=]*=\(.*\)')"
;;
--depth)
shift
shallow_depth="--depth=$1"
;;
-*)
usage
;;
*)
break
;;
esac
shift
done
case "$#" in
0)
origin=$(get_default_remote)
test -n "$(get_remote_url ${origin})" ||
die "Where do you want to fetch from today?"
set x $origin ; shift ;;
esac
if test -z "$exec"
then
# No command line override and we have configuration for the remote.
exec="--upload-pack=$(get_uploadpack $1)"
fi
remote_nick="$1"
remote=$(get_remote_url "$@")
refs=
rref=
rsync_slurped_objects=
if test "" = "$append"
then
: >"$GIT_DIR/FETCH_HEAD"
fi
# Global that is reused later
ls_remote_result=$(git ls-remote $exec "$remote") ||
die "Cannot get the repository state from $remote"
append_fetch_head () {
flags=
test -n "$verbose" && flags="$flags$LF-v"
test -n "$force$single_force" && flags="$flags$LF-f"
GIT_REFLOG_ACTION="$GIT_REFLOG_ACTION" \
git fetch--tool $flags append-fetch-head "$@"
}
# updating the current HEAD with git-fetch in a bare
# repository is always fine.
if test -z "$update_head_ok" && test $(is_bare_repository) = false
then
orig_head=$(git rev-parse --verify HEAD 2>/dev/null)
fi
# Allow --tags/--notags from remote.$1.tagopt
case "$tags$no_tags" in
'')
case "$(git config --get "remote.$1.tagopt")" in
--tags)
tags=t ;;
--no-tags)
no_tags=t ;;
esac
esac
# If --tags (and later --heads or --all) is specified, then we are
# not talking about defaults stored in Pull: line of remotes or
# branches file, and just fetch those and refspecs explicitly given.
# Otherwise we do what we always did.
reflist=$(get_remote_refs_for_fetch "$@")
if test "$tags"
then
taglist=$(IFS=' ' &&
echo "$ls_remote_result" |
git show-ref --exclude-existing=refs/tags/ |
while read sha1 name
do
echo ".${name}:${name}"
done) || exit
if test "$#" -gt 1
then
# remote URL plus explicit refspecs; we need to merge them.
reflist="$reflist$LF$taglist"
else
# No explicit refspecs; fetch tags only.
reflist=$taglist
fi
fi
fetch_all_at_once () {
eval=$(echo "$1" | git fetch--tool parse-reflist "-")
eval "$eval"
( : subshell because we muck with IFS
IFS=" $LF"
(
if test "$remote" = . ; then
git show-ref $rref || echo failed "$remote"
elif test -f "$remote" ; then
test -n "$shallow_depth" &&
die "shallow clone with bundle is not supported"
git bundle unbundle "$remote" $rref ||
echo failed "$remote"
else
if test -d "$remote" &&
# The remote might be our alternate. With
# this optimization we will bypass fetch-pack
# altogether, which means we cannot be doing
# the shallow stuff at all.
test ! -f "$GIT_DIR/shallow" &&
test -z "$shallow_depth" &&
# See if all of what we are going to fetch are
# connected to our repository's tips, in which
# case we do not have to do any fetch.
theirs=$(echo "$ls_remote_result" | \
git fetch--tool -s pick-rref "$rref" "-") &&
# This will barf when $theirs reach an object that
# we do not have in our repository. Otherwise,
# we already have everything the fetch would bring in.
git rev-list --objects $theirs --not --all \
>/dev/null 2>/dev/null
then
echo "$ls_remote_result" | \
git fetch--tool pick-rref "$rref" "-"
else
flags=
case $verbose in
YesYes*)
flags="-v"
;;
esac
git-fetch-pack --thin $exec $keep $shallow_depth \
$quiet $no_progress $flags "$remote" $rref ||
echo failed "$remote"
fi
fi
) |
(
flags=
test -n "$verbose" && flags="$flags -v"
test -n "$force" && flags="$flags -f"
GIT_REFLOG_ACTION="$GIT_REFLOG_ACTION" \
git fetch--tool $flags native-store \
"$remote" "$remote_nick" "$refs"
)
) || exit
}
fetch_per_ref () {
reflist="$1"
refs=
rref=
for ref in $reflist
do
refs="$refs$LF$ref"
# These are relative path from $GIT_DIR, typically starting at refs/
# but may be HEAD
if expr "z$ref" : 'z\.' >/dev/null
then
not_for_merge=t
ref=$(expr "z$ref" : 'z\.\(.*\)')
else
not_for_merge=
fi
if expr "z$ref" : 'z+' >/dev/null
then
single_force=t
ref=$(expr "z$ref" : 'z+\(.*\)')
else
single_force=
fi
remote_name=$(expr "z$ref" : 'z\([^:]*\):')
local_name=$(expr "z$ref" : 'z[^:]*:\(.*\)')
rref="$rref$LF$remote_name"
# There are transports that can fetch only one head at a time...
case "$remote" in
http://* | https://* | ftp://*)
test -n "$shallow_depth" &&
die "shallow clone with http not supported"
proto=$(expr "$remote" : '\([^:]*\):')
if [ -n "$GIT_SSL_NO_VERIFY" ]; then
curl_extra_args="-k"
fi
if [ -n "$GIT_CURL_FTP_NO_EPSV" -o \
"$(git config --bool http.noEPSV)" = true ]; then
noepsv_opt="--disable-epsv"
fi
# Find $remote_name from ls-remote output.
head=$(echo "$ls_remote_result" | \
git fetch--tool -s pick-rref "$remote_name" "-")
expr "z$head" : "z$_x40\$" >/dev/null ||
die "No such ref $remote_name at $remote"
echo >&2 "Fetching $remote_name from $remote using $proto"
case "$quiet" in '') v=-v ;; *) v= ;; esac
git-http-fetch $v -a "$head" "$remote" || exit
;;
rsync://*)
test -n "$shallow_depth" &&
die "shallow clone with rsync not supported"
TMP_HEAD="$GIT_DIR/TMP_HEAD"
rsync -L -q "$remote/$remote_name" "$TMP_HEAD" || exit 1
head=$(git rev-parse --verify TMP_HEAD)