--------
'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
-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.
--- /dev/null
+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.
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
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
~~~~~~~~~~~
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
~~~~~~~~~~~~~
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
~~~~~
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"
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)
- patch->new_mode = S_IFREG | 0644;
+ if (!patch->new_mode) {
+ if (patch->is_new)
+ patch->new_mode = S_IFREG | 0644;
+ else
+ patch->new_mode = patch->old_mode;
+ }
}
if (new_name && old_name) {
. git-sh-setup-script || die "Not a git archive"
-branchname="$1"
-case "$2" in
-'')
+case "$#" 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"
case "$all" in
t)
git-diff-files --name-only -z |
- xargs -0 git-update-cache -q -- || exit 1 ;;
-esac
-git-update-cache -q --refresh -- "$@" || exit 1
+ xargs -0 git-update-cache -q --
+ ;;
+*)
+ 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)
$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();
die "CVSROOT needs to be set";
}
$opt_o ||= "origin";
+$opt_s ||= "-";
my $git_tree = $opt_C;
$git_tree ||= ".";
$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+//) {
file=`printf '%04d-%stxt' $i "$title"`
i=`expr "$i" - 1`
- echo >&2 "* $file"
+ echo "* $file"
{
mailScript='
/./d
'')
_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-sh-setup-script || die "Not a git repository"
+usage () {
+ die "usage: $0 <ref>..."
+}
+
headref=`readlink $GIT_DIR/HEAD`
-case "$#" in
-0)
- set x `cd $GIT_DIR/refs &&
- find heads -type f -print |
- sed -e 's|heads/||' |
- sort`
+
+case "$(git-rev-parse --no-revs)" in '') ;; *) usage ;; esac
+revs=$(git-rev-parse --revs-only --symbolic --no-flags "$@")
+flags=$(git-rev-parse --revs-only --flags "$@")
+case "$revs" in
+'')
+ revs=$(git-rev-parse --symbolic --all | sed -ne 's|^refs/heads/||p' |
+ sort)
shift ;;
esac
+set x $revs
+shift
hh= in=
for ref
*/"$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"
set x $hh
shift
-git-rev-list --pretty=oneline "$@" |
+git-rev-list --pretty=oneline $flags $@ |
while read v l
do
in=''
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
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;
- * this does not have to be quoted even under output_sq.
- */
- printf("%s%s%c", type == show_type ? "" : "^", sha1_to_hex(sha1),
- output_sq ? ' ' : '\n');
+ if (type != show_type)
+ putchar('^');
+ if (symbolic && name)
+ show(name);
+ else
+ show(sha1_to_hex(sha1));
}
static void show_rev_arg(char *rev)
def = NULL;
if (!get_sha1(s, sha1)) {
- show_rev(NORMAL, sha1);
+ show_rev(NORMAL, sha1, s);
return;
}
show_arg(s);
static int show_reference(const char *refname, const unsigned char *sha1)
{
- show_rev(NORMAL, sha1);
+ show_rev(NORMAL, sha1, refname);
return 0;
}
show_type ^= REVERSED;
continue;
}
+ if (!strcmp(arg, "--symbolic")) {
+ symbolic = 1;
+ continue;
+ }
if (!strcmp(arg, "--all")) {
for_each_ref(show_reference);
continue;
if (no_revs)
continue;
def = NULL;
- show_rev(NORMAL, end);
- show_rev(REVERSED, sha1);
+ show_rev(NORMAL, end, n);
+ show_rev(REVERSED, sha1, arg);
continue;
}
}
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();
--- /dev/null
+#!/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
projects / git.git / commitdiff