Merge changes from master.

Documentation/git-cvsimport-script.txt

@@ -11,7 +11,8 @@ SYNOPSIS
 --------
 'git-cvsimport-script' [ -o <branch-for-HEAD> ] [ -h ] [ -v ]
 			[ -d <CVSROOT> ] [ -p <options-for-cvsps> ]
-			[ -C <GIT_repository> ] [ -i ] [ -k ] [ <CVS_module> ]
+			[ -C <GIT_repository> ] [ -i ] [ -k ]
+			[ -s <subst> ] [ <CVS_module> ]
 
 
 DESCRIPTION
@@ -69,6 +70,9 @@ OPTIONS
 -z <fuzz>::
         Pass the timestamp fuzz factor to cvsps.
 
+-s <subst>::
+	Substitute the character "/" in branch names with <subst>
+
 OUTPUT
 ------
 If '-v' is specified, the script reports what it is doing.

Documentation/glossary.txt

@@ -0,0 +1,198 @@
+object::
+	The unit of storage in GIT. It is uniquely identified by
+	the SHA1 of its contents. Consequently, an object can not
+	be changed.
+
+SHA1::
+	A 20-byte sequence (or 41-byte file containing the hex
+	representation and a newline). It is calculated from the
+	contents of an object by the Secure Hash Algorithm 1.
+
+object database::
+	Stores a set of "objects", and an individial object is identified
+	by its SHA1 (its ref). The objects are either stored as single
+	files, or live inside of packs.
+
+object name::
+	Synonym for SHA1.
+
+blob object::
+	Untyped object, i.e. the contents of a file.
+
+tree object::
+	An object containing a list of blob and/or tree objects.
+	(A tree usually corresponds to a directory without
+	subdirectories).
+
+tree::
+	Either a working tree, or a tree object together with the
+	dependent blob and tree objects (i.e. a stored representation
+	of a working tree).
+
+cache::
+	A collection of files whose contents are stored as objects.
+	The cache is a stored version of your working tree. Well, can
+	also contain a second, and even a third version of a working
+	tree, which are used when merging.
+
+cache entry::
+	The information regarding a particular file, stored in the index.
+	A cache entry can be unmerged, if a merge was started, but not
+	yet finished (i.e. if the cache contains multiple versions of
+	that file).
+
+index::
+	Contains information about the cache contents, in particular
+	timestamps and mode flags ("stat information") for the files
+	stored in the cache. An unmerged index is an index which contains
+	unmerged cache entries.
+
+working tree::
+	The set of files and directories currently being worked on.
+	Think "ls -laR"
+
+directory::
+	The list you get with "ls" :-)
+
+checkout::
+	The action of updating the working tree to a revision which was
+	stored in the object database.
+
+revision::
+	A particular state of files and directories which was stored in
+	the object database. It is referenced by a commit object.
+
+commit::
+	The action of storing the current state of the cache in the
+	object database. The result is a revision.
+
+commit object::
+	An object which contains the information about a particular
+	revision, such as parents, committer, author, date and the
+	tree object which corresponds to the top directory of the
+	stored revision.
+
+changeset::
+	BitKeeper/cvsps speak for "commit". Since git does not store
+	changes, but states, it really does not make sense to use
+	the term "changesets" with git.
+
+ent::
+	Favorite synonym to "tree-ish" by some total geeks.
+
+clean::
+	A working tree is clean, if it corresponds to the revision
+	referenced by the current head.
+
+dirty::
+	A working tree is said to be dirty if it contains modifications
+	which have not been committed to the current branch.
+
+head::
+	The top of a branch. It contains a ref to the corresponding
+	commit object.
+
+branch::
+	A non-cyclical graph of revisions, i.e. the complete history of
+	a particular revision, which does not (yet) have children, which
+	is called the branch head. The branch heads are stored in
+	$GIT_DIR/refs/heads/.
+
+ref::
+	A 40-byte hex representation of a SHA1 pointing to a particular
+	object. These are stored in $GIT_DIR/refs/.
+
+head ref::
+	A ref pointing to a head. Often, this is abbreviated to "head".
+	Head refs are stored in $GIT_DIR/refs/heads/.
+
+tree-ish::
+	A ref pointing to either a commit object, a tree object, or a
+	tag object pointing to a commit or tree object.
+
+tag object::
+	An object containing a ref pointing to another object. It can
+	contain a (PGP) signature, in which case it is called "signed
+	tag object".
+
+tag::
+	A ref pointing to a tag or commit object. In contrast to a head,
+	a tag is not changed by a commit. Tags (not tag objects) are
+	stored in $GIT_DIR/refs/tags/. A git tag has nothing to do with
+	a Lisp tag (which is called object type in git's context).
+
+merge::
+	To merge branches means to try to accumulate the changes since a
+	common ancestor and apply them to the first branch. An automatic
+	merge uses heuristics to accomplish that. Evidently, an automatic
+	merge can fail.
+
+resolve::
+	The action of fixing up manually what a failed automatic merge
+	left behind.
+
+repository::
+	A collection of refs together with an object database containing
+	all objects, which are reachable from the refs. A repository can
+	share an object database with other repositories.
+
+alternate object database::
+	Via the alternates mechanism, a repository can inherit part of its
+	object database from another object database, which is called
+	"alternate".
+
+reachable::
+	An object is reachable from a ref/commit/tree/tag, if there is a
+	chain leading from the latter to the former.
+
+chain::
+	A list of objects, where each object in the list contains a
+	reference to its successor (for example, the successor of a commit
+	could be one of its parents).
+
+parent::
+	A commit object contains a (possibly empty) list of the logical
+	predecessor(s) in the line of development, i.e. its parents.
+
+fetch::
+	Fetching a branch means to get the branch's head ref from a
+	remote repository, to find out which objects are missing from
+	the local object database, and to get them, too.
+
+pull::
+	Pulling a branch means to fetch it and merge it.
+
+push::
+	Pushing a branch means to get the branch's head ref from a remote
+	repository, find out if it is an ancestor to the branch's local
+	head ref is a direct, and in that case, putting all objects, which
+	are reachable from the local head ref, and which are missing from
+	the remote repository, into the remote object database, and updating
+	the remote head ref. If the remote head is not an ancestor to the
+	local head, the push fails.
+
+pack::
+	A set of objects which have been compressed into one file (to save
+	space or to transmit them efficiently).
+
+pack index::
+	Contains offsets into a pack, so the pack can be used instead of
+	the unpacked objects.
+
+plumbing::
+	Cute name for core git.
+
+porcelain::
+	Cute name for programs and program suites depending on core git,
+	presenting a high level access to core git. Porcelains expose
+	more of a SCM interface than the plumbing.
+
+object type:
+	One of the identifiers "commit","tree","tag" and "blob" describing
+	the type of an object.
+
+SCM::
+	Source code management (tool).
+
+dircache::
+	You are *waaaaay* behind.

Documentation/tutorial.txt

@@ -891,7 +891,7 @@ an empty directory:
 	mkdir my-git.git
 
 Then, make that directory into a GIT repository by running
-git-init-db, but this time, since it's name is not the usual
+git-init-db, but this time, since its name is not the usual
 ".git", we do things slightly differently:
 
 	GIT_DIR=my-git.git git-init-db

README

@@ -98,12 +98,12 @@ contents").
 In particular, since the blob is entirely defined by its data, if two
 files in a directory tree (or in multiple different versions of the
 repository) have the same contents, they will share the same blob
-object. The object is totally independent of it's location in the
+object. The object is totally independent of its location in the
 directory tree, and renaming a file does not change the object that
 file is associated with in any way.
 
 A blob is typically created when link:git-update-cache.html[git-update-cache]
-is run, and it's data can be accessed by link:git-cat-file.html[git-cat-file].
+is run, and its data can be accessed by link:git-cat-file.html[git-cat-file].
 
 Tree Object
 ~~~~~~~~~~~
@@ -142,7 +142,7 @@ noticing that the blob stayed the same.  However, renames with data
 changes need a smarter "diff" implementation.
 
 A tree is created with link:git-write-tree.html[git-write-tree] and
-it's data can be accessed by link:git-ls-tree.html[git-ls-tree]
+its data can be accessed by link:git-ls-tree.html[git-ls-tree]
 
 Commit Object
 ~~~~~~~~~~~~~
@@ -167,7 +167,7 @@ of the parents), and describing that makes no sense in this idiotic
 file manager.
 
 A commit is created with link:git-commit-tree.html[git-commit-tree] and
-it's data can be accessed by link:git-cat-file.html[git-cat-file]
+its data can be accessed by link:git-cat-file.html[git-cat-file]
 
 Trust
 ~~~~~
@@ -213,7 +213,7 @@ integrity; the trust framework (and signature provision and
 verification) has to come from outside.
 
 A tag is created with link:git-mktag.html[git-mktag] and
-it's data can be accessed by link:git-cat-file.html[git-cat-file]
+its data can be accessed by link:git-cat-file.html[git-cat-file]
 
 
 The "index" aka "Current Directory Cache"

apply.c

@@ -1043,8 +1043,12 @@ static int check_patch(struct patch *patch)
 			return error("%s: already exists in working directory", new_name);
 		if (errno != ENOENT)
 			return error("%s: %s", new_name, strerror(errno));
-		if (!patch->new_mode)
+		if (!patch->new_mode) {
-			patch->new_mode = S_IFREG | 0644;
+			if (patch->is_new)
+				patch->new_mode = S_IFREG | 0644;
+			else
+				patch->new_mode = patch->old_mode;
+		}
 	}
 
 	if (new_name && old_name) {

git-branch-script

@@ -2,16 +2,31 @@
 
 . git-sh-setup-script || die "Not a git archive"
 
-branchname="$1"
+case "$#" in
-case "$2" in
+0)
-'')
+	headref=$(readlink "$GIT_DIR/HEAD" | sed -e 's|^refs/heads/||')
+	git-rev-parse --symbolic --all |
+	sed -ne 's|^refs/heads/||p' |
+	sort |
+	while read ref
+	do
+		if test "$headref" = "$ref"
+		then
+			pfx='*'
+		else
+			pfx=' '
+		fi
+		echo "$pfx $ref"
+	done
+	exit 0 ;;
+1)
 	head=HEAD ;;
-*)
+2)
 	head="$2^0" ;;
 esac
+branchname="$1"
 rev=$(git-rev-parse --revs-only --verify "$head") || exit
 
-[ -z "$branchname" ] && die "git branch: I want a branch name"
 [ -e "$GIT_DIR/refs/heads/$branchname" ] && die "$branchname already exists"
 
 echo $rev > "$GIT_DIR/refs/heads/$branchname"

git-commit-script

@@ -88,9 +88,14 @@ esac
 case "$all" in
 t)
 	git-diff-files --name-only -z |
-	xargs -0 git-update-cache -q -- || exit 1 ;;
+	xargs -0 git-update-cache -q --
-esac
+	;;
-git-update-cache -q --refresh -- "$@" || exit 1
+*)
+	git-diff-files --name-only -z "$@" |
+	xargs -0 git-update-cache -q --
+	;;
+esac || exit 1
+git-update-cache -q --refresh || exit 1
 
 case "$verify" in
 t)

git-cvsimport-script

@@ -28,19 +28,19 @@ use POSIX qw(strftime dup2);
 $SIG{'PIPE'}="IGNORE";
 $ENV{'TZ'}="UTC";
 
-our($opt_h,$opt_o,$opt_v,$opt_k,$opt_d,$opt_p,$opt_C,$opt_z,$opt_i);
+our($opt_h,$opt_o,$opt_v,$opt_k,$opt_d,$opt_p,$opt_C,$opt_z,$opt_i,$opt_s);
 
 sub usage() {
 	print STDERR <<END;
 Usage: ${\basename $0}     # fetch/update GIT from CVS
        [ -o branch-for-HEAD ] [ -h ] [ -v ] [ -d CVSROOT ]
        [ -p opts-for-cvsps ] [ -C GIT_repository ] [ -z fuzz ]
-       [ -i ] [ -k ] [ CVS_module ]
+       [ -i ] [ -k ] [-s subst] [ CVS_module ]
 END
 	exit(1);
 }
 
-getopts("hivko:d:p:C:z:") or usage();
+getopts("hivko:d:p:C:z:s:") or usage();
 usage if $opt_h;
 
 @ARGV <= 1 or usage();
@@ -59,6 +59,7 @@ if($opt_d) {
 	die "CVSROOT needs to be set";
 }
 $opt_o ||= "origin";
+$opt_s ||= "-";
 my $git_tree = $opt_C;
 $git_tree ||= ".";
 
@@ -621,6 +622,7 @@ while(<CVS>) {
 		$state = 4;
 	} elsif($state == 4 and s/^Branch:\s+//) {
 		s/\s+$//;
+		s/[\/]/$opt_s/g;
 		$branch = $_;
 		$state = 5;
 	} elsif($state == 5 and s/^Ancestor branch:\s+//) {

git-format-patch-script

@@ -146,7 +146,7 @@ do
 
     file=`printf '%04d-%stxt' $i "$title"`
     i=`expr "$i" - 1`
-    echo >&2 "* $file"
+    echo "* $file"
     {
 	mailScript='
 	/./d

git-parse-remote

@@ -71,8 +71,8 @@ tag)
 	'')
 		_remote_head=HEAD ;;
 	*)
-		_remote_head="refs/heads/$_remote_head"
 		_remote_name="head '$_remote_head' of $_remote_name"
+		_remote_head="refs/heads/$_remote_head"
 		;;
 	esac
 	;;

git-show-branches-script

@@ -5,15 +5,23 @@
 
 . git-sh-setup-script || die "Not a git repository"
 
+usage () {
+    die "usage: $0 <ref>..."
+}
+
 headref=`readlink $GIT_DIR/HEAD`
-case "$#" in
+
-0)
+case "$(git-rev-parse --no-revs)" in '') ;; *) usage ;; esac
-	set x `cd $GIT_DIR/refs &&
+revs=$(git-rev-parse --revs-only --symbolic --no-flags "$@")
-	    find heads -type f -print |
+flags=$(git-rev-parse --revs-only --flags "$@")
-	    sed -e 's|heads/||' |
+case "$revs" in
-	    sort`
+'')
+	revs=$(git-rev-parse --symbolic --all | sed -ne 's|^refs/heads/||p' |
+	       sort)
 	shift ;;
 esac
+set x $revs
+shift
 
 hh= in=
 for ref
@@ -22,7 +30,7 @@ do
 	*/"$ref") H='*' ;;
 	*) H='!' ;;
 	esac
-	h=`git-rev-parse --verify "$ref^0"` || exit
+	h=`git-rev-parse --verify "$ref^0" 2>/dev/null` || continue
 	l=`git-log-script --max-count=1 --pretty=oneline "$h" |
 		sed -e 's/^[^ ]* //'`
 	hh="$hh $h"
@@ -32,7 +40,7 @@ done
 set x $hh
 shift
 
-git-rev-list --pretty=oneline "$@" |
+git-rev-list --pretty=oneline $flags $@ |
 while read v l
 do
 	in=''

rev-parse.c

@@ -16,6 +16,7 @@ static int output_revs = 0;
 static int flags_only = 0;
 static int no_flags = 0;
 static int output_sq = 0;
+static int symbolic = 0;
 
 #define NORMAL 0
 #define REVERSED 1
@@ -69,17 +70,18 @@ static void show(const char *arg)
 		puts(arg);
 }
 
-static void show_rev(int type, const unsigned char *sha1)
+static void show_rev(int type, const unsigned char *sha1, const char *name)
 {
 	if (no_revs)
 		return;
 	output_revs++;
 
-	/* Hexadecimal string plus possibly a carret;
+	if (type != show_type)
-	 * this does not have to be quoted even under output_sq.
+		putchar('^');
-	 */
+	if (symbolic && name)
-	printf("%s%s%c", type == show_type ? "" : "^", sha1_to_hex(sha1),
+		show(name);
-	       output_sq ? ' ' : '\n');
+	else
+		show(sha1_to_hex(sha1));
 }
 
 static void show_rev_arg(char *rev)
@@ -117,7 +119,7 @@ static void show_default(void)
 
 		def = NULL;
 		if (!get_sha1(s, sha1)) {
-			show_rev(NORMAL, sha1);
+			show_rev(NORMAL, sha1, s);
 			return;
 		}
 		show_arg(s);
@@ -126,7 +128,7 @@ static void show_default(void)
 
 static int show_reference(const char *refname, const unsigned char *sha1)
 {
-	show_rev(NORMAL, sha1);
+	show_rev(NORMAL, sha1, refname);
 	return 0;
 }
 
@@ -186,6 +188,10 @@ int main(int argc, char **argv)
 				show_type ^= REVERSED;
 				continue;
 			}
+			if (!strcmp(arg, "--symbolic")) {
+				symbolic = 1;
+				continue;
+			}
 			if (!strcmp(arg, "--all")) {
 				for_each_ref(show_reference);
 				continue;
@@ -209,8 +215,8 @@ int main(int argc, char **argv)
 					if (no_revs)
 						continue;
 					def = NULL;
-					show_rev(NORMAL, end);
+					show_rev(NORMAL, end, n);
-					show_rev(REVERSED, sha1);
+					show_rev(REVERSED, sha1, arg);
 					continue;
 				}
 			}
@@ -220,14 +226,14 @@ int main(int argc, char **argv)
 			if (no_revs)
 				continue;
 			def = NULL;
-			show_rev(NORMAL, sha1);
+			show_rev(NORMAL, sha1, arg);
 			continue;
 		}
 		if (*arg == '^' && !get_sha1(arg+1, sha1)) {
 			if (no_revs)
 				continue;
 			def = NULL;
-			show_rev(REVERSED, sha1);
+			show_rev(REVERSED, sha1, arg+1);
 			continue;
 		}
 		show_default();

t/t4102-apply-rename.sh

@@ -0,0 +1,37 @@
+#!/bin/sh
+#
+# Copyright (c) 2005 Junio C Hamano
+#
+
+test_description='git-apply handling copy/rename patch.
+
+'
+. ./test-lib.sh
+
+# setup
+
+cat >test-patch <<\EOF
+diff --git a/foo b/bar
+similarity index 47%
+copy from foo
+copy to bar
+--- a/foo
++++ b/bar
+@@ -1 +1 @@
+-This is foo
++This is bar
+EOF
+
+echo 'This is foo' >foo
+chmod +x foo
+
+test_expect_success setup \
+    'git-update-cache --add foo'
+
+test_expect_success apply \
+    'git-apply --index --stat --summary --apply test-patch'
+
+test_expect_success validate \
+    'test -f bar && ls -l bar | grep "^-..x..x..x"'
+
+test_done