* Re: merge-recur status
From: Junio C Hamano @ 2006-08-09 21:18 UTC (permalink / raw)
To: Johannes Schindelin; +Cc: git
In-Reply-To: <Pine.LNX.4.63.0608092232000.13885@wbgn013.biozentrum.uni-wuerzburg.de>
Johannes Schindelin <Johannes.Schindelin@gmx.de> writes:
> I tried to wrap my head over it, but seem unable to do so. Also, I do not
> find the case 14ALT (which is mentioned in unpack-trees.c:603) in
> Documentation/technical/trivial-merge.txt.
That is t/t1000-read-tree-m-3way.sh case 14. The current
semantics for case 14 used to be called ALT until 3e03aaf
simplified the table to reflect the reality, because the
"alternative" semantics had been in use for quite some time
already back then.
I'd like to take a look at 41094b8e, the real trouble that is
causing you grief, sometime later, but I'm currently pondering
if the one I tag should be called 1.4.2 or 1.4.2-rc4 ;-).
^ permalink raw reply
* Re: [PATCH/RFC] gitweb: Great subroutines renaming
From: Junio C Hamano @ 2006-08-09 21:11 UTC (permalink / raw)
To: git; +Cc: jnareb
In-Reply-To: <ebdi1v$cv5$1@sea.gmane.org>
Jakub Narebski <jnareb@gmail.com> writes:
> Subroutines in gitweb: <current name> => <proposed rename>.
If it is not too much trouble, having a few line summary of what
each of the sub does would greatly help judging if the names are
appropriate.
^ permalink raw reply
* merge-recur status
From: Johannes Schindelin @ 2006-08-09 21:02 UTC (permalink / raw)
To: git
Hi,
with my last patches, I tested merge-recur on 'next' (46faaaf8) by
comparing the index after -recur and -recursive, respectively.
At this stage, there are 1017 merges with exactly two parents (which is
the only type of merge -recursive can handle).
For all but 9 of them, the indices where identical. The reason for those 9
to differ: the order of the merge-bases. -recursive does its own thing
(set intersection after traversing the commits by hand, probably in
topological order), whereas with the last patches, -recur orders them by
decreasing date.
The 9 cases are:
52bc0e29: 1 better
a5c8a98c: 1 better, 2 identical
63bccad3: 1 identical
dcaad49c: 3 identical
7f2d5cb5: 3 identical
c2b9e699: 2 identical
4cc0b8a4: 2 identical
d2b9b5f5: 1 identical
41094b8e: worse
where
- "1 better" means that -recursive has a conflicting hunk, where
-recur resolves it (it is identical with the commit),
- "1 identical" means that there were multiply conflicting hunks (meaning
that merging two merge-bases already conflicted, and another conflict
came on top), and the versions of -recursive and -recur differ only in
the order of the conflict nesting, and
- "worse" means that the merge of 859ab4c and 061ad5f, which _should_ have
resulted in 41094b8e (as with -recursive) resulted in a
"fatal: Entry 'epoch.c' would be overwritten by merge. Cannot merge."
It might have its reason in the fact that 859ab4c and 061ad5f have
8 (!) merge bases.
Now, on average, -recur takes 0.1 seconds on average, spending only 9.9%
of what -recursive takes (on average). So I am happy with the speed.
I think -recur is really really close to being trustworthy, _but_ I do not
understand the reason behind the error. It happens in line 614 of
unpack-trees.c, where the "index" contains epoch.c, and "index" and
"remote" are identical, but "head" is empty.
I tried to wrap my head over it, but seem unable to do so. Also, I do not
find the case 14ALT (which is mentioned in unpack-trees.c:603) in
Documentation/technical/trivial-merge.txt.
Help?
Ciao,
Dscho
^ permalink raw reply
* Re: [PATCH/RFC] gitweb: Great subroutines renaming
From: Jakub Narebski @ 2006-08-09 20:54 UTC (permalink / raw)
To: git
In-Reply-To: <ebb3fm$2md$1@sea.gmane.org>
Subroutines in gitweb: <current name> => <proposed rename>.
If nobody would give any better suggestions, or warn about patches to gitweb
to be sent, could we do that "Great subroutines renaming" some time soon?
TIA.
* validate_input
* esc_param
* esc_html
* unquote
* untabify
* chop_str
* age_class
* age_string
* mode_str
* file_type
* format_log_line_html
* git_get_referencing => format_mark_referencing (???)
* git_read_head => git_get_head_hash
* git_read_hash => git_get_hash_by_ref
* git_get_hash_by_path
* git_get_type
* git_get_project_config
* git_get_project_config_bool
* git_read_description => git_get_project_description
* git_read_projects => git_get_projects_list
* read_info_ref => git_get_references
* git_read_refs => git_get_refs_list
* date_str => parse_date
* git_read_tag => parse_tag
* git_read_commit => parse_commit
* get_file_owner
* mimetype_guess_file => ??? (reads, parses and uses mime.types like file)
* mimetype_guess => (to be incorporated in blob_mimetype)
* git_blob_plain_mimetype => blob_mimetype
* git_get_paging_nav => ???
* git_page_nav => git_print_page_nav
* git_header_div => git_print_header_div
* git_print_page_path
* git_diff_print => (to be made obsolete)
* git_header_html
* git_footer_html
* die_error
* git_shortlog_body
* git_tags_body
* git_heads_body
* git_project_list
* git_summary
* git_tag
* git_blame2 => git_blame (?)
* git_blame => git_annotate (?)
* git_tags
* git_heads
* git_blob_plain
* git_blob
* git_tree
* git_log
* git_commit
* git_blobdiff
* git_blobdiff_plain
* git_commitdiff
* git_commitdiff_plain
* git_history
* git_search
* git_shortlog
* git_rss
* git_opml
--
Jakub Narebski
Warsaw, Poland
ShadeHawk on #git
^ permalink raw reply
* [PATCH] merge-recur: do not die unnecessarily
From: Johannes Schindelin @ 2006-08-09 20:31 UTC (permalink / raw)
To: git, junkio
When the cache is dirty, and we switch the index file from temporary
to final, we want to discard the cache without complaint.
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
---
merge-recursive.c | 6 ++++--
1 files changed, 4 insertions(+), 2 deletions(-)
diff --git a/merge-recursive.c b/merge-recursive.c
index 2d3ab4f..be97752 100644
--- a/merge-recursive.c
+++ b/merge-recursive.c
@@ -139,8 +139,10 @@ static int flush_cache(void)
static void setup_index(int temp)
{
current_index_file = temp ? temporary_index_file: original_index_file;
- if (cache_dirty)
- die("fatal: cache changed flush_cache();");
+ if (cache_dirty) {
+ discard_cache();
+ cache_dirty = 0;
+ }
unlink(temporary_index_file);
discard_cache();
}
--
1.4.2.rc3.g29d0-dirty
^ permalink raw reply related
* [PATCH] merge-recur: try to merge older merge bases first
From: Johannes Schindelin @ 2006-08-09 20:30 UTC (permalink / raw)
To: git, junkio
It seems to be the only sane way to do it: when a two-head merge is
done, and the merge-base and one of the two branches agree, the
merge assumes that the other branch has something new.
If we start creating virtual commits from newer merge-bases, and go
back to older merge-bases, and then merge with newer commits again,
chances are that a patch is lost, _because_ the merge-base and the
head agree on it. Unlikely, yes, but it happened to me.
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
---
merge-recursive.c | 16 +++++++++++++-
1 files changed, 13 insertions(+), 1 deletion(-)
diff --git a/merge-recursive.c b/merge-recursive.c
index f5b547b..2d3ab4f 100644
--- a/merge-recursive.c
+++ b/merge-recursive.c
@@ -1191,6 +1191,17 @@ static int merge_trees(struct tree *head
return clean;
}
+static struct commit_list *reverse_commit_list(struct commit_list *list)
+{
+ struct commit_list *next = NULL, *current, *backup;
+ for (current = list; current; current = backup) {
+ backup = current->next;
+ current->next = next;
+ next = current;
+ }
+ return next;
+}
+
/*
* Merge the commits h1 and h2, return the resulting virtual
* commit object and a flag indicating the cleaness of the merge.
@@ -1216,7 +1227,8 @@ int merge(struct commit *h1,
if (ancestor)
commit_list_insert(ancestor, &ca);
else
- ca = get_merge_bases(h1, h2, 1);
+ ca = reverse_commit_list(get_merge_bases(h1, h2, 1));
+ //ca = get_merge_bases(h1, h2, 1);
output("found %u common ancestor(s):", commit_list_count(ca));
for (iter = ca; iter; iter = iter->next)
--
1.4.2.rc3.g29d0-dirty
^ permalink raw reply related
* Re: HOWTO set up a repository which can be pushed into over HTTP
From: Johannes Schindelin @ 2006-08-09 20:20 UTC (permalink / raw)
To: git; +Cc: Junio C Hamano, git
In-Reply-To: <20060809193118.GC7841@nospam.com>
Hi,
On Wed, 9 Aug 2006, Rutger Nijlunsing wrote:
> > [...] but refer the user to the Apache manual if she cannot find it.
>
> Ok, but I find it always very convenient when someone describes the
> situation for _me_. So if other distro's would join in, I would be
> delighted. And indeed a general fallback to the Apache documentation
> would be good for all distro's (+ homegrown) not covered.
If everybody did this, you would not _find_ your distro-specific things
;-)
But I agree, Debian is a bureaucrat's dream. I positively _hate_ it. So
much so, that I left Knoppix behind.
> [lots of explanations of Debian, Windows Explorer, etc.]
Thanks for clearing these up for me!
> Do you want to finish it, or should I do a reedit?
I am a little short on time, and I want to finish the merge-recur stuff,
so I would be really grateful if you did it.
Ciao,
Dscho
^ permalink raw reply
* Re: Strange output of git-diff-tree
From: Junio C Hamano @ 2006-08-09 20:17 UTC (permalink / raw)
To: Jakub Narebski; +Cc: git
In-Reply-To: <7vfyg54vjb.fsf@assigned-by-dhcp.cox.net>
Junio C Hamano <junkio@cox.net> writes:
> Well spotted. The minimum reproduction recipe is:
>
> $ git diff-tree --find-copies-harder 2ad9331
>
> Will look into it.
This is because the original command line has -C and -M in this
order, and the minimum reproduction does not have either.
diff_setup_done() "silently" complains about it but the caller
was not taking notice.
What happens is that the check at the top of diff_setup_done()
fails, and does not set up options->abbrev to 40 upon seeing
abbrev is set to zero. This later causes find_unique_abbrev()
to be called with len=0, which returns an empty string, because
it is not expecing to get something like that.
Incidentally, there is another funny breakage related to this.
$ git diff-tree --find-copies-harder v1.4.1
complains quite a lot about "feeding unmodified" file pairs.
This is because "harder" is given without -C.
So there are three things to fix:
(1) callers of diff_setup_done() that do not check and die
should do so like others.
(2) find_unique_abbrev() should prepare being called with
len=0.
(3) make --find-copies-harder imply -C.
Strictly speaking, the third is an incompatible change, but it
makes something that used to be an invalid/undefined operation
to a valid one, so it would not be so bad.
*1*
diff --git a/builtin-diff.c b/builtin-diff.c
index 1075855..dd9886c 100644
--- a/builtin-diff.c
+++ b/builtin-diff.c
@@ -253,7 +253,8 @@ int cmd_diff(int argc, const char **argv
argc = setup_revisions(argc, argv, &rev, NULL);
if (!rev.diffopt.output_format) {
rev.diffopt.output_format = DIFF_FORMAT_PATCH;
- diff_setup_done(&rev.diffopt);
+ if (diff_setup_done(&rev.diffopt) < 0)
+ die("diff_setup_done failed");
}
/* Do we have --cached and not have a pending object, then
diff --git a/revision.c b/revision.c
index a58257a..5a91d06 100644
--- a/revision.c
+++ b/revision.c
@@ -936,7 +936,8 @@ int setup_revisions(int argc, const char
revs->diffopt.output_format = DIFF_FORMAT_PATCH;
}
revs->diffopt.abbrev = revs->abbrev;
- diff_setup_done(&revs->diffopt);
+ if (diff_setup_done(&revs->diffopt) < 0)
+ die("diff_setup_done failed");
return left;
}
*2*
diff --git a/sha1_name.c b/sha1_name.c
index 5fe8e5d..c5a05fa 100644
--- a/sha1_name.c
+++ b/sha1_name.c
@@ -193,7 +193,7 @@ const char *find_unique_abbrev(const uns
is_null = !memcmp(sha1, null_sha1, 20);
memcpy(hex, sha1_to_hex(sha1), 40);
- if (len == 40)
+ if (len == 40 || !len)
return hex;
while (len < 40) {
unsigned char sha1_ret[20];
*3*
diff --git a/diff.c b/diff.c
index 895c137..02a409d 100644
--- a/diff.c
+++ b/diff.c
@@ -1515,9 +1515,10 @@ void diff_setup(struct diff_options *opt
int diff_setup_done(struct diff_options *options)
{
- if ((options->find_copies_harder &&
- options->detect_rename != DIFF_DETECT_COPY) ||
- (0 <= options->rename_limit && !options->detect_rename))
+ if (options->find_copies_harder)
+ options->detect_rename = DIFF_DETECT_COPY;
+
+ if ((0 <= options->rename_limit && !options->detect_rename)
return -1;
if (options->output_format & (DIFF_FORMAT_NAME |
diff --git a/sha1_name.c b/sha1_name.c
index 5fe8e5d..c5a05fa 100644
--- a/sha1_name.c
+++ b/sha1_name.c
@@ -193,7 +193,7 @@ const char *find_unique_abbrev(const uns
is_null = !memcmp(sha1, null_sha1, 20);
memcpy(hex, sha1_to_hex(sha1), 40);
- if (len == 40)
+ if (len == 40 || !len)
return hex;
while (len < 40) {
unsigned char sha1_ret[20];
^ permalink raw reply related
* Re: [PATCH and RFC] gitweb: Remove --full-history from git_history
From: Johannes Schindelin @ 2006-08-09 20:08 UTC (permalink / raw)
To: Fredrik Kuivinen; +Cc: Jakub Narebski, git
In-Reply-To: <20060809192815.GA7954@c165.ib.student.liu.se>
Hi,
your struct path_list and find_renames() is so similar to what is already
in merge-recursive.c that it is not even funny.
Furthermore, the struct path_list from path-list.[ch] implements a sorted
list, so that lookups are way cheaper than with linked lists.
IMHO this whole renaming stuff should go into a new file, renames.c, and
be reused as often as possible.
Ciao,
Dscho
^ permalink raw reply
* Re: [PATCH] merge-recur: if there is no common ancestor, fake empty one
From: Alex Riesen @ 2006-08-09 19:55 UTC (permalink / raw)
To: Johannes Schindelin; +Cc: git, junkio
In-Reply-To: <Pine.LNX.4.63.0608091943570.1800@wbgn013.biozentrum.uni-wuerzburg.de>
Johannes Schindelin, Wed, Aug 09, 2006 19:44:38 +0200:
>
> > + *write_sha1_file_prepare(NULL, 0, tree_type, &tree->object.sha1,
>
> ... make this "tree->object.sha1" _without_ a "&", of course.
>
And without the asterisk before write_sha1_file_prepare
^ permalink raw reply
* Re: [PATCH] http-push: Make WebDAV work with (broken?) default apache2 WebDAV module
From: Junio C Hamano @ 2006-08-09 19:33 UTC (permalink / raw)
To: git; +Cc: git, Johannes Schindelin, Nick Hengeveld
In-Reply-To: <20060809185423.GB7841@nospam.com>
Rutger Nijlunsing <rutger@nospam.com> writes:
> WebDAV on Debian unstable cannot handle renames on WebDAV from
> file.ext to newfile (without ext) when newfile* already
> exists. Normally, git creates a file like 'objects/xx/sha1.token',
> which is renamed to 'objects/xx/sha1' when transferred completely.
>
> Just use '_' instead of '.' so WebDAV doesn't see it as an extension
> change.
>
> Signed-off-by: Rutger Nijlunsing <git@tux.tmfweb.nl>
> Acked-by: Johannes Schindelin <Johannes.Schindelin@gmx.de>
Good problem and workaround description. Nick, does this look
sane to you, or is there a more kosher way to handle this?
> ---
> http-push.c | 2 +-
> 1 files changed, 1 insertions(+), 1 deletions(-)
>
> diff --git a/http-push.c b/http-push.c
> index 4021e7d..d45733e 100644
> --- a/http-push.c
> +++ b/http-push.c
> @@ -530,7 +530,7 @@ static void start_put(struct transfer_re
> request->dest = xmalloc(strlen(request->url) + 14);
> sprintf(request->dest, "Destination: %s", request->url);
> posn += 38;
> - *(posn++) = '.';
> + *(posn++) = '_';
> strcpy(posn, request->lock->token);
>
> slot = get_active_slot();
> --
> 1.4.2.rc2.g7cb1
>
>
> --
> Rutger Nijlunsing ---------------------------------- eludias ed dse.nl
> never attribute to a conspiracy which can be explained by incompetence
> ----------------------------------------------------------------------
^ permalink raw reply
* Re: HOWTO set up a repository which can be pushed into over HTTP
From: Rutger Nijlunsing @ 2006-08-09 19:31 UTC (permalink / raw)
To: Johannes Schindelin; +Cc: git, Junio C Hamano, git
In-Reply-To: <Pine.LNX.4.63.0608090049480.1800@wbgn013.biozentrum.uni-wuerzburg.de>
> > Today I did try to follow it, and it made an otherwise impossible job
> > for me doable, although still taking too much hours and a patch. The
> > 'impossible job' for me had to do with my zero-apache experience and
> > (probably) a bug in WebDAV.
>
> Thank you for doing that valuable work! I think the patch is fine (take
> that as an Acked-by:); next time you might want to send it as a proper
> patch mail ;-)
Ok, I send it out. Don't know if I did it proper...
> > -This text assumes that you
> > -
> > -- have an Apache webserver,
> > -- can edit the configuration of it,
> > -- can restart it, and
> > +
> > +What's needed:
> > +
> > +- Have an Apache webserver
> > +
> > + On Debian:
> > + $ apt-get install apache2
> > + To get apache2 by default started,
> > + edit /etc/default/apache2 and set NO_START=0
> > +
> > +- can edit the configuration of it
> > +
> > + On Debian: this means being able to edit files under /etc/apache2
>
> On some other setups, it is /etc/httpd/. Since it is not specific to
> Debian, we might want to give some common options, but refer the user to
> the Apache manual if she cannot find it.
Ok, but I find it always very convenient when someone describes the
situation for _me_. So if other distro's would join in, I would be
delighted. And indeed a general fallback to the Apache documentation
would be good for all distro's (+ homegrown) not covered.
However, Debian already differs quite some from the defaults. I wrote
this addendum to the documentation _because_ it costed me quite some
time since Debian tries to be different.
Debian seperates as much as possible into different files and
directories to be able to easily install and deinstall modules with
the package manager. And it has scripts to manage those directories.
> > +
> > +- can restart it.
> > + 'apachectl --graceful' might do.
>
> It is Ã'apachectl graceful' here (without'--').
>
> > + On Debian:
> > + $ /etc/init.d/apache2 restart
>
> This should work everywhere, except it might be called apache or httpd
> instead. However, please warn users that this interrupts (however briefly)
> a running webserver, and if you do that on a production machine, users
> just downloading an iso file might be rightfully upset.
If you're on a production machine with a webserver already in
production, you're probably not using this tutorial (I hope).
If you're downloading a large iso, recent browsers have 'resume'
buttons. The internet has never been very reliable.
If you're on Debian, '/etc/init.d/apache2 restart' is the same as
'/etc/init.d/apache2 force-reload', so no interruptions.
...but warning is always good :)
> > + On Debian:
> > +
> > + $ cd /var/www
> > + $ mkdir my-new-repo.git
>
> Again, it might be cooler to be a bit more portable: if the user found
> httpd.config, he could just "grep DocumentRoot /where/ever/httpd.conf".
Nope. On Debian, httpd.conf is a placeholder which does not contain
anything expect for:
# This is here for backwards compatability reasons and to support
# installing 3rd party modules directly via apxs2, rather than
# through the /etc/apache2/mods-{available,enabled} mechanism.
#
#LoadModule mod_placeholder /usr/lib/apache2/modules/mod_placeholder.so
And the grep gives nothing. Doing a recursive grep gives:
/etc/apache2$ grep -r DocumentRoot *
sites-available/default: DocumentRoot /var/www
sites-enabled/000-default: DocumentRoot /var/www
...where sites-enabled is a link to sites-available.
> > Change the ownership to your webserver's credentials
> > +
> > + $ chown -R www.www .
> > +
> > + On Debian:
> > +
> > + $ chown -R www-data.www-data .
>
> Again, a better way would be to direct the user to "grep ^User httpd.conf"
> and "grep ^Group httpd.conf".
Both come up empty on Debian. The uid + gid appear to be in apache2.conf :
/etc/apache2$ grep ^User *
apache2.conf:User www-data
> > + DAVLockDB "/usr/local/apache2/temp/DAV.lock"
> > +
> > + On Debian:
> >
> > - DAVLockDB "/usr/local/apache2/temp/DAV.lock"
> > + Enable the dav and dav_fs modules of apache:
> > + $ a2enmod dav_fs
> > + $ a2enmod dav
> > + The DAV lock is located in /etc/apache2/mods-available/dav_fs.conf:
> > + DAVLockDB /var/lock/apache2/DAVLock
>
> I did not find a2enmod on my only Debian setup, so a more portable way
> would be to tell the user to insert the following lines in httpd.conf:
>
> LoadModule dav_module libexec/httpd/libdav.so
> AddModule mod_dav.c
No, a2enmod is the recommended way to enable modules. It adds symlinks
from the /etc/apache2/mods-enabled to /etc/apache2/mods-available.
I got those from http://www.debian-administration.org/articles/285
> (I do not know if there are setups where you have to load dav_fs
> explicitely...)
According to http://www.debian-administration.org/articles/285, I had
to. Didn't check it myself, though.
> > + On Debian:
> > + Create (or add to) /etc/apache2/conf.d/git.conf :
>
> Is this picked up automatically?
Yup. From /etc/apache2/README:
...
conf.d/
Files in this directory are included by this line in
apache2.conf:
# Include generic snippets of statements
Include /etc/apache2/conf.d
This is a good place to add additional configuration
directives.
httpd.conf
Empty file.
...
> > + <Location /my-new-repo.git>
> > + DAV on
> > + AuthType Basic
> > + AuthName "Git"
> > + AuthUserFile /etc/apache2/passwd.git
> > + Require valid-user
> > + </Location>
>
> We should not violate the DRY principle ("Don´'Repeat Yourself").
Ok, a merge could be done, but AuthUserFile is different.
Something like
+ AuthUserFile <passwd-file>
then.
> > +On Debian:
> > +
> > + To test the WebDAV part, do:
> > +
> > + $ apt-get install litmus
> > + $ litmus http://<servername>/my-new-repo.git <username> <password>
>
> There has to be a more portable way to test WebDAV, like an URL to type
> into a webbrowser. DAV wizards, anyone?
The renaming bug I found by using Windows Internet Explorer -> Open Location ->
http://<servername>/my-new-repo.git [x] Open as webfolder -> login,
and copy a file to it, rename it, ...
Another interactive tool is cadaver (see
http://www.debian-administration.org/articles/285 again).
With FUSE + fusedav you can mount a WebDAV like a normal filesystem
(which is cool ;)
> > -Then, add the following to your .netrc (you can do without, but will be
> > +Then, add the following to your ~/.netrc (you can do without, but will be
>
> Okay, I thought it was common knowledge where this resides. Although I
> would say $HOME/.netrc instead.
Ok.
> > + On Windows, use %HOMEDRIVE%%HOMEPATH%.netrc instead.
>
> Huh? You want to access it with something else than cygwin?
You're right, Cygwin should have $HOME set.
> > +To check whether all is OK, do:
> > +
> > + curl --netrc --location -v http://<username>@<servername>/my-new-repo.git/
> > +
> > +...this should give a directory listing in HTML of /var/www/my-new-repo.git .
>
> Does everybody who has libcurl installed, have curl installed also?
Don't know, but I think most people who have apache2 installed have
better things to worry about :) Might want to add the dependancy
explicitly in the document, yes.
> > - $ git-http-push upload master
> > + $ git push upload master
> > +
> > +This pushes branch 'master' (which is assumed to be the branch you
> > +want to export) to repository called 'upload', which we previously
> > +defined with git-repo-config.
> >
> > -(This assumes that the branch you want to export is called 'master' in your
> > -client setup...)
>
> Your wording is much clearer.
It took me a while to figure out, I (incorrectly) assumed 'upload' was
the name of the remote branch. And git-http-push didn't work at once,
so I got it working with some extra options before I realised it
should be 'git push' instead.
> > request; This can happen when you start Apache, but then disable the
> > network interface. A simple restart of Apache helps.
> >
> > -In other cases, reading /usr/local/apache2/logs/error_log is often helpful.
> > -
> > +Errors like (22/502) are of format (curl error code/http error
> > +code). So (22/404) means something like 'not found' at the server.
>
> I think the error log is more useful than the http error codes.
You deleted those two lines (look at the version I sent), so jut put
them back :)
Do you want to finish it, or should I do a reedit?
Regards,
Rutger.
--
Rutger Nijlunsing ---------------------------------- eludias ed dse.nl
never attribute to a conspiracy which can be explained by incompetence
----------------------------------------------------------------------
^ permalink raw reply
* (Unsolicited hint) straightening out stray "git bisect"
From: Junio C Hamano @ 2006-08-09 19:30 UTC (permalink / raw)
To: git
In-Reply-To: <7vwt9h3e35.fsf@assigned-by-dhcp.cox.net>
Junio C Hamano <junkio@cox.net> writes:
> Junio C Hamano <junkio@cox.net> writes:
>
>> Junio C Hamano <junkio@cox.net> writes:
>>
>>> Jakub Narebski <jnareb@gmail.com> writes:
>>>
>>>> First (noticed by matled) is that for git-diff-tree with single tree
>>>> as an argument it outputs fist commit-id of commit given at input.
>>>> It is not mentioned in documentation and I think totally unnecessary:
>>>>
>>>> 1038:jnareb@roke:~/git> git diff-tree --abbrev origin
>>>> d5dc6a76d49367cddc015e01d2e9aa22e64d7e28
>>>> :040000 040000 44fb36d... 1c26294... M Documentation
>>>
> Turns out that git-diff-tree from 1.0.0 behaves this way. Since
> 7384889 (May 18, 2005), one-tree form of diff-tree showed the
> "header" line that has the commit object name at the top, and
> since 1809266 (Jun 23, 2005) we have exactly one commit object
> name there; before that we used to say "commitA (from commitB)".
BTW, I got curious and run "git bisect" to see when the " (from
commitB)" was dropped. This turned out to be quite an
interesting one. You would start from these:
$ git bisect start
$ git bisect good 7384889 ;# this said "( from commitB)"
$ git bisect bad v1.0.0 ;# we know this did not
and keep building and testing "git-diff-tree", to mark the ones
that do not say "( from commitB)" as bad and the ones that do as
good.
At some point, it crosses the "coolest merge ever" and suggests
c2f6a02 to be checked, which is on the original "gitk" branch.
There is no way to build git-diff-tree in that revision ;-).
At this point, "visualize" helps.
$ git bisect visualize
shows (pardon the ASCII art):
*--bisect/bad git-rev-list: add option to list all objects
* git-rev-parse: re-organize and be more careful
.
* Do a cross-project merge of Paul Mackerras' gitk visualizer
|* Try to assign colors so crossing lines have different colors
|* Account for indentation of the checkin commments by git-rev-list
|.
|*-bisect Show heads as well as tags
|.
|* Add initial version of gitk to the CVS repository
o--bisect/good-fae22ac [PATCH] git-apply: tests for --stat and --summary.
Now, we know that gitk did not have diff-tree, so up to the
commit "Try to assign colors..." are irrelevant to the "bug" we
are hunting. We say:
$ git bisect good 6c20ff3
(where 6c20ff3 is the commit "Try to assign colors...") to mark
everything leading to that commit (ones on the line on the right
hand side in the above ASCII graph) are good. After that bisect
continues normally.
^ permalink raw reply
* Re: [PATCH and RFC] gitweb: Remove --full-history from git_history
From: Fredrik Kuivinen @ 2006-08-09 19:28 UTC (permalink / raw)
To: Jakub Narebski; +Cc: git
In-Reply-To: <200608091257.19461.jnareb@gmail.com>
On Wed, Aug 09, 2006 at 12:57:19PM +0200, Jakub Narebski wrote:
> This is call for better rename support in git (better than --full-history).
> There was such an attempt in "[RFC, PATCH] Teach revision.c about renames"
> by Fredrik Kuivinen
> http://marc.theaimsgroup.com/?l=git&m=114772921317920
> but IIRC patch was dropped in the favor of --full-history option.
I don't think it was dropped in favor --full-history. Anyway, I did
some more work on that patch back then. Compared to the one posted in
the mail referenced above a couple of bugs have been fixed and a few
tests have been added. If anyone wants to play with it see the patch
in the end of this mail. It is on top of
ed90cbf5f681c0144909457be3f4792b47604a5b, so it's quite old and will
most probably not apply cleanly on the current master branch. I just
noticed that it makes t/t6003-rev-list-topo-order.sh fail too.
> What is needed by gitweb is for git-rev-list to not only follow revisions
> of file contents across renames, and return more revisions,
Note that it is not enough to only return more revisions.
For example, consider the commits (newest commit first)
A: Rename "bar" to "foo"
B: No changes to "bar"
C: No changes to "bar", delete "foo"
<more commits here>
Then you want "git-rev-list --renames A -- foo" to return A,... not A,C,...
> but also
> return _how_ filename changes, without need to call git-diff-tree on each
> returned revision.
This is currently not done by the patch. Should be straight forward to
add though.
- Fredrik
---
Documentation/git-rev-list.txt | 6
Makefile | 2
log-tree.c | 9
revision.c | 636 ++++++++++++++++++++++++++++++++++++++++-
revision.h | 38 ++
t/t6004-rev-list-rename.sh | 100 ++++++
6 files changed, 780 insertions(+), 11 deletions(-)
diff --git a/Documentation/git-rev-list.txt b/Documentation/git-rev-list.txt
index ad6d14c..f7ecf8e 100644
--- a/Documentation/git-rev-list.txt
+++ b/Documentation/git-rev-list.txt
@@ -103,6 +103,12 @@ OPTIONS
topological order (i.e. descendant commits are shown
before their parents).
+--renames::
+ When optional paths are given together with '--renames' the
+ paths are tracked, and any renames detected by Git are
+ followed. This is useful for tracking the history of files
+ across renames.
+
Author
------
Written by Linus Torvalds <torvalds@osdl.org>
diff --git a/Makefile b/Makefile
index dbf19c6..4212a05 100644
--- a/Makefile
+++ b/Makefile
@@ -85,7 +85,7 @@ uname_P := $(shell sh -c 'uname -p 2>/de
# CFLAGS and LDFLAGS are for the users to override from the command line.
-CFLAGS = -g -O2 -Wall
+CFLAGS = -g3 -O0 -Wall
LDFLAGS =
ALL_CFLAGS = $(CFLAGS)
ALL_LDFLAGS = $(LDFLAGS)
diff --git a/log-tree.c b/log-tree.c
index 58b0163..e53dd19 100644
--- a/log-tree.c
+++ b/log-tree.c
@@ -133,11 +133,12 @@ int log_tree_diff_flush(struct rev_info
}
static int diff_root_tree(struct rev_info *opt,
- const unsigned char *new, const char *base)
+ struct commit* commit, const char *base)
{
int retval;
void *tree;
struct tree_desc empty, real;
+ const unsigned char* new = commit->object.sha1;
tree = read_object_with_reference(new, tree_type, &real.size, NULL);
if (!tree)
@@ -146,9 +147,11 @@ static int diff_root_tree(struct rev_inf
empty.buf = "";
empty.size = 0;
+ rev_setup_diffopt_paths(opt, commit, NULL);
retval = diff_tree(&empty, &real, base, &opt->diffopt);
free(tree);
log_tree_diff_flush(opt);
+ rev_free_diffopt_paths(opt, commit);
return retval;
}
@@ -178,7 +181,7 @@ static int log_tree_diff(struct rev_info
parents = commit->parents;
if (!parents) {
if (opt->show_root_diff)
- diff_root_tree(opt, sha1, "");
+ diff_root_tree(opt, commit, "");
return !opt->loginfo;
}
@@ -197,8 +200,10 @@ static int log_tree_diff(struct rev_info
for (;;) {
struct commit *parent = parents->item;
+ rev_setup_diffopt_paths(opt, commit, parent);
diff_tree_sha1(parent->object.sha1, sha1, "", &opt->diffopt);
log_tree_diff_flush(opt);
+ rev_free_diffopt_paths(opt, commit);
showed_log |= !opt->loginfo;
diff --git a/revision.c b/revision.c
index 2294b16..6d31e2d 100644
--- a/revision.c
+++ b/revision.c
@@ -1,12 +1,17 @@
+#include <assert.h>
+
#include "cache.h"
#include "tag.h"
#include "blob.h"
#include "tree.h"
#include "commit.h"
#include "diff.h"
+#include "diffcore.h"
#include "refs.h"
#include "revision.h"
+#define DEBUG 0
+
static char *path_name(struct name_path *path, const char *name)
{
struct name_path *p;
@@ -398,28 +403,67 @@ static void add_parents_to_list(struct r
}
}
+static struct commit_list* remove_duplicates(struct commit_list* list)
+{
+ struct commit_list* res = list, *end;
+
+ if (!list)
+ return NULL;
+
+ if (DEBUG) {
+ printf("removing duplicates... list:\n");
+ commit_list_print(list);
+ printf("end of list\n");
+ }
+
+ res->item->object.flags |= DUPLICATE;
+ end = res;
+ for(list = list->next; list; list = list->next) {
+ if (!(list->item->object.flags & DUPLICATE)) {
+ end->next = list;
+ end = list;
+ list->item->object.flags |= DUPLICATE;
+ } else if(DEBUG)
+ printf("removing duplicate: %s\n", sha1_to_hex(list->item->object.sha1));
+ }
+ end->next = NULL;
+
+ if (DEBUG){
+ printf("new list:\n");
+ commit_list_print(res);
+ printf("end of list\n");
+ }
+
+ return res;
+}
+
static void limit_list(struct rev_info *revs)
{
struct commit_list *list = revs->commits;
struct commit_list *newlist = NULL;
struct commit_list **p = &newlist;
- while (list) {
- struct commit_list *entry = list;
- struct commit *commit = list->item;
+ /* We have to be a bit careful here because objects may be
+ * added to revs->commits by functions called by
+ * add_parents_to_list and we want to process all those
+ * objects, in addition to the objects which are in the list
+ * in the beginning. */
+ while (revs->commits) {
+ struct commit_list *entry = revs->commits;
+ struct commit *commit = revs->commits->item;
struct object *obj = &commit->object;
- list = list->next;
+ revs->commits = revs->commits->next;
free(entry);
if (revs->max_age != -1 && (commit->date < revs->max_age))
obj->flags |= UNINTERESTING;
if (revs->unpacked && has_sha1_pack(obj->sha1))
obj->flags |= UNINTERESTING;
- add_parents_to_list(revs, commit, &list);
+ add_parents_to_list(revs, commit, &revs->commits);
if (obj->flags & UNINTERESTING) {
mark_parents_uninteresting(commit);
- if (everybody_uninteresting(list))
+ if (everybody_uninteresting(revs->commits))
break;
continue;
}
@@ -457,6 +501,8 @@ static void limit_list(struct rev_info *
commit->object.flags &= ~TMP_MARK;
}
}
+ if (revs->follow_renames)
+ newlist = remove_duplicates(newlist);
revs->commits = newlist;
}
@@ -507,6 +553,512 @@ static int add_parents_only(struct rev_i
return 1;
}
+/* Rename following code */
+struct mem_pool
+{
+ /* This is slightly ugly. We don't really store paths in this
+ * list, we store pointers to our memory blocks. */
+ struct path_list* list;
+
+ int block_size, len;
+};
+
+static void* mem_pool_alloc(struct mem_pool* pool, size_t size)
+{
+ assert(size < pool->block_size);
+ if (pool->list && pool->block_size - pool->len > size) {
+ int old_len = pool->len;
+ pool->len += size;
+ return pool->list->item + old_len;
+ } else {
+ if (DEBUG)
+ printf("allocating new block\n");
+ path_list_insert(xmalloc(pool->block_size), &pool->list);
+ pool->len = size;
+ return pool->list->item;
+ }
+}
+
+static void mem_pool_free(struct mem_pool* pool)
+{
+ struct path_list* next;
+ for (; pool->list; pool->list = next) {
+ free(pool->list->item);
+ next = pool->list->next;
+ free(pool->list);
+ }
+}
+
+static void mem_pool_init(struct mem_pool* pool, int block_size)
+{
+ pool->list = NULL;
+ pool->len = 0;
+ pool->block_size = block_size;
+}
+
+const struct path_list* path_list_find(const struct path_list* list,
+ const char* path)
+{
+ for(; list; list = list->next) {
+ if (!strcmp(path, list->item))
+ return list;
+ }
+
+ return NULL;
+}
+
+struct path_list* path_list_insert(char *item, struct path_list **list_p)
+{
+ struct path_list *new_list = xmalloc(sizeof(struct path_list));
+ new_list->item = item;
+ new_list->next = *list_p;
+ *list_p = new_list;
+ return new_list;
+}
+
+/* Return non-zero if l1 is a (not necessarily proper) subset of l2
+ * and zero otherwise.
+ *
+ * Yes, this is slow. */
+int path_list_issubseteq(struct path_list* l1, struct path_list* l2)
+{
+ for (; l1; l1 = l1->next) {
+ if (!path_list_find(l2, l1->item))
+ return 0;
+ }
+
+ return 1;
+}
+
+struct path_list* path_list_insert_pool(char *item, struct path_list **list_p,
+ struct mem_pool* pool)
+{
+ struct path_list *new_list =
+ mem_pool_alloc(pool, sizeof(struct path_list));
+ new_list->item = item;
+ new_list->next = *list_p;
+ *list_p = new_list;
+ return new_list;
+}
+
+
+struct path_list* path_list_union_pool(struct path_list* l1,
+ struct path_list* l2,
+ struct mem_pool* pool)
+{
+ struct path_list* res;
+ for (; l1; l1 = l1->next)
+ path_list_insert_pool(l1->item, &res, pool);
+ for (; l2; l2 = l2->next)
+ path_list_insert_pool(l2->item, &res, pool);
+ return res;
+}
+
+void path_list_print(FILE* file, struct path_list* list)
+{
+ for(; list; list = list->next)
+ fprintf(file, "%s ", list->item);
+ fputc('\n', file);
+}
+
+void path_list_free(struct path_list *list)
+{
+ while (list) {
+ struct path_list *temp = list;
+ list = temp->next;
+ free(temp);
+ }
+}
+
+const char** convert_to_pathspec(struct path_list* l1, struct path_list* l2)
+{
+ struct path_list* l;
+ const char** ret;
+ int i, len = 0;
+
+ for(l = l1; l; l = l->next, len++)
+ ;
+ for(l = l2; l; l = l->next, len++)
+ ;
+
+ ret = xmalloc((len+1)*sizeof(char*));
+ for(i = 0; l1; l1 = l1->next, i++)
+ ret[i] = l1->item;
+ for(; l2; l2 = l2->next, i++)
+ ret[i] = l2->item;
+
+ ret[len] = NULL;
+ return ret;
+}
+
+static int file_exists_helper(unsigned char *sha1, const char *base,
+ int baselen, const char *pathname,
+ unsigned mode, int stage);
+
+static int file_found;
+static const char* file_to_find;
+static int file_exists(struct tree *t, const char *pathname)
+{
+ const char *pathspec[2];
+
+ file_to_find = pathname;
+ pathspec[0] = pathname;
+ pathspec[1] = NULL;
+ file_found = 0;
+ read_tree_recursive(t, "", 0, 0, pathspec, file_exists_helper);
+
+ return file_found;
+}
+
+static int file_exists_helper(unsigned char *sha1, const char *base,
+ int baselen, const char *pathname,
+ unsigned mode, int stage)
+{
+ if (S_ISDIR(mode))
+ return READ_TREE_RECURSIVE;
+
+ if (strncmp(file_to_find, base, baselen) ||
+ strcmp(file_to_find + baselen, pathname))
+ return -1;
+
+ file_found = 1;
+ return -1;
+}
+
+static struct rev_commit_info* get_util(struct commit *commit)
+{
+ struct rev_commit_info *util = commit->object.util;
+
+ if (util)
+ return util;
+
+ util = xcalloc(1, sizeof(struct rev_commit_info));
+ commit->object.util = util;
+ return util;
+}
+
+void rev_setup_diffopt_paths(struct rev_info* revs,
+ struct commit* commit,
+ struct commit* parent)
+{
+ const char** pathspec;
+
+ if (!revs->follow_renames)
+ return;
+
+ pathspec = convert_to_pathspec(get_util(commit)->paths,
+ parent ? get_util(parent)->paths : NULL);
+
+ diff_tree_setup_paths(pathspec, &revs->diffopt);
+}
+
+void rev_free_diffopt_paths(struct rev_info* revs, struct commit* commit)
+{
+ if (!revs->follow_renames)
+ return;
+
+ free(revs->diffopt.paths);
+ diff_tree_release_paths(&revs->diffopt);
+}
+
+
+static void topo_setter(struct commit* c, void* data)
+{
+ struct rev_commit_info* util = c->object.util;
+ util->topo_data = data;
+}
+
+static void* topo_getter(struct commit* c)
+{
+ struct rev_commit_info* util = c->object.util;
+ return util->topo_data;
+}
+
+static int same_tree_as_empty_paths(struct rev_info *revs, struct tree* t1,
+ struct path_list* paths)
+{
+ int ret;
+
+ if (!paths)
+ return 1;
+
+ const char** pathspec = convert_to_pathspec(paths, NULL);
+ diff_tree_setup_paths(pathspec, &revs->pruning);
+ ret = rev_same_tree_as_empty(revs, t1);
+ diff_tree_release_paths(&revs->pruning);
+ free(pathspec);
+ return ret;
+}
+
+
+static struct path_list* file_removals;
+static struct mem_pool *current_string_pool, *current_list_pool;
+static void file_add_remove_ren(struct diff_options *options,
+ int addremove, unsigned mode,
+ const unsigned char *sha1,
+ const char *base, const char *path)
+{
+ if (DEBUG)
+ printf("%c base: '%s' path: '%s'\n", addremove, base, path);
+
+ if (addremove == '-') {
+ char* p = mem_pool_alloc(current_string_pool,
+ strlen(base) + strlen(path) + 1);
+ strcpy(p, base);
+ strcat(p, path);
+ path_list_insert_pool(p, &file_removals, current_list_pool);
+ tree_difference = REV_TREE_NEW;
+ } else {
+ ; //assert(0);
+ }
+}
+
+static void file_change_ren(struct diff_options *options,
+ unsigned old_mode, unsigned new_mode,
+ const unsigned char *old_sha1,
+ const unsigned char *new_sha1,
+ const char *base, const char *path)
+{
+ if (tree_difference == REV_TREE_SAME)
+ tree_difference = REV_TREE_DIFFERENT;
+}
+
+static int compare_tree_paths(struct rev_info* revs,
+ struct commit* parent, struct commit* commit,
+ struct path_list** added)
+{
+ const char** pathspec;
+ struct diff_options dopts;
+ struct path_list* paths = get_util(commit)->paths;
+
+ if (!paths) {
+ *added = NULL;
+ return REV_TREE_SAME;
+ }
+
+ diff_setup(&dopts);
+ dopts.recursive = 1;
+ dopts.add_remove = file_add_remove_ren;
+ dopts.change = file_change_ren;
+ dopts.output_format = DIFF_FORMAT_NO_OUTPUT;
+
+ pathspec = convert_to_pathspec(paths, NULL);
+ diff_tree_setup_paths(pathspec, &dopts);
+
+ if (diff_setup_done(&dopts) < 0)
+ die("diff_setup_done failed");
+
+ file_removals = NULL;
+ tree_difference = REV_TREE_SAME;
+ current_string_pool = revs->string_pool;
+ current_list_pool = revs->list_pool;
+ diff_tree_sha1(commit->tree->object.sha1, parent->tree->object.sha1,
+ "", &dopts);
+
+ diff_flush(&dopts);
+ diff_tree_release_paths(&dopts);
+ free(pathspec);
+
+ *added = file_removals;
+ return tree_difference;
+}
+
+static struct path_list* find_renames(struct rev_info* revs,
+ struct commit* commit,
+ struct commit* parent,
+ struct path_list* paths)
+{
+ int i;
+ struct diff_options dopts;
+ struct path_list* ret = NULL;
+
+ if (DEBUG) {
+ printf("find_renames commit: %s ",
+ sha1_to_hex(commit->object.sha1));
+ puts(sha1_to_hex(parent->object.sha1));
+ printf("rename from paths: ");
+ path_list_print(stdout, paths);
+ }
+
+ diff_setup(&dopts);
+ dopts.recursive = 1;
+ dopts.detect_rename = DIFF_DETECT_RENAME;
+ dopts.output_format = DIFF_FORMAT_NO_OUTPUT;
+
+ if (diff_setup_done(&dopts) < 0)
+ die("diff_setup_done failed");
+
+ diff_tree_sha1(commit->tree->object.sha1, parent->tree->object.sha1,
+ "", &dopts);
+ diffcore_std(&dopts);
+
+ for (i = 0; i < diff_queued_diff.nr; i++) {
+ struct diff_filepair *p = diff_queued_diff.queue[i];
+
+ if (0 && p->status == 'R' && DEBUG)
+ printf("rename %s -> %s\n", p->one->path, p->two->path);
+
+ if (p->status == 'R' && path_list_find(paths, p->one->path)) {
+ char *str = mem_pool_alloc(revs->string_pool,
+ strlen(p->two->path)+1);
+ strcpy(str, p->two->path);
+ path_list_insert_pool(str, &ret, revs->list_pool);
+
+ if (DEBUG) {
+ printf("rename %s -> %s\n",
+ p->one->path, p->two->path);
+ }
+ }
+ }
+ diff_flush(&dopts);
+
+ if (DEBUG) {
+ printf("rename result: ");
+ path_list_print(stdout, ret);
+ }
+ return ret;
+}
+
+static struct path_list* rewrite_paths(struct rev_info *revs,
+ struct commit* commit,
+ struct commit* parent,
+ struct path_list* removed)
+{
+ struct path_list* new_paths = find_renames(revs, commit, parent,
+ removed);
+ struct path_list* cpaths = get_util(commit)->paths;
+ for(; cpaths; cpaths = cpaths->next) {
+ if (!path_list_find(removed, cpaths->item))
+ path_list_insert(cpaths->item, &new_paths);
+ }
+ return new_paths;
+}
+
+static void reinsert_commit(struct rev_info* revs, struct commit* commit)
+{
+ /* Reparse the commit. We want the original parent list again
+ * as the set of files we are following has grown. */
+
+ free_commit_list(commit->parents);
+ /* We need the following, otherwise parse_commit wont do the
+ * right thing with the parents list. */
+ commit->parents = NULL;
+
+ commit->object.parsed = 0;
+ parse_commit(commit);
+
+ commit->object.flags &= ~ADDED;
+ commit_list_insert(commit, &revs->commits);
+ if (DEBUG)
+ printf("reinsert commit %s\n",
+ sha1_to_hex(commit->object.sha1));
+}
+
+static void simplify_commit_rename(struct rev_info *revs,
+ struct commit *commit)
+{
+ struct commit_list **pp, *parent;
+ struct rev_commit_info* cutil = get_util(commit);
+ int tree_changed = 0;
+
+ if (!commit->tree)
+ return;
+
+ if (!commit->parents) {
+ if (!same_tree_as_empty_paths(revs, commit->tree,
+ cutil->paths))
+ commit->object.flags |= TREECHANGE;
+ return;
+ }
+
+ pp = &commit->parents;
+ while ((parent = *pp) != NULL) {
+ struct commit *p = parent->item;
+ struct path_list* removed;
+ struct rev_commit_info* putil = get_util(p);
+
+ parse_commit(p);
+ switch (compare_tree_paths(revs, p, commit, &removed)) {
+ case REV_TREE_SAME:
+ {
+ int do_return = 1;
+ if (!putil->paths)
+ putil->paths = cutil->paths;
+ else if (!path_list_issubseteq(cutil->paths,
+ putil->paths)) {
+ putil->paths =
+ path_list_union_pool(cutil->paths,
+ putil->paths,
+ revs->list_pool);
+ reinsert_commit(revs, p);
+ tree_changed = 1;
+ do_return = 0;
+ }
+ if (p->object.flags & UNINTERESTING) {
+ /* Even if a merge with an uninteresting
+ * side branch brought the entire change
+ * we are interested in, we do not want
+ * to lose the other branches of this
+ * merge, so we just keep going.
+ */
+ pp = &parent->next;
+ continue;
+ }
+ if (do_return) {
+ parent->next = NULL;
+ commit->parents = parent;
+ return;
+ } else {
+ continue;
+ }
+ }
+
+ case REV_TREE_NEW:
+ {
+ struct path_list* new_paths =
+ rewrite_paths(revs, commit, p, removed);
+ if (new_paths) {
+ if (!putil->paths)
+ putil->paths = new_paths;
+ else if (!path_list_issubseteq(new_paths,
+ putil->paths)) {
+ putil->paths =
+ path_list_union_pool(new_paths,
+ putil->paths,
+ revs->list_pool);
+ reinsert_commit(revs, p);
+ }
+ } else {
+ parse_commit(p);
+ p->parents = NULL;
+ }
+ tree_changed = 1;
+ pp = &parent->next;
+ continue;
+ }
+
+ case REV_TREE_DIFFERENT:
+ tree_changed = 1;
+ pp = &parent->next;
+ if (!putil->paths)
+ putil->paths = cutil->paths;
+ else if (!path_list_issubseteq(cutil->paths,
+ putil->paths)) {
+ putil->paths =
+ path_list_union_pool(cutil->paths,
+ putil->paths,
+ revs->list_pool);
+ reinsert_commit(revs, p);
+ }
+ continue;
+ }
+ die("bad tree compare for commit %s",
+ sha1_to_hex(commit->object.sha1));
+ }
+ if (tree_changed)
+ commit->object.flags |= TREECHANGE;
+}
+
void init_revisions(struct rev_info *revs)
{
memset(revs, 0, sizeof(*revs));
@@ -742,6 +1294,11 @@ int setup_revisions(int argc, const char
revs->full_diff = 1;
continue;
}
+ if (!strcmp(arg, "--renames")) {
+ revs->follow_renames = 1;
+ continue;
+ }
+
opts = diff_opt_parse(&revs->diffopt, argv+i, argc-i);
if (opts > 0) {
revs->diff = 1;
@@ -841,15 +1398,65 @@ int setup_revisions(int argc, const char
(revs->diffopt.output_format != DIFF_FORMAT_DIFFSTAT))
revs->diffopt.output_format = DIFF_FORMAT_PATCH;
}
+ if (revs->follow_renames && revs->prune_data) {
+ char** p;
+ if (revs->remove_empty_trees)
+ die("--renames and --remove-empty are currently "
+ "mutually exclusive");
+ revs->prune_fn = simplify_commit_rename;
+ revs->topo_setter = topo_setter;
+ revs->topo_getter = topo_getter;
+ revs->limited = 1;
+ revs->string_pool = xmalloc(sizeof(struct mem_pool));
+ revs->list_pool = xmalloc(sizeof(struct mem_pool));
+ mem_pool_init(revs->string_pool, 1024*4);
+ mem_pool_init(revs->list_pool, 1024*4);
+
+ revs->initial_paths = NULL;
+ for(p = revs->prune_data; *p; p++) {
+ char* str = mem_pool_alloc(revs->string_pool,
+ strlen(*p)+1);
+ strcpy(str, *p);
+ path_list_insert(str, &revs->initial_paths);
+ if (DEBUG)
+ printf("filename: %s\n", *p);
+ }
+
+ if (DEBUG)
+ printf("prefix: %s\n", revs->prefix);
+ }
+
revs->diffopt.abbrev = revs->abbrev;
diff_setup_done(&revs->diffopt);
return left;
}
+void free_revisions(struct rev_info *revs)
+{
+ if (revs->follow_renames) {
+ mem_pool_free(revs->string_pool);
+ mem_pool_free(revs->list_pool);
+
+ free(revs->string_pool);
+ free(revs->list_pool);
+ }
+}
+
+static void insert_by_date_commits(struct rev_info* revs,
+ struct commit* commit)
+{
+ insert_by_date(commit, &revs->commits);
+ if (!revs->last_commit)
+ revs->last_commit = revs->commits;
+ else if (revs->last_commit->next)
+ revs->last_commit = revs->last_commit->next;
+}
+
void prepare_revision_walk(struct rev_info *revs)
{
struct object_list *list;
+ struct commit_list *clist;
list = revs->pending_objects;
revs->pending_objects = NULL;
@@ -858,12 +1465,27 @@ void prepare_revision_walk(struct rev_in
if (commit) {
if (!(commit->object.flags & SEEN)) {
commit->object.flags |= SEEN;
- insert_by_date(commit, &revs->commits);
+ insert_by_date_commits(revs, commit);
}
}
list = list->next;
}
+ for (clist = revs->commits; clist; clist = clist->next) {
+ struct commit *commit = clist->item;
+ struct rev_commit_info *util = get_util(commit);
+ if (!util->paths) {
+ struct path_list* l;
+ for (l = revs->initial_paths; l; l = l->next) {
+ if (file_exists(commit->tree, l->item)) {
+ path_list_insert(l->item, &util->paths);
+ }
+ }
+ if (DEBUG)
+ printf("NULL paths\n");
+ }
+ }
+
if (revs->no_walk)
return;
if (revs->limited)
diff --git a/revision.h b/revision.h
index bdbdd23..a2d9666 100644
--- a/revision.h
+++ b/revision.h
@@ -9,15 +9,19 @@ #define TMP_MARK (1u<<4) /* for isolated
#define BOUNDARY (1u<<5)
#define BOUNDARY_SHOW (1u<<6)
#define ADDED (1u<<7) /* Parents already parsed and added? */
+#define DUPLICATE (1u<<8)
struct rev_info;
struct log_info;
+struct path_list;
typedef void (prune_fn_t)(struct rev_info *revs, struct commit *commit);
struct rev_info {
/* Starting list */
struct commit_list *commits;
+ /* the last entry in the 'commits' list */
+ struct commit_list *last_commit;
struct object_list *pending_objects;
/* Basic information */
@@ -39,7 +43,8 @@ struct rev_info {
limited:1,
unpacked:1,
boundary:1,
- parents:1;
+ parents:1,
+ follow_renames:1;
/* Diff flags */
unsigned int diff:1,
@@ -70,6 +75,11 @@ struct rev_info {
struct diff_options diffopt;
struct diff_options pruning;
+ /* Rename following */
+ struct path_list* initial_paths;
+ struct mem_pool* string_pool;
+ struct mem_pool* list_pool;
+
topo_sort_set_fn_t topo_setter;
topo_sort_get_fn_t topo_getter;
};
@@ -84,6 +94,7 @@ extern int rev_compare_tree(struct rev_i
extern void init_revisions(struct rev_info *revs);
extern int setup_revisions(int argc, const char **argv, struct rev_info *revs, const char *def);
+extern void free_revisions(struct rev_info *revs);
extern void prepare_revision_walk(struct rev_info *revs);
extern struct commit *get_revision(struct rev_info *revs);
@@ -101,4 +112,29 @@ extern struct object_list **add_object(s
struct name_path *path,
const char *name);
+struct path_list {
+ char* item;
+ struct path_list *next;
+};
+
+struct rev_commit_info {
+ struct path_list* paths;
+ void* topo_data;
+};
+
+extern const struct path_list* path_list_find(const struct path_list* list,
+ const char* path);
+extern struct path_list* path_list_insert(char *item,
+ struct path_list **list_p);
+extern void path_list_print(FILE*, struct path_list* list);
+extern void free_path_list(struct path_list *list);
+extern const char** convert_to_pathspec(struct path_list* l1,
+ struct path_list* l2);
+
+extern void rev_setup_diffopt_paths(struct rev_info* revs,
+ struct commit* commit,
+ struct commit* parent);
+extern void rev_free_diffopt_paths(struct rev_info* revs,
+ struct commit* commit);
+
#endif
diff --git a/t/t6004-rev-list-rename.sh b/t/t6004-rev-list-rename.sh
new file mode 100755
index 0000000..e2d37d1
--- /dev/null
+++ b/t/t6004-rev-list-rename.sh
@@ -0,0 +1,100 @@
+#!/bin/sh
+#
+# Copyright (c) 2006 Fredrik Kuivinen
+# Bases on t6003-rev-list-topo-order.sh
+
+test_description='Tests git-rev-list --renames functionality'
+
+. ./test-lib.sh
+. ../t6000lib.sh # t6xxx specific functions
+
+list_duplicates()
+{
+ "$@" | sort | uniq -d
+}
+
+unique_commit_wd()
+{
+ _text=$1
+ _tree=`git-write-tree`
+ shift 1
+ echo $_text | git-commit-tree $_tree "$@"
+}
+
+cp ../../COPYING .
+cp ../../README .
+git-update-index --add COPYING README
+hide_error save_tag root unique_commit_wd root
+
+echo '1' >> COPYING
+git-update-index COPYING
+save_tag l0 unique_commit_wd l0 -p root
+
+echo '1' >> README
+git-update-index COPYING README
+save_tag l1 unique_commit_wd l1 -p l0
+
+echo '2' >> COPYING
+echo '2' >> README
+git-update-index COPYING README
+save_tag l2 unique_commit_wd l2 -p l1
+
+git mv README README-ren
+save_tag l3 unique_commit_wd l3 -p l2
+
+git mv README-ren README-ren2
+save_tag a0 unique_commit_wd a0 -p l3
+
+git mv README-ren2 README-ren
+git mv COPYING COPYING-ren
+
+save_tag b0 unique_commit_wd b0 -p l3
+git mv README-ren README-ren2
+
+save_tag m unique_commit_wd m -p a0 -p b0
+git mv README-ren2 README-ren3
+echo '3' >> COPYING-ren
+git-update-index COPYING-ren
+save_tag head unique_commit_wd head -p m
+
+test_output_expect_success "--renames head -- README-ren3" "git-rev-list --topo-order --renames head -- README-ren3" <<EOF
+head
+a0
+l3
+l2
+l1
+root
+EOF
+
+test_output_expect_success "--renames head a0 -- COPYING" "git-rev-list --topo-order --renames head a0 -- COPYING" <<EOF
+l2
+l0
+root
+EOF
+
+test_output_expect_success "--renames head -- README-ren3 COPYING-ren" "git-rev-list --topo-order --renames head -- README-ren3 COPYING-ren" <<EOF
+head
+m
+b0
+a0
+l3
+l2
+l1
+l0
+root
+EOF
+
+test_output_expect_success "--renames --all -- README-ren3 COPYING" "git-rev-list --topo-order --renames --all -- README-ren3 COPYING" <<EOF
+head
+a0
+l3
+l2
+l1
+l0
+root
+EOF
+
+test_output_expect_success "--renames head -- COPYING README" "git-rev-list --renames head -- COPYING README" <<EOF
+EOF
+
+test_done
^ permalink raw reply related
* Re: Strange output of git-diff-tree
From: Junio C Hamano @ 2006-08-09 19:26 UTC (permalink / raw)
To: Jakub Narebski; +Cc: git
In-Reply-To: <7vbqqt4vct.fsf@assigned-by-dhcp.cox.net>
Junio C Hamano <junkio@cox.net> writes:
> Junio C Hamano <junkio@cox.net> writes:
>
>> Jakub Narebski <jnareb@gmail.com> writes:
>>
>>> First (noticed by matled) is that for git-diff-tree with single tree
>>> as an argument it outputs fist commit-id of commit given at input.
>>> It is not mentioned in documentation and I think totally unnecessary:
>>>
>>> 1038:jnareb@roke:~/git> git diff-tree --abbrev origin
>>> d5dc6a76d49367cddc015e01d2e9aa22e64d7e28
>>> :040000 040000 44fb36d... 1c26294... M Documentation
>>
>> Working as specified as in the original version. See
>> core-tutorial and look for "git-diff-tree -p HEAD".
>
> My mistake -- if you are talking about the first line that shows
> the commit object name, I am not sure if this was from the
> beginning or a recent slip-up. Will need to look into it.
>
> I thought you were talking about 1-argument diff-tree, sorry.
Turns out that git-diff-tree from 1.0.0 behaves this way. Since
7384889 (May 18, 2005), one-tree form of diff-tree showed the
"header" line that has the commit object name at the top, and
since 1809266 (Jun 23, 2005) we have exactly one commit object
name there; before that we used to say "commitA (from commitB)".
I agree that showing the single argument that is given on the
command line as the first output line might seem redundant, but
it has been done this way for a long time (eternity in git
timescale), so let's not risk breaking people's scripts by
changing it.
^ permalink raw reply
* [PATCH] http-push: Make WebDAV work with (broken?) default apache2 WebDAV module
From: Rutger Nijlunsing @ 2006-08-09 18:54 UTC (permalink / raw)
To: git
WebDAV on Debian unstable cannot handle renames on WebDAV from
file.ext to newfile (without ext) when newfile* already
exists. Normally, git creates a file like 'objects/xx/sha1.token',
which is renamed to 'objects/xx/sha1' when transferred completely.
Just use '_' instead of '.' so WebDAV doesn't see it as an extension
change.
Signed-off-by: Rutger Nijlunsing <git@tux.tmfweb.nl>
Acked-by: Johannes Schindelin <Johannes.Schindelin@gmx.de>
---
http-push.c | 2 +-
1 files changed, 1 insertions(+), 1 deletions(-)
diff --git a/http-push.c b/http-push.c
index 4021e7d..d45733e 100644
--- a/http-push.c
+++ b/http-push.c
@@ -530,7 +530,7 @@ static void start_put(struct transfer_re
request->dest = xmalloc(strlen(request->url) + 14);
sprintf(request->dest, "Destination: %s", request->url);
posn += 38;
- *(posn++) = '.';
+ *(posn++) = '_';
strcpy(posn, request->lock->token);
slot = get_active_slot();
--
1.4.2.rc2.g7cb1
--
Rutger Nijlunsing ---------------------------------- eludias ed dse.nl
never attribute to a conspiracy which can be explained by incompetence
----------------------------------------------------------------------
^ permalink raw reply related
* Re: Strange output of git-diff-tree
From: Junio C Hamano @ 2006-08-09 18:28 UTC (permalink / raw)
To: Jakub Narebski; +Cc: git
In-Reply-To: <7vfyg54vjb.fsf@assigned-by-dhcp.cox.net>
Junio C Hamano <junkio@cox.net> writes:
> Jakub Narebski <jnareb@gmail.com> writes:
>
>> First (noticed by matled) is that for git-diff-tree with single tree
>> as an argument it outputs fist commit-id of commit given at input.
>> It is not mentioned in documentation and I think totally unnecessary:
>>
>> 1038:jnareb@roke:~/git> git diff-tree --abbrev origin
>> d5dc6a76d49367cddc015e01d2e9aa22e64d7e28
>> :040000 040000 44fb36d... 1c26294... M Documentation
>
> Working as specified as in the original version. See
> core-tutorial and look for "git-diff-tree -p HEAD".
My mistake -- if you are talking about the first line that shows
the commit object name, I am not sure if this was from the
beginning or a recent slip-up. Will need to look into it.
I thought you were talking about 1-argument diff-tree, sorry.
^ permalink raw reply
* Re: Strange output of git-diff-tree
From: Junio C Hamano @ 2006-08-09 18:24 UTC (permalink / raw)
To: Jakub Narebski; +Cc: git
In-Reply-To: <ebcnml$btf$1@sea.gmane.org>
Jakub Narebski <jnareb@gmail.com> writes:
> First (noticed by matled) is that for git-diff-tree with single tree
> as an argument it outputs fist commit-id of commit given at input.
> It is not mentioned in documentation and I think totally unnecessary:
>
> 1038:jnareb@roke:~/git> git diff-tree --abbrev origin
> d5dc6a76d49367cddc015e01d2e9aa22e64d7e28
> :040000 040000 44fb36d... 1c26294... M Documentation
Working as specified as in the original version. See
core-tutorial and look for "git-diff-tree -p HEAD".
> Second, for some combination of options for it returns "..." instead of
> 0{40} for file creation.
Well spotted. The minimum reproduction recipe is:
$ git diff-tree --find-copies-harder 2ad9331
Will look into it.
> Third, while it detects that gitweb/gitweb.perl was renamed from
> gitweb/gitweb.cgi:
> [...] R100 gitweb/gitweb.cgi gitweb/gitweb.perl
> it does not notice that gitweb/gitweb.cgi was gitweb.cgi in
> 1130ef362fc8d9c3422c23f5d5a833e93d3f5c13.
Depends on how you ask.
git diff-tree --abbrev --pretty -m -M -r --diff-filter=R 0a8f4f00
or
git diff-tree --abbrev --pretty -c -M -r 0a8f4f00
^ permalink raw reply
* Re: [PATCH] merge-recur: if there is no common ancestor, fake empty one
From: Johannes Schindelin @ 2006-08-09 17:44 UTC (permalink / raw)
To: git, junkio
In-Reply-To: <Pine.LNX.4.63.0608091842210.1800@wbgn013.biozentrum.uni-wuerzburg.de>
Hi,
On Wed, 9 Aug 2006, Johannes Schindelin wrote:
> + *write_sha1_file_prepare(NULL, 0, tree_type, &tree->object.sha1,
... make this "tree->object.sha1" _without_ a "&", of course.
Ciao,
Dscho
^ permalink raw reply
* Re: setting up a git repo on apache
From: Alan Larkin @ 2006-08-09 17:02 UTC (permalink / raw)
To: git
In-Reply-To: <20060809164305.GA7841@nospam.com>
Rutger Nijlunsing wrote:
> On Wed, Aug 09, 2006 at 04:58:03PM +0100, Alan Larkin wrote:
>> New user ... Hi.
>>
>> I realise that this is really an apache question, but Im not getting any
>> help from their mailing lists and figure that there must be someone here
>> whos done this.
>>
>> Can someone please help me get a GIT repo running on Apache 2.
>> Specifically my problem is with DAV.
>>
>> $ git push http://localhost:/webdav/git/myproj master
>> Error: no DAV locking support on remote repo
>
> This 'localhost:' is a typo, right?
>
> (just to be sure)
>
>
Um ... it wasnt actually. I was copying this line from "A git core
tutorial for developers":
$ git push <public-host>:/path/to/my-git.git master
Although I did think it curious enough to try it with and without the
colon (it is the colon youre questioning right?).
^ permalink raw reply
* Re: setting up a git repo on apache
From: Alan Larkin @ 2006-08-09 17:01 UTC (permalink / raw)
To: git
In-Reply-To: <Pine.LNX.4.63.0608091831320.1800@wbgn013.biozentrum.uni-wuerzburg.de>
Johannes Schindelin wrote:
> Hi,
>
> On Wed, 9 Aug 2006, Alan Larkin wrote:
>
>> $ git push http://localhost:/webdav/git/myproj master
>> Error: no DAV locking support on remote repo
>
> What do the access_log and the error_log say about this?
>
> It could also be that you have a "Require valid-user" somewhere in there
> by mistake.
>
> Further, you might want to check if it works _with_ authentication (I
> never tried without, and I am not sure if it should be allowed to begin
> with).
>
> There is a recent thread by Junio, Rutger and me, which might help you:
>
> http://thread.gmane.org/gmane.comp.version-control.git/24816/focus=24861
>
> Hth,
> Dscho
>
>
>
I initially had authentication in place (which was working insofar as I
couldnt browse the repo without logging in) but I removed it to simplify
the process of tracking down the DAV problem. I have also removed all
.htaccess files so nothing can be overriding apache2.conf and that only
contains:
<Directory /var/www/webdav>
Order allow,deny
Allow from localhost
DAV on
</Directory>
Ill look into that previous thread. Apologies for not finding it before
posting.
^ permalink raw reply
* Re: setting up a git repo on apache
From: Rutger Nijlunsing @ 2006-08-09 16:43 UTC (permalink / raw)
To: Alan Larkin; +Cc: git
In-Reply-To: <44DA060B.2050601@eircom.net>
On Wed, Aug 09, 2006 at 04:58:03PM +0100, Alan Larkin wrote:
> New user ... Hi.
>
> I realise that this is really an apache question, but Im not getting any
> help from their mailing lists and figure that there must be someone here
> whos done this.
>
> Can someone please help me get a GIT repo running on Apache 2.
> Specifically my problem is with DAV.
>
> $ git push http://localhost:/webdav/git/myproj master
> Error: no DAV locking support on remote repo
This 'localhost:' is a typo, right?
(just to be sure)
--
Rutger Nijlunsing ---------------------------------- eludias ed dse.nl
never attribute to a conspiracy which can be explained by incompetence
----------------------------------------------------------------------
^ permalink raw reply
* [PATCH] merge-recur: if there is no common ancestor, fake empty one
From: Johannes Schindelin @ 2006-08-09 16:43 UTC (permalink / raw)
To: git, junkio
This fixes the coolest merge ever.
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
---
This was a forgotten part from the python version.
merge-recursive.c | 12 ++++++++++++
1 files changed, 12 insertions(+), 0 deletions(-)
diff --git a/merge-recursive.c b/merge-recursive.c
index 7a93dd9..f5b547b 100644
--- a/merge-recursive.c
+++ b/merge-recursive.c
@@ -1223,6 +1223,18 @@ int merge(struct commit *h1,
output_commit_title(iter->item);
merged_common_ancestors = pop_commit(&ca);
+ if (merged_common_ancestors == NULL) {
+ /* if there is no common ancestor, make an empty tree */
+ struct tree *tree = xcalloc(1, sizeof(struct tree));
+ char buffer[40];
+ int hdrlen;
+
+ tree->object.parsed = 1;
+ tree->object.type = OBJ_TREE;
+ *write_sha1_file_prepare(NULL, 0, tree_type, &tree->object.sha1,
+ buffer, &hdrlen);
+ merged_common_ancestors = make_virtual_commit(tree, "ancestor");
+ }
for (iter = ca; iter; iter = iter->next) {
output_indent = call_depth + 1;
--
1.4.2.rc3.g29d0-dirty
^ permalink raw reply related
* Re: setting up a git repo on apache
From: Johannes Schindelin @ 2006-08-09 16:35 UTC (permalink / raw)
To: Alan Larkin; +Cc: git
In-Reply-To: <44DA060B.2050601@eircom.net>
Hi,
On Wed, 9 Aug 2006, Alan Larkin wrote:
> $ git push http://localhost:/webdav/git/myproj master
> Error: no DAV locking support on remote repo
What do the access_log and the error_log say about this?
It could also be that you have a "Require valid-user" somewhere in there
by mistake.
Further, you might want to check if it works _with_ authentication (I
never tried without, and I am not sure if it should be allowed to begin
with).
There is a recent thread by Junio, Rutger and me, which might help you:
http://thread.gmane.org/gmane.comp.version-control.git/24816/focus=24861
Hth,
Dscho
^ permalink raw reply
* setting up a git repo on apache
From: Alan Larkin @ 2006-08-09 15:58 UTC (permalink / raw)
To: git
New user ... Hi.
I realise that this is really an apache question, but Im not getting any
help from their mailing lists and figure that there must be someone here
whos done this.
Can someone please help me get a GIT repo running on Apache 2.
Specifically my problem is with DAV.
$ git push http://localhost:/webdav/git/myproj master
Error: no DAV locking support on remote repo
I have dav_fs.conf, dav_fs.load, and dav.load in mods-enabled. They
load the modules and set
DAVLockDB /var/lock/apache2/DAV.lock
Apache owns and has full access to that directory.
I have removed all .htaccess files below /var/www/webdav. I am not
using any form of authentication. I have tried with and without aliases
for the repo directory. I have tried setting DAV on for
/var/www/webdav/git, and /var/www/webdav/git/myproj.
Its always the same. No DAV locking support.
If could help or even point me to some appropriate documentation (Ive
looked and looked and cant find any) Id appreciate it.
Thanks.
^ 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