Any way to get complete diff up to a tag?

Any way to get complete diff up to a tag?

[Peter Kjellerstedt]

If I use

$ git diff v1.7.1..

I get a diff for everything that has happened after the v1.7.1
release (up to HEAD). Is there a way to do the opposite, i.e.,
get everything (including the initial commit) up to and including 
v1.7.1? I first tried  

$ git diff ..v1.7.1

but it gave me the reverse of the above, which I later found out 
was due to it being the same as

$ git diff HEAD..v1.7.1

which of course does not yield the result I want. 

If I use

$ git diff $(git rev-list --reverse v1.7.1 |head -1)..v1.7.1

I almost get what I want, but the initial commit is still missing.
Is there any way to get that initial commit included in the diff?

Basically, what I think I am asking for is a way to specify the 
empty parent of the initial commit, i.e., where v1.7.1~1000000 would
end up. I can see this being useful in at least one other case as 
well, namely when doing an interactive rebase to allow the initial
commit to be rebased (something I have wanted to do a couple of 
times...)

//Peter

Re: Any way to get complete diff up to a tag?

[Bert Wesarg]

On Thu, May 6, 2010 at 11:27, Peter Kjellerstedt
<peter.kjellerstedt@axis.com> wrote:
> I almost get what I want, but the initial commit is still missing.
> Is there any way to get that initial commit included in the diff?

git diff-tree -p 4b825dc642cb6eb9a060e54bf8d69288fbee4904 v1.7.1^{tree}

Bert

Re: Any way to get complete diff up to a tag?

[Björn Steinbrink]

On 2010.05.06 11:27:40 +0200, Peter Kjellerstedt wrote:
> If I use
> 
> $ git diff $(git rev-list --reverse v1.7.1 |head -1)..v1.7.1
> 
> I almost get what I want, but the initial commit is still missing.
> Is there any way to get that initial commit included in the diff?

git internally knows about the empty tree, so you can use:
git diff 4b825dc642cb6eb9a060e54bf8d69288fbee4904 v1.7.1

Björn

RE: Any way to get complete diff up to a tag?

[Peter Kjellerstedt]

> -----Original Message-----
> From: git-owner@vger.kernel.org [mailto:git-owner@vger.kernel.org] On
> Behalf Of Björn Steinbrink
> Sent: den 6 maj 2010 11:42
> To: Peter Kjellerstedt
> Cc: git@vger.kernel.org
> Subject: Re: Any way to get complete diff up to a tag?
> 
> On 2010.05.06 11:27:40 +0200, Peter Kjellerstedt wrote:
> > If I use
> >
> > $ git diff $(git rev-list --reverse v1.7.1 |head -1)..v1.7.1
> >
> > I almost get what I want, but the initial commit is still missing.
> > Is there any way to get that initial commit included in the diff?
> 
> git internally knows about the empty tree, so you can use:
> git diff 4b825dc642cb6eb9a060e54bf8d69288fbee4904 v1.7.1
> 
> Björn

Thank you, that was useful. However, I need to be able to do this
for an arbitrary repository, and that SHA seems to be specific for 
the git repository. How do I get the SHA for the empty tree in an 
arbitrary repository?

//Peter

Re: Any way to get complete diff up to a tag?

[Santi Béjar]

2010/5/6 Peter Kjellerstedt <peter.kjellerstedt@axis.com>:
>> -----Original Message-----
>> From: git-owner@vger.kernel.org [mailto:git-owner@vger.kernel.org] On
>> Behalf Of Björn Steinbrink
>>
>> On 2010.05.06 11:27:40 +0200, Peter Kjellerstedt wrote:
>> > If I use
>> >
>> > $ git diff $(git rev-list --reverse v1.7.1 |head -1)..v1.7.1
>> >
>> > I almost get what I want, but the initial commit is still missing.
>> > Is there any way to get that initial commit included in the diff?
>>
>> git internally knows about the empty tree, so you can use:
>> git diff 4b825dc642cb6eb9a060e54bf8d69288fbee4904 v1.7.1
>>
>> Björn
>
> Thank you, that was useful. However, I need to be able to do this
> for an arbitrary repository, and that SHA seems to be specific for
> the git repository. How do I get the SHA for the empty tree in an
> arbitrary repository?

It is not specific for the git repository, there is only one SHA1 for
the empty tree. But it is hard-coded in git itself since 1.5.5. If you
use an older git you have to create it yourself.

Santi

Re: Any way to get complete diff up to a tag?

[Johannes Sixt]

Am 5/6/2010 13:20, schrieb Peter Kjellerstedt:
> Björn Steinbrink
>> git internally knows about the empty tree, so you can use:
>> git diff 4b825dc642cb6eb9a060e54bf8d69288fbee4904 v1.7.1
>>
>> Björn
> 
> Thank you, that was useful. However, I need to be able to do this
> for an arbitrary repository, and that SHA seems to be specific for 
> the git repository. How do I get the SHA for the empty tree in an 
> arbitrary repository?

Aha, so you think Björn et.al. were able to guess the SHA1 for your
specific repository? ;)

No, the empty tree is the empty tree, and its name is as cited above, no
matter where in the universe you are.

-- Hannes

RE: Any way to get complete diff up to a tag?

[Peter Kjellerstedt]

> -----Original Message-----
> From: git-owner@vger.kernel.org [mailto:git-owner@vger.kernel.org] On
> Behalf Of Johannes Sixt
> Sent: den 6 maj 2010 15:04
> To: Peter Kjellerstedt
> Cc: Björn Steinbrink; git@vger.kernel.org
> Subject: Re: Any way to get complete diff up to a tag?
> 
> Am 5/6/2010 13:20, schrieb Peter Kjellerstedt:
> > Björn Steinbrink
> >> git internally knows about the empty tree, so you can use:
> >> git diff 4b825dc642cb6eb9a060e54bf8d69288fbee4904 v1.7.1
> >>
> >> Björn
> >
> > Thank you, that was useful. However, I need to be able to do this
> > for an arbitrary repository, and that SHA seems to be specific for
> > the git repository. How do I get the SHA for the empty tree in an
> > arbitrary repository?
> 
> Aha, so you think Björn et.al. were able to guess the SHA1 for your
> specific repository? ;)

No, not really, but I could not understand why it worked when I
tested it in my clone of git itself, but not in another git repository.

> No, the empty tree is the empty tree, and its name is as cited above,
> no matter where in the universe you are.
> 
> -- Hannes

Well, I figured out my mistake. I had abbreviated the SHA1 since I
typed it in manually, and it worked fine in git's own repository, 
but not in another repository. But when I used the full SHA1 it 
worked in both. So I guess the empty dir SHA1 hardcoded in git just 
happened to be the SHA1 for the empty dir in git's own repository...

Since the 4b825dc642cb6eb9a060e54bf8d69288fbee4904 SHA1 is somewhat
cumbersome to remember, wouldn't it be an idea to give it some kind 
of alias or mnemonic? E.g., something like @~ (or some other mix of 
odd characters which do not clash with all the other similar 
constructs already used for references).

Anyway, thanks all for the help.
//Peter

Re: Any way to get complete diff up to a tag?

[Björn Steinbrink]

On 2010.05.06 17:09:57 +0200, Peter Kjellerstedt wrote:
> 
> Well, I figured out my mistake. I had abbreviated the SHA1 since I
> typed it in manually, and it worked fine in git's own repository, 
> but not in another repository. But when I used the full SHA1 it 
> worked in both. So I guess the empty dir SHA1 hardcoded in git just 
> happened to be the SHA1 for the empty dir in git's own repository...

No, there can be only one SHA1 for the empty tree. It's the SHA1 hash of
the object, and the empty tree is the empty tree, always.

git.git just happens to actually contain that object, so the abbreviated
hash works, because git can find the object and doesn't actually need
the hardcoded built-in empty tree (which is only used when the full hash
is given).

Björn

RE: Any way to get complete diff up to a tag?

[Linus Torvalds]

On Thu, 6 May 2010, Peter Kjellerstedt wrote:
> 
> Since the 4b825dc642cb6eb9a060e54bf8d69288fbee4904 SHA1 is somewhat
> cumbersome to remember, wouldn't it be an idea to give it some kind 
> of alias or mnemonic? E.g., something like @~ (or some other mix of 
> odd characters which do not clash with all the other similar 
> constructs already used for references).

Well, you don't strictly speaking have to "remember" it, you can always 
just re-generate it. The most straightforward way to do that is probably

	git hash-object -t tree --stdin < /dev/null

although I admit that maybe we could have some syntax for "git diff" that 
would do the "diff against empty tree" automatically. It does seem to be 
conceptually a reasonable thing to do.

For example, right now if you give "git diff" a single SHA1, it will work 
against the working tree. Except if you add "--cached", to say that you 
want the diff against the index. I don't think it would be in any way 
_wrong_ to make "--root" mean that you want it against an empty tree.

[ We already accept "--root", but it has no meaning for "git diff" with a 
  single SHA1. It matters for showing the root commit for 'git-diff-tree'.

  And means something totally different for git-format-patch ]

So we certainly _could_ do something like

	git diff --root <treeish>

and make it do what you want. That said, the "empty tree" thing works for 
all versions of git (well, some older versions of git need the actual 
object, but you could always use "-w" on that git-hash-object command 
line, and then it really should work for every git version).

			Linus

Re: Any way to get complete diff up to a tag?

[Greg Troxel]

[-- Attachment #1: Type: text/plain, Size: 588 bytes --]


Linus Torvalds <torvalds@linux-foundation.org> writes:

> Well, you don't strictly speaking have to "remember" it, you can always 
> just re-generate it. The most straightforward way to do that is probably
>
> 	git hash-object -t tree --stdin < /dev/null
>
> although I admit that maybe we could have some syntax for "git diff" that 
> would do the "diff against empty tree" automatically. It does seem to be 
> conceptually a reasonable thing to do.

How about 

  git diff empty..

as if empty is a tag for the empty revision?  It works for 'git
checkout' already.


[-- Attachment #2: Type: application/pgp-signature, Size: 194 bytes --]

RE: Any way to get complete diff up to a tag?

[Peter Kjellerstedt]

[-- Attachment #1: Type: text/plain, Size: 2864 bytes --]

> -----Original Message-----
> From: git-owner@vger.kernel.org [mailto:git-owner@vger.kernel.org] On
> Behalf Of Linus Torvalds
> Sent: den 6 maj 2010 19:09
> To: Peter Kjellerstedt
> Cc: Johannes Sixt; git@vger.kernel.org; Björn Steinbrink
> Subject: RE: Any way to get complete diff up to a tag?
> 
> On Thu, 6 May 2010, Peter Kjellerstedt wrote:
> >
> > Since the 4b825dc642cb6eb9a060e54bf8d69288fbee4904 SHA1 is somewhat
> > cumbersome to remember, wouldn't it be an idea to give it some kind
> > of alias or mnemonic? E.g., something like @~ (or some other mix of
> > odd characters which do not clash with all the other similar
> > constructs already used for references).
> 
> Well, you don't strictly speaking have to "remember" it, you can always
> just re-generate it. The most straightforward way to do that is
> probably
> 
> 	git hash-object -t tree --stdin < /dev/null

Thank you, that is good to know.

> although I admit that maybe we could have some syntax for "git diff"
> that would do the "diff against empty tree" automatically. It does 
> seem to be conceptually a reasonable thing to do.
> 
> For example, right now if you give "git diff" a single SHA1, it will
> work against the working tree. Except if you add "--cached", to say 
> that you want the diff against the index. I don't think it would be in 
> any way _wrong_ to make "--root" mean that you want it against an 
> empty tree.
> 
> [ We already accept "--root", but it has no meaning for "git diff" 
>   with a single SHA1. It matters for showing the root commit for 
>   'git-diff-tree'.
> 
>   And means something totally different for git-format-patch ]
> 
> So we certainly _could_ do something like
> 
> 	git diff --root <treeish>

I went ahead and implemented support for --root as an option to git 
diff (patch attached for reference). However, I then realized that 
there are probably more commands that would benefit from the same 
support, e.g., git diff-index. Then I thought about git diff-tree
and realized that it could also benefit from my version of --root,
but as you mentioned above, it already has a --root option with
a different semantic... I also figured it would be a hassle for me 
to find all commands who can use a --root option, not knowing the 
internals of git well enough yet.

So I then went back to my original idea of making an alias for the
empty tree, and came up with a two line patch which I will send as
a separate patch, and see what you guys think of the idea.

> and make it do what you want. That said, the "empty tree" thing works
> for all versions of git (well, some older versions of git need the 
> actual object, but you could always use "-w" on that git-hash-object 
> command line, and then it really should work for every git version).
> 
> 			Linus

//Peter


[-- Attachment #2: 0001-diff-Make-git-diff-support-the-root-option.patch --]
[-- Type: application/octet-stream, Size: 3454 bytes --]

From d9d482db98aa3ff3545cf66a8f851cc459b0eacd Mon Sep 17 00:00:00 2001
From: Peter Kjellerstedt <pkj@axis.com>
Date: Fri, 7 May 2010 17:11:19 +0200
Subject: [PATCH] diff: Make git diff support the --root option

Using 'git diff --root <tree-ish>' will give all the changes between
the empty tree and <tree-ish>. It is also possible to use 'git diff
--root --cached' to get all changes between the empty tree and the
current index.

Signed-off-by: Peter Kjellerstedt <pkj@axis.com>
---
 builtin/diff.c |   28 ++++++++++++++++++++++------
 revision.c     |   12 ++++++++++++
 revision.h     |    1 +
 3 files changed, 35 insertions(+), 6 deletions(-)

diff --git a/builtin/diff.c b/builtin/diff.c
index ffcdd05..8da59dd 100644
--- a/builtin/diff.c
+++ b/builtin/diff.c
@@ -253,6 +253,7 @@ int cmd_diff(int argc, const char **argv, const char *prefix)
 	const char *path = NULL;
 	struct blobinfo blob[2];
 	int nongit;
+	int cached = 0;
 	int result = 0;
 
 	/*
@@ -316,10 +317,10 @@ int cmd_diff(int argc, const char **argv, const char *prefix)
 		setup_pager();
 
 	/*
-	 * Do we have --cached and not have a pending object, then
-	 * default to HEAD by hand.  Eek.
+	 * If we have --cached and/or --root we may need to add the empty tree
+	 * or HEAD by hand.  Eek.
 	 */
-	if (!rev.pending.nr) {
+	if (rev.pending.nr <= 1) {
 		int i;
 		for (i = 1; i < argc; i++) {
 			const char *arg = argv[i];
@@ -327,14 +328,29 @@ int cmd_diff(int argc, const char **argv, const char *prefix)
 				break;
 			else if (!strcmp(arg, "--cached") ||
 				 !strcmp(arg, "--staged")) {
-				add_head_to_pending(&rev);
-				if (!rev.pending.nr)
-					die("No HEAD commit to compare with (yet)");
+				cached = 1;
 				break;
 			}
 		}
 	}
 
+	if (!rev.pending.nr) {
+		if (rev.show_root_diff) {
+			add_empty_tree_to_pending(&rev);
+			if (!rev.pending.nr)
+				die("No empty tree to compare with");
+		} else if (cached) {
+			add_head_to_pending(&rev);
+			if (!rev.pending.nr)
+				die("No HEAD commit to compare with (yet)");
+		}
+	} else if (rev.pending.nr == 1 && rev.show_root_diff && !cached) {
+		add_empty_tree_to_pending(&rev);
+		if (rev.pending.nr != 2)
+			die("No empty tree to compare with");
+		rev.diffopt.flags ^= DIFF_OPT_REVERSE_DIFF;
+	}
+
 	for (i = 0; i < rev.pending.nr; i++) {
 		struct object_array_entry *list = rev.pending.objects+i;
 		struct object *obj = list->item;
diff --git a/revision.c b/revision.c
index f4b8b38..c3a78dc 100644
--- a/revision.c
+++ b/revision.c
@@ -169,6 +169,18 @@ void add_head_to_pending(struct rev_info *revs)
 	add_pending_object(revs, obj, "HEAD");
 }
 
+void add_empty_tree_to_pending(struct rev_info *revs)
+{
+	unsigned char sha1[20];
+	struct object *obj;
+	if (get_sha1(EMPTY_TREE_SHA1_HEX, sha1))
+		return;
+	obj = parse_object(sha1);
+	if (!obj)
+		return;
+	add_pending_object(revs, obj, EMPTY_TREE_SHA1_HEX);
+}
+
 static struct object *get_reference(struct rev_info *revs, const char *name, const unsigned char *sha1, unsigned int flags)
 {
 	struct object *object;
diff --git a/revision.h b/revision.h
index 568f1c9..e1a7d9d 100644
--- a/revision.h
+++ b/revision.h
@@ -176,6 +176,7 @@ extern void add_object(struct object *obj,
 extern void add_pending_object(struct rev_info *revs, struct object *obj, const char *name);
 
 extern void add_head_to_pending(struct rev_info *);
+extern void add_empty_tree_to_pending(struct rev_info *revs);
 
 enum commit_action {
 	commit_ignore,
-- 
1.7.0.1

Re: Any way to get complete diff up to a tag?

[Knittl]

On Thu, May 6, 2010 at 11:27 AM, Peter Kjellerstedt
<peter.kjellerstedt@axis.com> wrote:
> Basically, what I think I am asking for is a way to specify the
> empty parent of the initial commit, i.e., where v1.7.1~1000000 would
> end up. I can see this being useful in at least one other case as
> well, namely when doing an interactive rebase to allow the initial
> commit to be rebased (something I have wanted to do a couple of
> times...)


wait, let me get this straight. you want to diff some tag against the
empty parent of the root commit (empty tree)?

which in turn means you will get a diff, where all lines in all files
existing in the tree that tag references are added. all files get
basically prefixed with + and have header information (filename). what
purpose has such a diff?

regards, daniel

-- 
typed with http://neo-layout.org
myFtPhp -- visit http://myftphp.sf.net -- v. 0.4.7 released!

RE: Any way to get complete diff up to a tag?

[Peter Kjellerstedt]

> -----Original Message-----
> From: git-owner@vger.kernel.org
> [mailto:git-owner@vger.kernel.org] On Behalf Of Knittl
> Sent: den 6 maj 2010 17:44
> To: Peter Kjellerstedt
> Cc: git@vger.kernel.org
> Subject: Re: Any way to get complete diff up to a tag?
>
> On Thu, May 6, 2010 at 11:27 AM, Peter Kjellerstedt
> <peter.kjellerstedt@axis.com> wrote:
> > Basically, what I think I am asking for is a way to specify the
> > empty parent of the initial commit, i.e., where v1.7.1~1000000 would
> > end up. I can see this being useful in at least one other case as
> > well, namely when doing an interactive rebase to allow the initial
> > commit to be rebased (something I have wanted to do a couple of
> > times...)
>
> wait, let me get this straight. you want to diff some tag against the
> empty parent of the root commit (empty tree)?
>
> which in turn means you will get a diff, where all lines in all files
> existing in the tree that tag references are added. all files get
> basically prefixed with + and have header information (filename). what
> purpose has such a diff?
>
> regards, daniel

Well, I can see a couple of purposes, but in my case I have a tool
post-processing the generated diff. And to it there is no difference
regarding what point was used as the start of the diff, whether it
was the empty tree (i.e., a diff containing everything), some commit
in the middle, or the last commit (i.e., an emptry diff). All it
wants is a diff.

//Peter