* Re: [PATCH v3] git-gui: adjust the minimum height of diff pane for shorter screen height
From: Junio C Hamano @ 2009-10-15 19:57 UTC (permalink / raw)
To: Vietor Liu; +Cc: Shawn O. Pearce, git, Johannes Schindelin
In-Reply-To: <1255583127-14893-1-git-send-email-vietor@vxwo.org>
Vietor Liu <vietor@vxwo.org> writes:
> When the screen height is shorter (e.g. Netbook screen 1024x600), both the
> partial commit pane and the status bar will hide. This patch adjust the
> minimum height of the diff pane, allowing the overall window to be shorter
> and still display both the entire commit pane and status bar.
Ah, I finally can parse and understand what this s/15/5/ change was about
;-). Perhaps with "s/will hide/are hidden/" it would be perfect?
>
> Signed-off-by: Vietor Liu <vietor@vxwo.org>
> ---
> git-gui.sh | 2 +-
> 1 files changed, 1 insertions(+), 1 deletions(-)
>
> diff --git a/git-gui.sh b/git-gui.sh
> index 09b2720..037a1f2 100755
> --- a/git-gui.sh
> +++ b/git-gui.sh
> @@ -3083,7 +3083,7 @@ frame .vpane.lower.diff.body
> set ui_diff .vpane.lower.diff.body.t
> text $ui_diff -background white -foreground black \
> -borderwidth 0 \
> - -width 80 -height 15 -wrap none \
> + -width 80 -height 5 -wrap none \
> -font font_diff \
> -xscrollcommand {.vpane.lower.diff.body.sbx set} \
> -yscrollcommand {.vpane.lower.diff.body.sby set} \
> --
> 1.6.5
>
> --
> To unsubscribe from this list: send the line "unsubscribe git" in
> the body of a message to majordomo@vger.kernel.org
> More majordomo info at http://vger.kernel.org/majordomo-info.html
^ permalink raw reply
* Re: My custom cccmd
From: Junio C Hamano @ 2009-10-15 20:09 UTC (permalink / raw)
To: Felipe Contreras; +Cc: git
In-Reply-To: <94a0d4530910150620g733bdf0aq88660053f869b0a9@mail.gmail.com>
Felipe Contreras <felipe.contreras@gmail.com> writes:
> Hi,
>
> I love the new option to run a cccmd and how good it works on the
> linux kernel, but I couldn't find a generic script. So I decided to
> write my own.
>
> It's very simple, it just looks into the authors of the commits that
> modified the lines being overridden (git blame). It's not checking for
> s-o-b, or anything fancy.
>
> Comments?
> #!/usr/bin/env ruby
>
> @commits = {} # keeps a count of commits per author
>
> ARGV.each do |filename|
> File.open(filename) do |patch_file|
> patch_file.each_line do |patch_line|
> case patch_line
> when /^---\s+(\S+)/
> @source = $1[2..-1]
> when /^@@\s-(\d+),(\d+)/
> blame = `git blame -p -L #{$1},+#{$2} #{@source} | grep author`
> blame.each_line do |al|
> key, value = al.chomp.split(" ", 2)
> case key
> when "author"
> @name = value
> when "author-mail"
> @mail = value
> author = "\"#{@name}\" #{@mail}"
> @commits[author] ||= 0
> @commits[author] += 1
> end
> end
> end
> end
> end
> end
Comments.
#0. Gaahhh, my eyes, my eyes!! Can't you do this ugly run of infinite
number of "end"s?
#1. You are not making sure that you start blaming from the commit the
patch is based on, so your -La,b line numbers can be off. If you can
assume that you are always reading format-patch output, you can learn
which commit to start from by reading the first "magic" line.
#2. If you have two patch series that updates one file twice, some
changes in your second patch could even be an update to the changes
you introduced in your first patch. After you fix issue #1, you
would probably want to fix this by excluding the commits you have
already sent the blames for.
#3. Does the number of commits you keep per author have any significance?
I know it doesn't in the implementation you posted, but should it,
and if so how?
> @commits.each_key do |a|
> puts a
> end
>
> --
> Felipe Contreras
> --
> To unsubscribe from this list: send the line "unsubscribe git" in
> the body of a message to majordomo@vger.kernel.org
> More majordomo info at http://vger.kernel.org/majordomo-info.html
^ permalink raw reply
* Re: [RFC PATCH v3 00/17] Return of smart HTTP
From: Junio C Hamano @ 2009-10-15 20:27 UTC (permalink / raw)
To: Shawn O. Pearce; +Cc: Johan Herland, Nanako Shiraishi, Junio C Hamano, git
In-Reply-To: <20091015154142.GL10505@spearce.org>
"Shawn O. Pearce" <spearce@spearce.org> writes:
> It does. It is caused by the disconnect_helper call inside of
> fetch_with_import. You can't disconnect inside of the fetch method
> of a transport, the caller is going to disconnect you a second time.
> ...
> This bug isn't due to the merge, its a bug in Johan's series that
> needs to be fixed before it could merge down to next/master.
Thanks; I pushed out 'pu' with your v3 this time.
Last night I did a trial fetch merge with FETCH_HEAD into 'pu', but then
after I queued some fixes to 'maint' and 'master' to prepare for 1.6.5.1,
I rebuilt 'pu' with the still-old sp/smart-http topic, and that is what
was sitting at k.org til this morning.
I am a bit confused about your diagnosis, though. As far as I recall,
Johan's topic itself nor 'pu' with Johan's topic but without v2 of
sp/smart-http did not have the issue. Does that indicate that the
behaviour expected from the fetch method is different between the two
topics, and this indeed is a semantic conflict as you suspected initially?
In other words, if Johan's series is updated not to disconnect inside the
fetch method of the transport, and if it is not merged with your series,
does the caller still disconnect it properly?
^ permalink raw reply
* Re: [PATCH] Proof-of-concept patch to remember what the detached HEAD was
From: Junio C Hamano @ 2009-10-15 20:34 UTC (permalink / raw)
To: Daniel Barkalow
Cc: James Pickens, Jeff King, Junio C Hamano, Nicolas Pitre,
Jay Soffian, git
In-Reply-To: <alpine.LNX.2.00.0910151523020.32515@iabervon.org>
Daniel Barkalow <barkalow@iabervon.org> writes:
> $ git checkout origin/master
> $ git fetch
> $ git checkout origin/next
> Uncommited file '...' would be overwritten.
>
> If HEAD is a symref to refs/remotes/origin/master, and you update
> refs/remotes/origin/master, git will subsequently see that your index
> doesn't match HEAD, and when you switch branches, it will try to apply a
> revert to the branch you're switching to. It's the same issue as pushing
> into a non-bare repository.
I think the idea here is to allow HEAD to point at outside refs/heads/,
e.g. refs/remotes/origin/master, but forbid commit and other commands from
updating HEAD and its underlying ref via update_ref() unless HEAD is
detached or points at a local branch.
^ permalink raw reply
* Re: [RFC PATCH v3 00/17] Return of smart HTTP
From: Shawn O. Pearce @ 2009-10-15 20:45 UTC (permalink / raw)
To: Junio C Hamano, Daniel Barkalow; +Cc: Johan Herland, Nanako Shiraishi, git
In-Reply-To: <7vfx9k4d33.fsf@alter.siamese.dyndns.org>
Junio C Hamano <gitster@pobox.com> wrote:
> "Shawn O. Pearce" <spearce@spearce.org> writes:
>
> > It does. It is caused by the disconnect_helper call inside of
> > fetch_with_import. You can't disconnect inside of the fetch method
> > of a transport, the caller is going to disconnect you a second time.
> > ...
> > This bug isn't due to the merge, its a bug in Johan's series that
> > needs to be fixed before it could merge down to next/master.
...
> I am a bit confused about your diagnosis, though. As far as I recall,
> Johan's topic itself nor 'pu' with Johan's topic but without v2 of
> sp/smart-http did not have the issue.
Sadly, sometimes double frees do not result in segfaults, other
times they do. The reason you are not seeing a problem with these
other variants is because of luck, not code correctness.
Actually, after some further research, the bug is not Johan's but is
actually Daniel's. Johan, I apologize for claiming it was your bug.
In:
commit 23a3380ee9c2d5164712c40f8821cb0fba24e80c
Author: Daniel Barkalow <barkalow@iabervon.org>
Date: Thu Sep 3 22:14:01 2009 -0400
Add support for "import" helper command
Daniel introduces the fetch_with_import() function to
transport-helper.c. This method calls disconnect_helper():
+static int fetch_with_import(struct transport *transport,
+ int nr_heads, struct ref **to_fetch)
+{
...
+ disconnect_helper(transport);
+ finish_command(&fastimport);
Unfortunately this is in the middle of the transport_fetch() call
stack; transport_fetch() called the static fetch() function in
transport-helper.c, which in turn called fetch_with_import().
Callers (e.g. builtin-fetch.c) invoke transport_close() when
they are done with the handle (see line 704). That in turn calls
disconnect_helper() a second time.
The disconnect_helper function is not prepared to be called twice:
static int disconnect_helper(struct transport *transport)
{
struct helper_data *data = transport->data;
if (data->helper) {
...
}
free(data);
return 0;
}
Because of that unexpected invocation inside of fetch_with_import
we have already free'd the memory block used by transport->data,
and the second invocation attempts to free it again. Worse, if the
block was reused by a subsequent malloc, data->helper might not be
NULL, and we'd enter into the if block and do its work again.
Long story short, transport_close() is what is supposed to perform
the work that disconnect_helper does, as its the final thing right
before we free the struct transport block. Free'ing the data block
inside of the fetch or push functions is wrong.
Its fine to close the helper and restart it within the single
lifespan of a struct transport, but dammit, don't free the
struct helper_data until transport_close().
--
Shawn.
^ permalink raw reply
* Git gui and gitk documentation
From: chris miles @ 2009-10-15 20:51 UTC (permalink / raw)
To: git
Hi
I'm looking for documentation on gitk and the gui that is distributed with git.
Could anyone point me in the right direction?
Thanks
Chris Miles
_________________________________________________________________
Did you know you can get Messenger on your mobile?
http://clk.atdmt.com/UKM/go/174426567/direct/01/
^ permalink raw reply
* Re: [PATCH] Proof-of-concept patch to remember what the detached HEAD was
From: Jeff King @ 2009-10-15 21:26 UTC (permalink / raw)
To: Junio C Hamano
Cc: Nicolas Pitre, James Pickens, Daniel Barkalow, Jay Soffian, git
In-Reply-To: <7v1vl45t9k.fsf@alter.siamese.dyndns.org>
On Thu, Oct 15, 2009 at 12:52:55PM -0700, Junio C Hamano wrote:
> I like James's suggestion to allow us to store refs other than refs/heads/
> in HEAD to denote this state, and keep commit and reset from updating such
> a ref through updating HEAD.
Didn't we already consider and reject this the first time around? For
example, this thread has a ton of stuff about how we shouldn't prevent
people from making commits on the wandering state:
http://thread.gmane.org/gmane.comp.version-control.git/35777/focus=35835
And here's me even advocating this exact strategy (and I'm sure I didn't
think of it; it's probably discussed elsewhere, too):
http://thread.gmane.org/gmane.comp.version-control.git/35777/focus=35858
Not that I am not necessarily complaining, but I just hope this decision
is "with new-found knowledge we are revisiting this decision" and not
"we totally forgot about what came before".
-Peff
^ permalink raw reply
* Re: [PATCH] Proof-of-concept patch to remember what the detached HEAD was
From: Daniel Barkalow @ 2009-10-15 21:35 UTC (permalink / raw)
To: Junio C Hamano; +Cc: James Pickens, Jeff King, Nicolas Pitre, Jay Soffian, git
In-Reply-To: <7v3a5k4cri.fsf@alter.siamese.dyndns.org>
On Thu, 15 Oct 2009, Junio C Hamano wrote:
> Daniel Barkalow <barkalow@iabervon.org> writes:
>
> > $ git checkout origin/master
> > $ git fetch
> > $ git checkout origin/next
> > Uncommited file '...' would be overwritten.
> >
> > If HEAD is a symref to refs/remotes/origin/master, and you update
> > refs/remotes/origin/master, git will subsequently see that your index
> > doesn't match HEAD, and when you switch branches, it will try to apply a
> > revert to the branch you're switching to. It's the same issue as pushing
> > into a non-bare repository.
>
> I think the idea here is to allow HEAD to point at outside refs/heads/,
> e.g. refs/remotes/origin/master, but forbid commit and other commands from
> updating HEAD and its underlying ref via update_ref() unless HEAD is
> detached or points at a local branch.
$ git checkout origin/master
$ git fetch
(Some error)
I think it would be much more confusing for many users if you couldn't
do:
$ git checkout origin/master
(look at origin/master)
(wait a day)
$ git fetch
$ git checkout origin/next
(look at origin/next)
Part of the original point of detached HEAD was to support this pattern
without creating an undesired local branch (which falls out of date),
having problems with updating the tracking branches, or having problems
with direct changes to the ref that HEAD points to.
Currently, HEAD is never a symref to anything that will ever be updated
normally except though the symref. That's a really handy property that
avoids making us deal with lots of special cases in weird places. And
those special cases would not only be annoying to have to handle again,
but they'd be complexity that users would have to be exposed to.
-Daniel
*This .sig left intentionally blank*
^ permalink raw reply
* Re: My custom cccmd
From: Felipe Contreras @ 2009-10-15 21:37 UTC (permalink / raw)
To: Junio C Hamano; +Cc: git
In-Reply-To: <7vk4yw4dy3.fsf@alter.siamese.dyndns.org>
On Thu, Oct 15, 2009 at 11:09 PM, Junio C Hamano <gitster@pobox.com> wrote:
> Felipe Contreras <felipe.contreras@gmail.com> writes:
>
>> Hi,
>>
>> I love the new option to run a cccmd and how good it works on the
>> linux kernel, but I couldn't find a generic script. So I decided to
>> write my own.
>>
>> It's very simple, it just looks into the authors of the commits that
>> modified the lines being overridden (git blame). It's not checking for
>> s-o-b, or anything fancy.
>>
<snip/>
> Comments.
>
> #0. Gaahhh, my eyes, my eyes!! Can't you do this ugly run of infinite
> number of "end"s?
Hehe, sure. Will do.
> #1. You are not making sure that you start blaming from the commit the
> patch is based on, so your -La,b line numbers can be off. If you can
> assume that you are always reading format-patch output, you can learn
> which commit to start from by reading the first "magic" line.
The 'From' magic line points to the actual commit the patch was
generated from, so it would actually be @from^.
This of course would only work if the patches have the corresponding
commits in the current tree (which is the case most of the time).
And makes sense only for the first patch, the rest of the patches
would use a wrong commit as a base. See below.
> #2. If you have two patch series that updates one file twice, some
> changes in your second patch could even be an update to the changes
> you introduced in your first patch. After you fix issue #1, you
> would probably want to fix this by excluding the commits you have
> already sent the blames for.
How exactly? By looking at the commit from 'git blame' and discarding
it? That would be a bit tricky since each instance of 'cccmd' is not
aware of the previous ones.
> #3. Does the number of commits you keep per author have any significance?
> I know it doesn't in the implementation you posted, but should it,
> and if so how?
Not currently. Once I add support for s-o-b it might be useful.
Currently I left it in order to order the CC's by the count, but it
turned out to be a bit messier than I thought, and the advantage is
almost nothing.
I'll clean it up.
Taking in consideration the previous comments, here is v2:
#!/usr/bin/env ruby
@authors = {}
def parse_blame(line)
key, value = line.split(" ", 2)
case key
when "author"
@name = value
when "author-mail"
@mail = value
author = "\"#{@name}\" #{@mail}"
@authors[author] = true
end
end
ARGV.each do |filename|
patch_file = File.open(filename)
patch_file.each_line do |patch_line|
case patch_line
when /^---\s+(\S+)/
@source = $1[2..-1]
when /^@@\s-(\d+),(\d+)/
blame = `git blame -p -L #{$1},+#{$2} #{@source} | grep author`
blame.each_line { |l| parse_blame(l.chomp) }
end
end
end
@authors.each_key do |a|
puts a
end
--
Felipe Contreras
^ permalink raw reply
* Re: [PATCH] Proof-of-concept patch to remember what the detached HEAD was
From: Nicolas Pitre @ 2009-10-15 21:48 UTC (permalink / raw)
To: Daniel Barkalow
Cc: Junio C Hamano, James Pickens, Jeff King, Jay Soffian, git
In-Reply-To: <alpine.LNX.2.00.0910151653480.32515@iabervon.org>
On Thu, 15 Oct 2009, Daniel Barkalow wrote:
> On Thu, 15 Oct 2009, Junio C Hamano wrote:
>
> > Daniel Barkalow <barkalow@iabervon.org> writes:
> >
> > > $ git checkout origin/master
> > > $ git fetch
> > > $ git checkout origin/next
> > > Uncommited file '...' would be overwritten.
> > >
> > > If HEAD is a symref to refs/remotes/origin/master, and you update
> > > refs/remotes/origin/master, git will subsequently see that your index
> > > doesn't match HEAD, and when you switch branches, it will try to apply a
> > > revert to the branch you're switching to. It's the same issue as pushing
> > > into a non-bare repository.
> >
> > I think the idea here is to allow HEAD to point at outside refs/heads/,
> > e.g. refs/remotes/origin/master, but forbid commit and other commands from
> > updating HEAD and its underlying ref via update_ref() unless HEAD is
> > detached or points at a local branch.
>
> $ git checkout origin/master
> $ git fetch
> (Some error)
Right.
So we're back to your initial proposal I guess (storing some info/state
in .git/HEAD when detached).
Nicolas
^ permalink raw reply
* Re: [PATCH] Proof-of-concept patch to remember what the detached HEAD was
From: Junio C Hamano @ 2009-10-15 21:54 UTC (permalink / raw)
To: Jeff King
Cc: Junio C Hamano, Nicolas Pitre, James Pickens, Daniel Barkalow,
Jay Soffian, git
In-Reply-To: <20091015212632.GA13180@coredump.intra.peff.net>
Jeff King <peff@peff.net> writes:
> On Thu, Oct 15, 2009 at 12:52:55PM -0700, Junio C Hamano wrote:
>
>> I like James's suggestion to allow us to store refs other than refs/heads/
>> in HEAD to denote this state, and keep commit and reset from updating such
>> a ref through updating HEAD.
>
> Didn't we already consider and reject this the first time around? For
> example, this thread has a ton of stuff about how we shouldn't prevent
> people from making commits on the wandering state:
>
> http://thread.gmane.org/gmane.comp.version-control.git/35777/focus=35835
>
> And here's me even advocating this exact strategy (and I'm sure I didn't
> think of it; it's probably discussed elsewhere, too):
>
> http://thread.gmane.org/gmane.comp.version-control.git/35777/focus=35858
>
> Not that I am not necessarily complaining, but I just hope this decision
> is "with new-found knowledge we are revisiting this decision" and not
> "we totally forgot about what came before".
Maybe we are reading different messages in the same message.
My understanding of James's suggestion is:
(1) "git checkout $token" makes HEAD point at the refname dwim_ref()
expands $token to, iff dwim_ref() is happy, and otherwise detaches
HEAD;
(2) "git commit" (and other things like "git reset HEAD^" that updates
underlying ref thru updates to HEAD when HEAD is a symref) rejects
when HEAD points at a ref outside refs/heads/, but works when HEAD
points at a local branch, or when HEAD is detached.
As a consequence:
$ git checkout v1.6.5 ;# does not detach, cannot update
$ git symbolic-ref HEAD
refs/tags/v1.6.5
$ git checkout origin/next ;# ditto
$ git symbolic-ref HEAD
refs/remotes/origin/next
These are often done by sightseers, and we can add instructions to fork
and record upon an attempt to "git commit".
As a bonus, we get Daniel's extra information for detached HEAD for free,
as we can just read HEAD and learn what it points at. We need to design
what "git branch" should say in this case.
This is backward incompatible, and makes what experts are used to do
slightly cumbersome to spell, i.e.
$ git checkout v1.6.5^0 ;# detaches and can commit
$ git checkout origin/next^0 ;# ditto
$ git checkout $(git merge-base master sp/smart-http) ;# ditto
These detach, and I can apply the updates series to the same base as the
previous round on an unnamed branch.
So in other words, the semantics for detached HEAD case does not change at
all. We never forbid committing or resetting while on detached HEAD, as
it is meant to be an easy way to get an unnamed throw-away state that is
not even worth coming up with a unique temporary branch name, and I do not
think the above contradicts with what was said in 35835.
We used to have only two states on HEAD: either on a local branch or
detached. James is introducing another state: on a ref that is not a
local branch.
As that is useful for common sightseer tasks, we can afford to forbid
committing or updating for safety and we do not have to worry about
hurting the established usefulness of how detached HEAD works.
One drawback is that you cannot be in this sightseeing state without
having a ref. You can have "look-but-not-touch" checkout on origin/next
or origin/master, but you cannot sightsee the parent of origin/next the
same way (it would detach). I do not know if it is a big deal, though.
If it is very important to support:
$ git checkout --look-but-not-touch origin/next^
then James's approach would not be very useful, as we do have to detach
HEAD and implement the "do not touch" logic for detached HEAD state
anyway, so we might just use the same logic we would use for origin/next^
when checking out origin/next itself.
^ permalink raw reply
* Re: [PATCH] Proof-of-concept patch to remember what the detached HEAD was
From: Junio C Hamano @ 2009-10-15 22:08 UTC (permalink / raw)
To: Junio C Hamano
Cc: Jeff King, Nicolas Pitre, James Pickens, Daniel Barkalow,
Jay Soffian, git
In-Reply-To: <7v1vl42uid.fsf@alter.siamese.dyndns.org>
Junio C Hamano <gitster@pobox.com> writes:
> $ git checkout origin/next ;# ditto
> $ git symbolic-ref HEAD
> refs/remotes/origin/next
Ok, after reading Daniel's message to remind us that "git fetch" after
this will get us into trouble, I agree that detaching HEAD is inevitable.
^ permalink raw reply
* Re: [PATCH] Proof-of-concept patch to remember what the detached HEAD was
From: Jeff King @ 2009-10-15 22:16 UTC (permalink / raw)
To: Junio C Hamano
Cc: Nicolas Pitre, James Pickens, Daniel Barkalow, Jay Soffian, git
In-Reply-To: <7v1vl42uid.fsf@alter.siamese.dyndns.org>
On Thu, Oct 15, 2009 at 02:54:18PM -0700, Junio C Hamano wrote:
> Maybe we are reading different messages in the same message.
>
> My understanding of James's suggestion is:
>
> (1) "git checkout $token" makes HEAD point at the refname dwim_ref()
> expands $token to, iff dwim_ref() is happy, and otherwise detaches
> HEAD;
>
> (2) "git commit" (and other things like "git reset HEAD^" that updates
> underlying ref thru updates to HEAD when HEAD is a symref) rejects
> when HEAD points at a ref outside refs/heads/, but works when HEAD
> points at a local branch, or when HEAD is detached.
Right. I thought the idea of "don't complain at checkout time, but
complain at commit" had been considered and rejected. But I guess you
could argue that the difference between this and the original discussion
is that we are going to have _both_ the detached HEAD state and the
"refs/tags/* in HEAD" state, and treat them differently.
I feel like the latter idea was discussed in more detail (I made
reference to it in the latter email I linked to, but I don't think that
was the origin of it), but I can't seem to find any discussion.
So I will buy that this is somewhat of a new idea. I am still confused
about what happens with this, though:
$ git checkout origin/next
$ git fetch ;# updates origin/next
Do we refuse the fetch? Does the user now have a working tree and index
that doesn't match their HEAD?
> This is backward incompatible, and makes what experts are used to do
> slightly cumbersome to spell, i.e.
>
> $ git checkout v1.6.5^0 ;# detaches and can commit
> $ git checkout origin/next^0 ;# ditto
> $ git checkout $(git merge-base master sp/smart-http) ;# ditto
I think it is less cumbersome if we add "git checkout -d v1.6.5" (well,
same number of characters, but a lot less ugly). Assuming that the rest
of it is a good idea.
-Peff
^ permalink raw reply
* Re: [PATCH] Proof-of-concept patch to remember what the detached HEAD was
From: Jeff King @ 2009-10-15 22:17 UTC (permalink / raw)
To: Junio C Hamano
Cc: Nicolas Pitre, James Pickens, Daniel Barkalow, Jay Soffian, git
In-Reply-To: <20091015221657.GC13180@coredump.intra.peff.net>
On Thu, Oct 15, 2009 at 06:16:57PM -0400, Jeff King wrote:
> So I will buy that this is somewhat of a new idea. I am still confused
> about what happens with this, though:
>
> $ git checkout origin/next
> $ git fetch ;# updates origin/next
>
> Do we refuse the fetch? Does the user now have a working tree and index
> that doesn't match their HEAD?
OK, nevermind about this, we just crossed emails.
-Peff
^ permalink raw reply
* [PATCH v2 0/5] Pretty formats for reflog data
From: Thomas Rast @ 2009-10-15 22:41 UTC (permalink / raw)
To: Jeff King, Junio C Hamano; +Cc: Jef Driesen, Nanako Shiraishi, git
In-Reply-To: <20091014050645.GD31810@coredump.intra.peff.net>
Jeff King wrote:
> Maybe a better solution would be a "short name" variant for pretty
> format specifiers. We already have %(refname) and %(refname:short) [...]
> The tricky part would be deciding on a syntax. This seems to come up a
> fair bit.
Ok, I settled for %g[dDs] for now to save on letters. I'm saving the
syntax question for a later series while we discuss this one ;-)
I think going for %(...) wouldn't be too bad since we already have
that in for-each-ref, and it can be backwards compatible. So we would
have different sets of short and long specifiers, e.g.
%ae = %(authoremail)
%aE = %(authoremail:mailmap)
We can then pass arguments via some yet-to-be decided syntax, say,
%(body:indent(10)).
Other changes in this version include:
* I followed your struct suggestion, which is the new 1/5.
* Since the shortening can be handled by %gd, the old 5/5 (change from
refs/stash to only stash) is no longer needed.
* I fixed the warning that Junio found (and finally found the right
combination of -W flags, though I cannot compile with -Werror myself
because of *other* warnings...)
I also added tests and docs to the main patch (now 3/5).
Thomas Rast (5):
Refactor pretty_print_commit arguments into a struct
reflog-walk: refactor the branch@{num} formatting
Introduce new pretty formats %g[sdD] for reflog information
stash list: use new %g formats instead of sed
stash list: drop the default limit of 10 stashes
Documentation/pretty-formats.txt | 3 +
builtin-branch.c | 3 +-
builtin-checkout.c | 3 +-
builtin-log.c | 3 +-
builtin-merge.c | 7 ++-
builtin-rev-list.c | 7 ++-
builtin-shortlog.c | 9 +++-
builtin-show-branch.c | 4 +-
commit.h | 20 ++++++---
git-stash.sh | 8 +---
log-tree.c | 21 +++++----
pretty.c | 44 ++++++++++++++------
reflog-walk.c | 85 ++++++++++++++++++++++++++++----------
reflog-walk.h | 8 ++++
t/t1411-reflog-show.sh | 12 +++++
15 files changed, 166 insertions(+), 71 deletions(-)
^ permalink raw reply
* [PATCH v2 5/5] stash list: drop the default limit of 10 stashes
From: Thomas Rast @ 2009-10-15 22:41 UTC (permalink / raw)
To: Jeff King, Junio C Hamano; +Cc: Jef Driesen, Nanako Shiraishi, git
In-Reply-To: <cover.1255645570.git.trast@student.ethz.ch>
'git stash list' had an undocumented limit of 10 stashes, unless other
git-log arguments were specified. This surprised at least one user,
but possibly served to cut the output below a screenful without using
a pager.
Since the last commit, 'git stash list' will fire up a pager according
to the same rules as the 'git log' it calls, so we can drop the limit.
Signed-off-by: Thomas Rast <trast@student.ethz.ch>
---
git-stash.sh | 5 -----
1 files changed, 0 insertions(+), 5 deletions(-)
diff --git a/git-stash.sh b/git-stash.sh
index f8847c1..f796c2f 100755
--- a/git-stash.sh
+++ b/git-stash.sh
@@ -382,11 +382,6 @@ test -n "$seen_non_option" || set "save" "$@"
case "$1" in
list)
shift
- if test $# = 0
- then
- set x -n 10
- shift
- fi
list_stash "$@"
;;
show)
--
1.6.5.18.g9f87a.dirty
^ permalink raw reply related
* [PATCH v2 1/5] Refactor pretty_print_commit arguments into a struct
From: Thomas Rast @ 2009-10-15 22:41 UTC (permalink / raw)
To: Jeff King, Junio C Hamano; +Cc: Jef Driesen, Nanako Shiraishi, git
In-Reply-To: <cover.1255645570.git.trast@student.ethz.ch>
pretty_print_commit() has a bunch of rarely-used arguments, and
introducing more of them requires yet another update of all the call
sites. Refactor most of them into a struct to make future extensions
easier.
The ones that stay "plain" arguments were chosen on the grounds that
all callers put real arguments there, whereas some callers have 0/NULL
for all arguments that were factored into the struct.
We declare the struct 'const' to ensure none of the callers are bitten
by the changed (no longer call-by-value) semantics.
Signed-off-by: Thomas Rast <trast@student.ethz.ch>
---
builtin-branch.c | 3 ++-
builtin-checkout.c | 3 ++-
builtin-log.c | 3 ++-
builtin-merge.c | 7 +++++--
builtin-rev-list.c | 7 ++++---
builtin-shortlog.c | 9 ++++++---
builtin-show-branch.c | 4 ++--
commit.h | 19 +++++++++++++------
log-tree.c | 20 ++++++++++----------
pretty.c | 27 ++++++++++++++-------------
10 files changed, 60 insertions(+), 42 deletions(-)
diff --git a/builtin-branch.c b/builtin-branch.c
index 9f57992..05e876e 100644
--- a/builtin-branch.c
+++ b/builtin-branch.c
@@ -387,8 +387,9 @@ static void print_ref_item(struct ref_item *item, int maxwidth, int verbose,
commit = item->commit;
if (commit && !parse_commit(commit)) {
+ struct pretty_print_context ctx = {0};
pretty_print_commit(CMIT_FMT_ONELINE, commit,
- &subject, 0, NULL, NULL, 0, 0);
+ &subject, &ctx);
sub = subject.buf;
}
diff --git a/builtin-checkout.c b/builtin-checkout.c
index d050c37..075a49f 100644
--- a/builtin-checkout.c
+++ b/builtin-checkout.c
@@ -302,8 +302,9 @@ static void show_local_changes(struct object *head)
static void describe_detached_head(char *msg, struct commit *commit)
{
struct strbuf sb = STRBUF_INIT;
+ struct pretty_print_context ctx = {0};
parse_commit(commit);
- pretty_print_commit(CMIT_FMT_ONELINE, commit, &sb, 0, NULL, NULL, 0, 0);
+ pretty_print_commit(CMIT_FMT_ONELINE, commit, &sb, &ctx);
fprintf(stderr, "%s %s... %s\n", msg,
find_unique_abbrev(commit->object.sha1, DEFAULT_ABBREV), sb.buf);
strbuf_release(&sb);
diff --git a/builtin-log.c b/builtin-log.c
index 25e21ed..207a361 100644
--- a/builtin-log.c
+++ b/builtin-log.c
@@ -1304,8 +1304,9 @@ int cmd_cherry(int argc, const char **argv, const char *prefix)
if (verbose) {
struct strbuf buf = STRBUF_INIT;
+ struct pretty_print_context ctx = {0};
pretty_print_commit(CMIT_FMT_ONELINE, commit,
- &buf, 0, NULL, NULL, 0, 0);
+ &buf, &ctx);
printf("%c %s %s\n", sign,
sha1_to_hex(commit->object.sha1), buf.buf);
strbuf_release(&buf);
diff --git a/builtin-merge.c b/builtin-merge.c
index b6b8428..c69a305 100644
--- a/builtin-merge.c
+++ b/builtin-merge.c
@@ -264,6 +264,7 @@ static void squash_message(void)
struct strbuf out = STRBUF_INIT;
struct commit_list *j;
int fd;
+ struct pretty_print_context ctx = {0};
printf("Squash commit -- not updating HEAD\n");
fd = open(git_path("SQUASH_MSG"), O_WRONLY | O_CREAT, 0666);
@@ -285,13 +286,15 @@ static void squash_message(void)
if (prepare_revision_walk(&rev))
die("revision walk setup failed");
+ ctx.abbrev = rev.abbrev;
+ ctx.date_mode = rev.date_mode;
+
strbuf_addstr(&out, "Squashed commit of the following:\n");
while ((commit = get_revision(&rev)) != NULL) {
strbuf_addch(&out, '\n');
strbuf_addf(&out, "commit %s\n",
sha1_to_hex(commit->object.sha1));
- pretty_print_commit(rev.commit_format, commit, &out, rev.abbrev,
- NULL, NULL, rev.date_mode, 0);
+ pretty_print_commit(rev.commit_format, commit, &out, &ctx);
}
if (write(fd, out.buf, out.len) < 0)
die_errno("Writing SQUASH_MSG");
diff --git a/builtin-rev-list.c b/builtin-rev-list.c
index 4ba1c12..42cc8d8 100644
--- a/builtin-rev-list.c
+++ b/builtin-rev-list.c
@@ -96,9 +96,10 @@ static void show_commit(struct commit *commit, void *data)
if (revs->verbose_header && commit->buffer) {
struct strbuf buf = STRBUF_INIT;
- pretty_print_commit(revs->commit_format, commit,
- &buf, revs->abbrev, NULL, NULL,
- revs->date_mode, 0);
+ struct pretty_print_context ctx = {0};
+ ctx.abbrev = revs->abbrev;
+ ctx.date_mode = revs->date_mode;
+ pretty_print_commit(revs->commit_format, commit, &buf, &ctx);
if (revs->graph) {
if (buf.len) {
if (revs->commit_format != CMIT_FMT_ONELINE)
diff --git a/builtin-shortlog.c b/builtin-shortlog.c
index 4d4a3c8..8aa63c7 100644
--- a/builtin-shortlog.c
+++ b/builtin-shortlog.c
@@ -158,9 +158,12 @@ void shortlog_add_commit(struct shortlog *log, struct commit *commit)
sha1_to_hex(commit->object.sha1));
if (log->user_format) {
struct strbuf buf = STRBUF_INIT;
-
- pretty_print_commit(CMIT_FMT_USERFORMAT, commit, &buf,
- DEFAULT_ABBREV, "", "", DATE_NORMAL, 0);
+ struct pretty_print_context ctx = {0};
+ ctx.abbrev = DEFAULT_ABBREV;
+ ctx.subject = "";
+ ctx.after_subject = "";
+ ctx.date_mode = DATE_NORMAL;
+ pretty_print_commit(CMIT_FMT_USERFORMAT, commit, &buf, &ctx);
insert_one_record(log, author, buf.buf);
strbuf_release(&buf);
return;
diff --git a/builtin-show-branch.c b/builtin-show-branch.c
index be95930..9f13caa 100644
--- a/builtin-show-branch.c
+++ b/builtin-show-branch.c
@@ -293,8 +293,8 @@ static void show_one_commit(struct commit *commit, int no_name)
struct commit_name *name = commit->util;
if (commit->object.parsed) {
- pretty_print_commit(CMIT_FMT_ONELINE, commit,
- &pretty, 0, NULL, NULL, 0, 0);
+ struct pretty_print_context ctx = {0};
+ pretty_print_commit(CMIT_FMT_ONELINE, commit, &pretty, &ctx);
pretty_str = pretty.buf;
}
if (!prefixcmp(pretty_str, "[PATCH] "))
diff --git a/commit.h b/commit.h
index f4fc5c5..011766d 100644
--- a/commit.h
+++ b/commit.h
@@ -63,6 +63,15 @@ enum cmit_fmt {
CMIT_FMT_UNSPECIFIED,
};
+struct pretty_print_context
+{
+ int abbrev;
+ const char *subject;
+ const char *after_subject;
+ enum date_mode date_mode;
+ int need_8bit_cte;
+};
+
extern int non_ascii(int);
extern int has_non_ascii(const char *text);
struct rev_info; /* in revision.h, it circularly uses enum cmit_fmt */
@@ -71,12 +80,10 @@ enum cmit_fmt {
extern void get_commit_format(const char *arg, struct rev_info *);
extern void format_commit_message(const struct commit *commit,
const void *format, struct strbuf *sb,
- enum date_mode dmode);
-extern void pretty_print_commit(enum cmit_fmt fmt, const struct commit*,
- struct strbuf *,
- int abbrev, const char *subject,
- const char *after_subject, enum date_mode,
- int need_8bit_cte);
+ const struct pretty_print_context *context);
+extern void pretty_print_commit(enum cmit_fmt fmt, const struct commit *commit,
+ struct strbuf *sb,
+ const struct pretty_print_context *context);
void pp_user_info(const char *what, enum cmit_fmt fmt, struct strbuf *sb,
const char *line, enum date_mode dmode,
const char *encoding);
diff --git a/log-tree.c b/log-tree.c
index f7d54f2..f57487f 100644
--- a/log-tree.c
+++ b/log-tree.c
@@ -277,10 +277,9 @@ void show_log(struct rev_info *opt)
struct strbuf msgbuf = STRBUF_INIT;
struct log_info *log = opt->loginfo;
struct commit *commit = log->commit, *parent = log->parent;
- int abbrev = opt->diffopt.abbrev;
int abbrev_commit = opt->abbrev_commit ? opt->abbrev : 40;
- const char *subject = NULL, *extra_headers = opt->extra_headers;
- int need_8bit_cte = 0;
+ const char *extra_headers = opt->extra_headers;
+ struct pretty_print_context ctx = {0};
opt->loginfo = NULL;
if (!opt->verbose_header) {
@@ -347,8 +346,8 @@ void show_log(struct rev_info *opt)
*/
if (opt->commit_format == CMIT_FMT_EMAIL) {
- log_write_email_headers(opt, commit, &subject, &extra_headers,
- &need_8bit_cte);
+ log_write_email_headers(opt, commit, &ctx.subject, &extra_headers,
+ &ctx.need_8bit_cte);
} else if (opt->commit_format != CMIT_FMT_USERFORMAT) {
fputs(diff_get_color_opt(&opt->diffopt, DIFF_COMMIT), stdout);
if (opt->commit_format != CMIT_FMT_ONELINE)
@@ -405,11 +404,12 @@ void show_log(struct rev_info *opt)
/*
* And then the pretty-printed message itself
*/
- if (need_8bit_cte >= 0)
- need_8bit_cte = has_non_ascii(opt->add_signoff);
- pretty_print_commit(opt->commit_format, commit, &msgbuf,
- abbrev, subject, extra_headers, opt->date_mode,
- need_8bit_cte);
+ if (ctx.need_8bit_cte >= 0)
+ ctx.need_8bit_cte = has_non_ascii(opt->add_signoff);
+ ctx.date_mode = opt->date_mode;
+ ctx.abbrev = opt->diffopt.abbrev;
+ ctx.after_subject = extra_headers;
+ pretty_print_commit(opt->commit_format, commit, &msgbuf, &ctx);
if (opt->add_signoff)
append_signoff(&msgbuf, opt->add_signoff);
diff --git a/pretty.c b/pretty.c
index f5983f8..d6d57eb 100644
--- a/pretty.c
+++ b/pretty.c
@@ -442,7 +442,7 @@ struct chunk {
struct format_commit_context {
const struct commit *commit;
- enum date_mode dmode;
+ const struct pretty_print_context *pretty_ctx;
unsigned commit_header_parsed:1;
unsigned commit_message_parsed:1;
@@ -711,11 +711,11 @@ static size_t format_commit_item(struct strbuf *sb, const char *placeholder,
case 'a': /* author ... */
return format_person_part(sb, placeholder[1],
msg + c->author.off, c->author.len,
- c->dmode);
+ c->pretty_ctx->date_mode);
case 'c': /* committer ... */
return format_person_part(sb, placeholder[1],
msg + c->committer.off, c->committer.len,
- c->dmode);
+ c->pretty_ctx->date_mode);
case 'e': /* encoding */
strbuf_add(sb, msg + c->encoding.off, c->encoding.len);
return 1;
@@ -741,13 +741,13 @@ static size_t format_commit_item(struct strbuf *sb, const char *placeholder,
void format_commit_message(const struct commit *commit,
const void *format, struct strbuf *sb,
- enum date_mode dmode)
+ const struct pretty_print_context *pretty_ctx)
{
struct format_commit_context context;
memset(&context, 0, sizeof(context));
context.commit = commit;
- context.dmode = dmode;
+ context.pretty_ctx = pretty_ctx;
strbuf_expand(sb, format, format_commit_item, &context);
}
@@ -900,18 +900,18 @@ void pp_remainder(enum cmit_fmt fmt,
}
void pretty_print_commit(enum cmit_fmt fmt, const struct commit *commit,
- struct strbuf *sb, int abbrev,
- const char *subject, const char *after_subject,
- enum date_mode dmode, int need_8bit_cte)
+ struct strbuf *sb,
+ const struct pretty_print_context *context)
{
unsigned long beginning_of_body;
int indent = 4;
const char *msg = commit->buffer;
char *reencoded;
const char *encoding;
+ int need_8bit_cte = context->need_8bit_cte;
if (fmt == CMIT_FMT_USERFORMAT) {
- format_commit_message(commit, user_format, sb, dmode);
+ format_commit_message(commit, user_format, sb, context);
return;
}
@@ -946,8 +946,9 @@ void pretty_print_commit(enum cmit_fmt fmt, const struct commit *commit,
}
}
- pp_header(fmt, abbrev, dmode, encoding, commit, &msg, sb);
- if (fmt != CMIT_FMT_ONELINE && !subject) {
+ pp_header(fmt, context->abbrev, context->date_mode, encoding,
+ commit, &msg, sb);
+ if (fmt != CMIT_FMT_ONELINE && !context->subject) {
strbuf_addch(sb, '\n');
}
@@ -956,8 +957,8 @@ void pretty_print_commit(enum cmit_fmt fmt, const struct commit *commit,
/* These formats treat the title line specially. */
if (fmt == CMIT_FMT_ONELINE || fmt == CMIT_FMT_EMAIL)
- pp_title_line(fmt, &msg, sb, subject,
- after_subject, encoding, need_8bit_cte);
+ pp_title_line(fmt, &msg, sb, context->subject,
+ context->after_subject, encoding, need_8bit_cte);
beginning_of_body = sb->len;
if (fmt != CMIT_FMT_ONELINE)
--
1.6.5.18.g9f87a.dirty
^ permalink raw reply related
* [PATCH v2 4/5] stash list: use new %g formats instead of sed
From: Thomas Rast @ 2009-10-15 22:41 UTC (permalink / raw)
To: Jeff King, Junio C Hamano; +Cc: Jef Driesen, Nanako Shiraishi, git
In-Reply-To: <cover.1255645570.git.trast@student.ethz.ch>
With the new formats, we can rewrite 'git stash list' in terms of an
appropriate pretty format, instead of hand-editing with sed. This has
the advantage that it obeys the normal settings for git-log, notably
the pager.
Signed-off-by: Thomas Rast <trast@student.ethz.ch>
---
git-stash.sh | 3 +--
1 files changed, 1 insertions(+), 2 deletions(-)
diff --git a/git-stash.sh b/git-stash.sh
index 4febbbf..f8847c1 100755
--- a/git-stash.sh
+++ b/git-stash.sh
@@ -205,8 +205,7 @@ have_stash () {
list_stash () {
have_stash || return 0
- git log --no-color --pretty=oneline -g "$@" $ref_stash -- |
- sed -n -e 's/^[.0-9a-f]* refs\///p'
+ git log --format="%gd: %gs" -g "$@" $ref_stash --
}
show_stash () {
--
1.6.5.18.g9f87a.dirty
^ permalink raw reply related
* [PATCH v2 3/5] Introduce new pretty formats %g[sdD] for reflog information
From: Thomas Rast @ 2009-10-15 22:41 UTC (permalink / raw)
To: Jeff King, Junio C Hamano; +Cc: Jef Driesen, Nanako Shiraishi, git
In-Reply-To: <cover.1255645570.git.trast@student.ethz.ch>
Add three new --pretty=format escapes:
%gD long reflog descriptor (e.g. refs/stash@{0})
%gd short reflog descriptor (e.g. stash@{0})
%gs reflog message
This is achieved by passing down the reflog info, if any, inside the
pretty_print_context struct.
We use the newly refactored get_reflog_selector(), and give it some
extra functionality to extract a shortened ref. The shortening has a
very simple 1-element cache, since it will usually be called with the
same ref every time. Add another helper get_reflog_message() for the
message extraction.
Note that the --format="%h %gD: %gs" tests may not work in real
repositories, as the --pretty formatter doesn't know to leave away the
": " on the last commit in an incomplete (because git-gc removed the
old part) reflog. This equivalence is nevertheless the main goal of
this patch.
Signed-off-by: Thomas Rast <trast@student.ethz.ch>
---
Documentation/pretty-formats.txt | 3 +++
commit.h | 1 +
log-tree.c | 1 +
pretty.c | 17 +++++++++++++++++
reflog-walk.c | 37 ++++++++++++++++++++++++++++++++++---
reflog-walk.h | 8 ++++++++
t/t1411-reflog-show.sh | 12 ++++++++++++
7 files changed, 76 insertions(+), 3 deletions(-)
diff --git a/Documentation/pretty-formats.txt b/Documentation/pretty-formats.txt
index 2a845b1..6359272 100644
--- a/Documentation/pretty-formats.txt
+++ b/Documentation/pretty-formats.txt
@@ -123,6 +123,9 @@ The placeholders are:
- '%s': subject
- '%f': sanitized subject line, suitable for a filename
- '%b': body
+- '%gD': reflog selector, e.g., `refs/stash@{1}`
+- '%gd': shortened reflog selector, e.g., `stash@{1}`
+- '%gs': reflog subject
- '%Cred': switch color to red
- '%Cgreen': switch color to green
- '%Cblue': switch color to blue
diff --git a/commit.h b/commit.h
index 011766d..15cb649 100644
--- a/commit.h
+++ b/commit.h
@@ -70,6 +70,7 @@ struct pretty_print_context
const char *after_subject;
enum date_mode date_mode;
int need_8bit_cte;
+ struct reflog_walk_info *reflog_info;
};
extern int non_ascii(int);
diff --git a/log-tree.c b/log-tree.c
index f57487f..8e782fc 100644
--- a/log-tree.c
+++ b/log-tree.c
@@ -409,6 +409,7 @@ void show_log(struct rev_info *opt)
ctx.date_mode = opt->date_mode;
ctx.abbrev = opt->diffopt.abbrev;
ctx.after_subject = extra_headers;
+ ctx.reflog_info = opt->reflog_info;
pretty_print_commit(opt->commit_format, commit, &msgbuf, &ctx);
if (opt->add_signoff)
diff --git a/pretty.c b/pretty.c
index d6d57eb..fc65fca 100644
--- a/pretty.c
+++ b/pretty.c
@@ -7,6 +7,7 @@
#include "mailmap.h"
#include "log-tree.h"
#include "color.h"
+#include "reflog-walk.h"
static char *user_format;
@@ -701,6 +702,22 @@ static size_t format_commit_item(struct strbuf *sb, const char *placeholder,
case 'd':
format_decoration(sb, commit);
return 1;
+ case 'g': /* reflog info */
+ switch(placeholder[1]) {
+ case 'd': /* reflog selector */
+ case 'D':
+ if (c->pretty_ctx->reflog_info)
+ get_reflog_selector(sb,
+ c->pretty_ctx->reflog_info,
+ c->pretty_ctx->date_mode,
+ (placeholder[1] == 'd'));
+ return 2;
+ case 's': /* reflog message */
+ if (c->pretty_ctx->reflog_info)
+ get_reflog_message(sb, c->pretty_ctx->reflog_info);
+ return 2;
+ }
+ return 0; /* unknown %g placeholder */
}
/* For the rest we have to parse the commit header. */
diff --git a/reflog-walk.c b/reflog-walk.c
index 596bafe..6c6867b 100644
--- a/reflog-walk.c
+++ b/reflog-walk.c
@@ -243,15 +243,29 @@ void fake_reflog_parent(struct reflog_walk_info *info, struct commit *commit)
void get_reflog_selector(struct strbuf *sb,
struct reflog_walk_info *reflog_info,
- enum date_mode dmode)
+ enum date_mode dmode,
+ int shorten)
{
struct commit_reflog *commit_reflog = reflog_info->last_commit_reflog;
struct reflog_info *info;
+ static const char *last_ref = NULL;
+ static char *last_short_ref = NULL;
+ const char *printed_ref;
if (!commit_reflog)
return;
- strbuf_addf(sb, "%s@{", commit_reflog->reflogs->ref);
+ if (shorten) {
+ if (last_ref != commit_reflog->reflogs->ref) {
+ free(last_short_ref);
+ last_short_ref = shorten_unambiguous_ref(commit_reflog->reflogs->ref, 0);
+ }
+ printed_ref = last_short_ref;
+ } else {
+ printed_ref = commit_reflog->reflogs->ref;
+ }
+
+ strbuf_addf(sb, "%s@{", printed_ref);
if (commit_reflog->flag || dmode) {
info = &commit_reflog->reflogs->items[commit_reflog->recno+1];
strbuf_addstr(sb, show_date(info->timestamp, info->tz, dmode));
@@ -263,6 +277,23 @@ void get_reflog_selector(struct strbuf *sb,
strbuf_addch(sb, '}');
}
+void get_reflog_message(struct strbuf *sb,
+ struct reflog_walk_info *reflog_info)
+{
+ struct commit_reflog *commit_reflog = reflog_info->last_commit_reflog;
+ struct reflog_info *info;
+ size_t len;
+
+ if (!commit_reflog)
+ return;
+
+ info = &commit_reflog->reflogs->items[commit_reflog->recno+1];
+ len = strlen(info->message);
+ if (len > 0)
+ len--; /* strip away trailing newline */
+ strbuf_add(sb, info->message, len);
+}
+
void show_reflog_message(struct reflog_walk_info *reflog_info, int oneline,
enum date_mode dmode)
{
@@ -272,7 +303,7 @@ void show_reflog_message(struct reflog_walk_info *reflog_info, int oneline,
struct strbuf selector = STRBUF_INIT;
info = &commit_reflog->reflogs->items[commit_reflog->recno+1];
- get_reflog_selector(&selector, reflog_info, dmode);
+ get_reflog_selector(&selector, reflog_info, dmode, 0);
if (oneline) {
printf("%s: %s", selector.buf, info->message);
}
diff --git a/reflog-walk.h b/reflog-walk.h
index 74c9096..7bd2cd4 100644
--- a/reflog-walk.h
+++ b/reflog-walk.h
@@ -3,6 +3,8 @@
#include "cache.h"
+struct reflog_walk_info;
+
extern void init_reflog_walk(struct reflog_walk_info** info);
extern int add_reflog_for_walk(struct reflog_walk_info *info,
struct commit *commit, const char *name);
@@ -10,5 +12,11 @@ extern void fake_reflog_parent(struct reflog_walk_info *info,
struct commit *commit);
extern void show_reflog_message(struct reflog_walk_info *info, int,
enum date_mode);
+extern void get_reflog_message(struct strbuf *sb,
+ struct reflog_walk_info *reflog_info);
+extern void get_reflog_selector(struct strbuf *sb,
+ struct reflog_walk_info *reflog_info,
+ enum date_mode dmode,
+ int shorten);
#endif
diff --git a/t/t1411-reflog-show.sh b/t/t1411-reflog-show.sh
index c18ed8e..cb8d0fd 100755
--- a/t/t1411-reflog-show.sh
+++ b/t/t1411-reflog-show.sh
@@ -64,4 +64,16 @@ test_expect_success 'using --date= shows reflog date (oneline)' '
test_cmp expect actual
'
+test_expect_success '--format="%h %gD: %gs" is same as git-reflog' '
+ git reflog >expect &&
+ git log -g --format="%h %gD: %gs" >actual &&
+ test_cmp expect actual
+'
+
+test_expect_success '--format="%h %gD: %gs" is same as git-reflog (with date)' '
+ git reflog --date=raw >expect &&
+ git log -g --format="%h %gD: %gs" --date=raw >actual &&
+ test_cmp expect actual
+'
+
test_done
--
1.6.5.18.g9f87a.dirty
^ permalink raw reply related
* [PATCH v2 2/5] reflog-walk: refactor the branch@{num} formatting
From: Thomas Rast @ 2009-10-15 22:41 UTC (permalink / raw)
To: Jeff King, Junio C Hamano; +Cc: Jef Driesen, Nanako Shiraishi, git
In-Reply-To: <cover.1255645570.git.trast@student.ethz.ch>
We'll use the same output in an upcoming commit, so refactor its
formatting (which was duplicated anyway) into a separate function.
Signed-off-by: Thomas Rast <trast@student.ethz.ch>
---
reflog-walk.c | 54 ++++++++++++++++++++++++++++++++----------------------
1 files changed, 32 insertions(+), 22 deletions(-)
diff --git a/reflog-walk.c b/reflog-walk.c
index 5623ea6..596bafe 100644
--- a/reflog-walk.c
+++ b/reflog-walk.c
@@ -241,36 +241,46 @@ void fake_reflog_parent(struct reflog_walk_info *info, struct commit *commit)
commit->object.flags &= ~(ADDED | SEEN | SHOWN);
}
-void show_reflog_message(struct reflog_walk_info *info, int oneline,
+void get_reflog_selector(struct strbuf *sb,
+ struct reflog_walk_info *reflog_info,
+ enum date_mode dmode)
+{
+ struct commit_reflog *commit_reflog = reflog_info->last_commit_reflog;
+ struct reflog_info *info;
+
+ if (!commit_reflog)
+ return;
+
+ strbuf_addf(sb, "%s@{", commit_reflog->reflogs->ref);
+ if (commit_reflog->flag || dmode) {
+ info = &commit_reflog->reflogs->items[commit_reflog->recno+1];
+ strbuf_addstr(sb, show_date(info->timestamp, info->tz, dmode));
+ } else {
+ strbuf_addf(sb, "%d", commit_reflog->reflogs->nr
+ - 2 - commit_reflog->recno);
+ }
+
+ strbuf_addch(sb, '}');
+}
+
+void show_reflog_message(struct reflog_walk_info *reflog_info, int oneline,
enum date_mode dmode)
{
- if (info && info->last_commit_reflog) {
- struct commit_reflog *commit_reflog = info->last_commit_reflog;
+ if (reflog_info && reflog_info->last_commit_reflog) {
+ struct commit_reflog *commit_reflog = reflog_info->last_commit_reflog;
struct reflog_info *info;
+ struct strbuf selector = STRBUF_INIT;
info = &commit_reflog->reflogs->items[commit_reflog->recno+1];
+ get_reflog_selector(&selector, reflog_info, dmode);
if (oneline) {
- printf("%s@{", commit_reflog->reflogs->ref);
- if (commit_reflog->flag || dmode)
- printf("%s", show_date(info->timestamp,
- info->tz,
- dmode));
- else
- printf("%d", commit_reflog->reflogs->nr
- - 2 - commit_reflog->recno);
- printf("}: %s", info->message);
+ printf("%s: %s", selector.buf, info->message);
}
else {
- printf("Reflog: %s@{", commit_reflog->reflogs->ref);
- if (commit_reflog->flag || dmode)
- printf("%s", show_date(info->timestamp,
- info->tz,
- dmode));
- else
- printf("%d", commit_reflog->reflogs->nr
- - 2 - commit_reflog->recno);
- printf("} (%s)\nReflog message: %s",
- info->email, info->message);
+ printf("Reflog: %s (%s)\nReflog message: %s",
+ selector.buf, info->email, info->message);
}
+
+ strbuf_release(&selector);
}
}
--
1.6.5.18.g9f87a.dirty
^ permalink raw reply related
* Re: [PATCH] Proof-of-concept patch to remember what the detached HEAD was
From: Thomas Rast @ 2009-10-15 22:56 UTC (permalink / raw)
To: Daniel Barkalow
Cc: Nicolas Pitre, James Pickens, Jeff King, Junio C Hamano,
Jay Soffian, git
In-Reply-To: <alpine.LNX.2.00.0910151517070.32515@iabervon.org>
Daniel Barkalow wrote:
> On Thu, 15 Oct 2009, Nicolas Pitre wrote:
>
> > On Thu, 15 Oct 2009, Daniel Barkalow wrote:
> >
> > > I think the description used in CVS and SVN (and, I think, others) is that
> > > you're not at the HEAD revision.
[...]
> > > * origin/master (not at head)
> > > $ git checkout 123cafe^5; git branch
> > > * 123cafe^5 (not at head)
> >
> > I think this is wrong. Git has multiple heads, and insisting on "not at
> > head" would be extremely confusing.
>
> Maybe "(not at a head)"? Git does have multiple heads, but what's checked
> out isn't one of them, and that's actually the point.
Please don't reuse 'head' (even lowercase) in this context/meaning. I
see enough people coming to IRC who are confused about the fact that
they checked out some old commit, hence HEAD is just that, but they
refer to the *newest* commit on whatever branch they like most as HEAD
because that's what it means in SVN.
Now imagine having to explain to them that their (SVN) 'HEAD' is not
the same as git's 'HEAD', but can rightly be considered the equivalent
of master's 'head'; and that furthermore, you are always at 'HEAD' but
not always at 'head'.
I think in this case '(detached)' would be more consistent with
current terminology, though we may of course try to change it.
(I've tried to consistently use 'tip' in the branch tip meaning,
admittedly without knowing exactly how this intersects with
mercurial's definition of the term.)
--
Thomas Rast
trast@{inf,student}.ethz.ch
^ permalink raw reply
* Re: [PATCH] Proof-of-concept patch to remember what the detached HEAD was
From: Nicolas Pitre @ 2009-10-15 23:16 UTC (permalink / raw)
To: Junio C Hamano
Cc: Jeff King, James Pickens, Daniel Barkalow, Jay Soffian, git
In-Reply-To: <7vfx9k1faa.fsf@alter.siamese.dyndns.org>
On Thu, 15 Oct 2009, Junio C Hamano wrote:
> Junio C Hamano <gitster@pobox.com> writes:
>
> > $ git checkout origin/next ;# ditto
> > $ git symbolic-ref HEAD
> > refs/remotes/origin/next
>
> Ok, after reading Daniel's message to remind us that "git fetch" after
> this will get us into trouble, I agree that detaching HEAD is inevitable.
Either the fetch should be refused just like a commit would, or HEAD
gets detached automatically in that case. Probably the former would be
less confusing, otherwise the user might expect to see the updated
remote branch after the fetch and not understand that a detached HEAD
remained on the previous remote branch state.
Nicolas
^ permalink raw reply
* Re: [PATCH] Proof-of-concept patch to remember what the detached HEAD was
From: James Pickens @ 2009-10-15 23:47 UTC (permalink / raw)
To: Junio C Hamano
Cc: Jeff King, Nicolas Pitre, Daniel Barkalow, Jay Soffian, git
In-Reply-To: <7vfx9k1faa.fsf@alter.siamese.dyndns.org>
On Thu, Oct 15, 2009 at 3:08 PM, Junio C Hamano <gitster@pobox.com> wrote:
> Junio C Hamano <gitster@pobox.com> writes:
>
>> $ git checkout origin/next ;# ditto
>> $ git symbolic-ref HEAD
>> refs/remotes/origin/next
>
> Ok, after reading Daniel's message to remind us that "git fetch" after
> this will get us into trouble, I agree that detaching HEAD is inevitable.
Some people liked the idea, so let's not give up just yet. Here are a few
things Git could do when a fetch wants to update the currently checked out
branch:
1. Refuse the fetch.
2. Update the ref, leaving the user with a work tree and index that don't
match their HEAD.
3. Detach the HEAD, then update the ref.
4. Update the ref, then check it out.
Option 1 is ok, as long as the "next step" is not too complicated. It's no
good if the user has to checkout a different branch, then fetch, then
checkout the original branch again.
Option 2 is crap.
Option 3 seems reasonable, but it might be just as scary/confusing to
newbies as the current behavior, so I don't think it should be the default.
Option 4 also seems reasonable, but you run into problems if the user had
changed the index or work tree. In that case Git could do 'checkout
--merge' automatically. This option is also less "pure" since it lets 'git
fetch' modify the index and work tree.
So how about this:
* 'git fetch' refuses the fetch by default.
* 'git fetch --detach' detaches HEAD, then updates the ref
* 'git pull' detaches HEAD, updates the ref, then checks out the new ref
with --merge.
BTW I'm not convinced this is any better than the current UI... just
thinking out loud. And I find it more than a little depressing that most
of these ideas have already been discussed almost 3 years ago (thanks Jeff
for the pointer).
James
^ permalink raw reply
* [PATCH] am: allow some defaults to be specified via git-config
From: Sam Vilain @ 2009-10-15 23:50 UTC (permalink / raw)
To: git; +Cc: Nigel McNie, Sam Vilain
Some users prefer in particular '3way' to be the default, let them
specify it via the config file - and some other boolean settings while
we're at it.
Signed-off-by: Sam Vilain <sam.vilain@catalyst.net.nz>
---
Documentation/config.txt | 4 ++++
Documentation/git-am.txt | 11 +++++++++--
git-am.sh | 5 +++++
3 files changed, 18 insertions(+), 2 deletions(-)
diff --git a/Documentation/config.txt b/Documentation/config.txt
index cd17814..82adca5 100644
--- a/Documentation/config.txt
+++ b/Documentation/config.txt
@@ -476,6 +476,10 @@ it will be treated as a shell command. For example, defining
executed from the top-level directory of a repository, which may
not necessarily be the current directory.
+am.*::
+ Specify defaults for linkgit:git-am[1]. Currently, the three
+ boolean options, 'sign', 'utf8' and 'keep' may be specified.
+
apply.ignorewhitespace::
When set to 'change', tells 'git-apply' to ignore changes in
whitespace, in the same way as the '--ignore-space-change'
diff --git a/Documentation/git-am.txt b/Documentation/git-am.txt
index 67ad5da..c22bca2 100644
--- a/Documentation/git-am.txt
+++ b/Documentation/git-am.txt
@@ -38,6 +38,7 @@ OPTIONS
-k::
--keep::
Pass `-k` flag to 'git-mailinfo' (see linkgit:git-mailinfo[1]).
+ May be specified via 'am.keep' (see linkgit:git-config[1]).
-c::
--scissors::
@@ -60,7 +61,8 @@ OPTIONS
preferred encoding if it is not UTF-8).
+
This was optional in prior versions of git, but now it is the
-default. You can use `--no-utf8` to override this.
+default. You can use `--no-utf8` to override this, or set
+'am.utf8' to no via linkgit:git-config[1].
--no-utf8::
Pass `-n` flag to 'git-mailinfo' (see
@@ -71,7 +73,12 @@ default. You can use `--no-utf8` to override this.
When the patch does not apply cleanly, fall back on
3-way merge if the patch records the identity of blobs
it is supposed to apply to and we have those blobs
- available locally.
+ available locally. This can be configured via
+ linkgit:git-config[1] using the 'am.3way' option
+
+--no-3way::
+ If 'am.3way' is specified to be true in the configuration file,
+ this switch allows it to be disabled.
--ignore-date::
--ignore-space-change::
diff --git a/git-am.sh b/git-am.sh
index c132f50..a22fa3b 100755
--- a/git-am.sh
+++ b/git-am.sh
@@ -294,6 +294,9 @@ git_apply_opt=
committer_date_is_author_date=
ignore_date=
+# apply defaults from config
+eval "$(git config --bool --get-regexp '^am\.(sign|utf8|keep)' | sed 's/^am\.\([a-z0-9]*\) /\1=/;s/true/t/;s/false//')"
+
while test $# != 0
do
case "$1" in
@@ -303,6 +306,8 @@ do
: ;;
-3|--3way)
threeway=t ;;
+ --no-3way)
+ threeway= ;;
-s|--signoff)
sign=t ;;
-u|--utf8)
--
1.6.3.3
^ permalink raw reply related
* Re: cgit suggestion
From: Lars Hjemli @ 2009-10-16 0:13 UTC (permalink / raw)
To: Alexey Nezhdanov; +Cc: git
In-Reply-To: <200909272302.30742.snakeru@gmail.com>
[* Sorry for the late reply *]
On Sun, Sep 27, 2009 at 21:02, Alexey Nezhdanov <snakeru@gmail.com> wrote:
> Here is the diff. It adds feature of downloading 'named' tarball from the tag
> description page.
Thanks, I've applied the patch (slightly modified) to my master branch
and pushed the result to http://hjemli.net/git/cgit.
--
larsh
^ permalink raw reply
page: next (older) | prev (newer) | latest
- recent:[subjects (threaded)|topics (new)|topics (active)]
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox