* Re: [PATCH] disable post-checkout test on Cygwin
From: Junio C Hamano @ 2009-03-17 16:52 UTC (permalink / raw)
To: Alex Riesen; +Cc: Jeff King, layer, git
In-Reply-To: <81b0412b0903170926p4f2d536el2b96a71c79c0159e@mail.gmail.com>
Alex Riesen <raa.lkml@gmail.com> writes:
> It is broken because of the tricks we have to play with
> lstat to get the bearable perfomance out of the call.
> Sadly, it disables access to Cygwin's executable attribute,
> which Windows filesystems do not have at all.
Hmm, perhaps when checking hooks to see if they are executable, Cygwin
port should avoid using the "tricks"? Compared to paths inside the
worktree the number of hooks is a lot smaller, no?
^ permalink raw reply
* Re: Generate version file by hooks
From: Johannes Sixt @ 2009-03-17 16:54 UTC (permalink / raw)
To: Björn Hendriks; +Cc: git, John Dlugosz, Santi Béjar
In-Reply-To: <200903171740.26575.bjoern01@nurfuerspam.de>
Björn Hendriks schrieb:
> In fact my problem is not to find out the SHA1 of the last commit in a script
> but to have that script called automatically each time git changes the
> commit. My idea was to use the git hooks for that, but as I explained I
> couldn't find hooks for all cases in which a commit changes.
In fact there are so many situations where the current commit changes. You
won't find enough hooks to catch all cases.
You better modify your build system to look for the current commit when it
is needed. That is *much* safer.
-- Hannes
^ permalink raw reply
* Re: Mirroring repository state, with branches and submodules.
From: Miklos Vajna @ 2009-03-17 16:56 UTC (permalink / raw)
To: Toby White; +Cc: git
In-Reply-To: <623D3837-E899-49AF-9A37-F667A311EE58@gmail.com>
[-- Attachment #1: Type: text/plain, Size: 489 bytes --]
On Tue, Mar 17, 2009 at 03:21:40PM +0000, Toby White <toby.o.h.white@googlemail.com> wrote:
> git fetch
> for BRANCH in $(git branch -r | cut -d / -f 2); do
> git checkout $BRANCH
> git reset --hard origin/$BRANCH
> done
> git submodule update --init
First, I think you don't handle the case when you have multiple
remotes. I don't know if this is a problem for you or not.
Second, use plumbing in scripts, git for-each-ref has a stable output
format, while git branch may change.
[-- Attachment #2: Type: application/pgp-signature, Size: 197 bytes --]
^ permalink raw reply
* Re: [PATCH] disable post-checkout test on Cygwin
From: Johannes Sixt @ 2009-03-17 16:59 UTC (permalink / raw)
To: Alex Riesen; +Cc: Junio C Hamano, Jeff King, layer, git
In-Reply-To: <7vprggqeh2.fsf@gitster.siamese.dyndns.org>
Junio C Hamano schrieb:
> Alex Riesen <raa.lkml@gmail.com> writes:
>
>> It is broken because of the tricks we have to play with
>> lstat to get the bearable perfomance out of the call.
>> Sadly, it disables access to Cygwin's executable attribute,
>> which Windows filesystems do not have at all.
>
> Hmm, perhaps when checking hooks to see if they are executable, Cygwin
> port should avoid using the "tricks"? Compared to paths inside the
> worktree the number of hooks is a lot smaller, no?
Hmm. Nowadays, we run hooks through run_hook() in run_command.c. It uses
access(..., X_OK), not lstat(). We don't play games with access(), do we?
-- Hannes
^ permalink raw reply
* Re: [PATCH] git-branch.txt: document -f correctly
From: git @ 2009-03-17 16:51 UTC (permalink / raw)
To: John Dlugosz; +Cc: git
In-Reply-To: <450196A1AAAE4B42A00A8B27A59278E70A3FC05C@EXCHANGE.trad.tradestation.com>
John Dlugosz venit, vidit, dixit 17.03.2009 17:07:
> === Re: ===
> BTW, I noticed that 'git-subcmd' is used everywhere in here which does
> not feel right, but I followed the existing style, leaving a consistent
> clean-up for a later patch. Also, typesetting is inconsistent:
> We have <branch> as well as `<branch>` when the text talks about the
> options. Do we have a style guide or such?
> === end ===
>
> I would agree that being factually correct and available immediately
> trumps being wrong but pretty.
I can't really make much sense out of this but I guess I doesn't matter.
In any case, by "style guide" I mean something saying "write options as
monospaced", "write git commands without dash unless in links"...
> As an experienced writer and editor, the documentation is something I
> might hack long before I tackle the code. I see you edited a file with
> .txt extension, and some kind of markup that's not the HTML files I'm
> reading. Beyond any kind of style guide, is there a guide to the
> documentation _system_ in use?
It's asciidoc. Rather, asciidoc 7ish, current asciidoc is at 8.4.1.
The backticks are used for displaying commands, e.g., and usually come
out as monospaced in html, underlined in man.
Cheers,
Michael
^ permalink raw reply
* [PATCH] config.txt: Describe special 'none' handling in core.gitProxy.
From: Emil Sit @ 2009-03-17 17:31 UTC (permalink / raw)
To: git
Signed-off-by: Emil Sit <sit@emilsit.net>
---
I noticed none support in connect.c that was not documented in config.txt.
Here's a small patch to explain it.
Documentation/config.txt | 5 +++++
1 files changed, 5 insertions(+), 0 deletions(-)
diff --git a/Documentation/config.txt b/Documentation/config.txt
index 56bd781..d5532d2 100644
--- a/Documentation/config.txt
+++ b/Documentation/config.txt
@@ -221,6 +221,11 @@ core.gitProxy::
Can be overridden by the 'GIT_PROXY_COMMAND' environment variable
(which always applies universally, without the special "for"
handling).
++
+The special string `none` can be used as the proxy command to
+specify that no proxy be used for a given domain pattern.
+This is useful for excluding servers inside a firewall from
+proxy use, while defaulting to a common proxy for external domains.
core.ignoreStat::
If true, commands which modify both the working tree and the index
--
1.6.1
--
Emil Sit / http://www.emilsit.net/
^ permalink raw reply related
* Re: [PATCH 2/2] make the ST_{C,M}TIME_NSEC macros more function like
From: Kjetil Barvik @ 2009-03-17 17:38 UTC (permalink / raw)
To: Junio C Hamano; +Cc: git
In-Reply-To: <7vhc1ux7nx.fsf@gitster.siamese.dyndns.org>
Junio C Hamano <gitster@pobox.com> writes:
> Kjetil Barvik <barvik@broadpark.no> writes:
>
>> [...] in C or Pascal, calling a function with a large structure as
>> an argument will cause the entire structure to be copied,
>> potentially causing serious performance degradation, and mutations
>> to the structure are invisible to the caller. [...]
>>
>> So in my eyes it make more sense to be consistent and take the address
>> of all struct like objects (&st in this case) for all arguments to
>> "function-like" things.
>
> Notice the "mutations to the structure are invisible to the caller" part.
> The call site of st_ctime_nsec(st) can be sure that st won't be modified,
> without checking the definition of the function.
>
> Which is actually a nice property. When st_ctime_nsec(st) is implemented as
> a macro, you _could_ write it in such a way to mutate what is in st, but
> the implementation does not do so, and will be unlikely to in the future,
> so I think writing it as if it is a function that receives a structure by
> value will help readers of the calling code.
>
> And the readability is what we should optimize for when picking from two
> ways to write it, and when the generated code is the same.
OK, I guess we can dropp this patch! :-)
-- kjetil
^ permalink raw reply
* Suggested Workflow Question
From: Roger Garvin @ 2009-03-17 17:51 UTC (permalink / raw)
To: git
I work for a small company with about 15 developers who work concurrently on
about 10+ projects both in new development and support.
We do custom software for manufacturing and production systems. Part of our
contracts with our customers is a perpetual single use license of the source
code at each facility.
So we have a copy of the source on our office server, and another copy at each
customer site. When we had only 5 developers it was easier to handle. Now that
we are growing we need a source control system and I have been looking heavily
into Git. Our old workflow does not seem that it will fit well with Git
however, but I feel that I need a distributed system to keep track of the office
version and the on-site versions of our source since development is taking place
on both.
(Some customers also have separate development, and testing versions on their
servers as well.)
I have created git repositories on a couple of our project source directories as
test beds. Right now (second day) I am the only one who is actually using git.
Everyone else is simply accessing the files on the server as they have always
done, and I am making the commits when I see signifigant changes.
My question is really a request for modified workflow ideas. My plan was to
have a master repository in our office server with clones at each customer site,
and multiple branches for test, QA, and production versions of the source.
Since most of these customers have closed networks, we would rely on people
traveling onsite, or emailing patches to get any updates back into our office
repository.
Thank you for any assistance for this revision control newb.
Roger Garvin
^ permalink raw reply
* Re: [PATCH] builtin-tag.c: remove global variable to use the callback data of git-config.
From: Carlos Rica @ 2009-03-17 17:57 UTC (permalink / raw)
To: Johannes Schindelin; +Cc: gitster, git
In-Reply-To: <alpine.DEB.1.00.0903171646140.6393@intel-tinevez-2-302>
On Tue, Mar 17, 2009 at 4:47 PM, Johannes Schindelin
<Johannes.Schindelin@gmx.de> wrote:
> Hi,
> On Tue, 17 Mar 2009, Carlos Rica wrote:
>> @@ -164,11 +162,10 @@ static int do_sign(struct strbuf *buffer)
>> int len;
>> int i, j;
>>
>> - if (!*signingkey) {
>> - if (strlcpy(signingkey, git_committer_info(IDENT_ERROR_ON_NO_NAME),
>> - sizeof(signingkey)) > sizeof(signingkey) - 1)
>> - return error("committer info too long.");
>> - bracket = strchr(signingkey, '>');
>> + if (!signingkey->buf[0]) {
>
> It is probably better to ask for !signingkey->len (think of trying to
> understand the code in 6 months from now).
I was in doubt here. By avoiding the use of signingkey->len I was
trying to say that you cannot rely in such field if we touch the
buffer directly, as it happens below:
bracket = strchr(signingkey->buf, '>');
if (bracket)
bracket[1] = '\0';
^ permalink raw reply
* [PATCH] Revert "lstat_cache(): print a warning if doing ping-pong between cache types"
From: Kjetil Barvik @ 2009-03-17 18:20 UTC (permalink / raw)
To: git; +Cc: Junio C Hamano, Kjetil Barvik
This reverts commit 7734f04873cfaddd0b148074a633f1f824fd961f.
I guess that the revert commit, 7734f048, has been in test long
enough, and should now be reverted. I have not received any info
regarding any debug output of the reverted commit, so lets hope that
the lstat_cache() function do not cause any ping-pong.
Signed-off-by: Kjetil Barvik <barvik@broadpark.no>
---
Junio, I do not know what type of people who use, test and play
around with the master branch, but I guess that not all of them
expect to get a debug output from the program.
So, therefore, I have made this revert now, but you can decide when
it should be aplayed, now and right before the patch is merged into
master or right before the next release, v1.6.3, is made.
symlinks.c | 23 -----------------------
1 files changed, 0 insertions(+), 23 deletions(-)
diff --git a/symlinks.c b/symlinks.c
index cb255a3..1d6b35b 100644
--- a/symlinks.c
+++ b/symlinks.c
@@ -51,11 +51,6 @@ static inline void reset_lstat_cache(void)
*/
}
-#define SWITCHES_BEFORE_WARNING 10
-static unsigned int cache_switches, number_of_warnings;
-static unsigned int current_cache_func, last_cache_func;
-static unsigned int total_calls;
-
#define FL_DIR (1 << 0)
#define FL_NOENT (1 << 1)
#define FL_SYMLINK (1 << 2)
@@ -82,7 +77,6 @@ static int lstat_cache(const char *name, int len,
int match_flags, ret_flags, save_flags, max_len, ret;
struct stat st;
- total_calls++;
if (cache.track_flags != track_flags ||
cache.prefix_len_stat_func != prefix_len_stat_func) {
/*
@@ -94,17 +88,6 @@ static int lstat_cache(const char *name, int len,
cache.track_flags = track_flags;
cache.prefix_len_stat_func = prefix_len_stat_func;
match_len = last_slash = 0;
- cache_switches++;
- if (cache_switches > SWITCHES_BEFORE_WARNING) {
- if (number_of_warnings < 10 || number_of_warnings % 1000 == 0)
- printf("warning from %s:%d cache_switches:%u > %u "\
- "(current:%u last:%u total:%u)\n",
- __FILE__, __LINE__,
- cache_switches, SWITCHES_BEFORE_WARNING,
- current_cache_func, last_cache_func,
- total_calls);
- number_of_warnings++;
- }
} else {
/*
* Check to see if we have a match from the cache for
@@ -233,8 +216,6 @@ void clear_lstat_cache(void)
*/
int has_symlink_leading_path(const char *name, int len)
{
- last_cache_func = current_cache_func;
- current_cache_func = 1;
return lstat_cache(name, len,
FL_SYMLINK|FL_DIR, USE_ONLY_LSTAT) &
FL_SYMLINK;
@@ -246,8 +227,6 @@ int has_symlink_leading_path(const char *name, int len)
*/
int has_symlink_or_noent_leading_path(const char *name, int len)
{
- last_cache_func = current_cache_func;
- current_cache_func = 2;
return lstat_cache(name, len,
FL_SYMLINK|FL_NOENT|FL_DIR, USE_ONLY_LSTAT) &
(FL_SYMLINK|FL_NOENT);
@@ -262,8 +241,6 @@ int has_symlink_or_noent_leading_path(const char *name, int len)
*/
int has_dirs_only_path(const char *name, int len, int prefix_len)
{
- last_cache_func = current_cache_func;
- current_cache_func = 3;
return lstat_cache(name, len,
FL_DIR|FL_FULLPATH, prefix_len) &
FL_DIR;
--
1.6.2.GIT
^ permalink raw reply related
* [PATCH 2/4] Documentation: reworded the "Description" section of git-bisect.txt.
From: David J. Mellor @ 2009-03-14 22:56 UTC (permalink / raw)
To: gitster; +Cc: git
In-Reply-To: <1237270577-17261-2-git-send-email-dmellor@whistlingcat.com>
Reworded this section to make it less chatty. Also made minor grammatical
fixes.
Signed-off-by: David J. Mellor <dmellor@whistlingcat.com>
---
Resubmitting this patch to correct a typo at line 90 in the patched file:
resest --> resets
Also corrected the subject:
git-blame.txt --> git-bisect.txt
Documentation/git-bisect.txt | 154 +++++++++++++++++++++---------------------
1 files changed, 77 insertions(+), 77 deletions(-)
diff --git a/Documentation/git-bisect.txt b/Documentation/git-bisect.txt
index e65c1ca..51d06c1 100644
--- a/Documentation/git-bisect.txt
+++ b/Documentation/git-bisect.txt
@@ -3,7 +3,7 @@ git-bisect(1)
NAME
----
-git-bisect - Find the change that introduced a bug by binary search
+git-bisect - Find by binary search the change that introduced a bug
SYNOPSIS
@@ -39,7 +39,8 @@ help" or "git bisect -h" to get a long usage description.
Basic bisect commands: start, bad, good
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-The way you use it is:
+Using the Linux kernel tree as an example, basic use of the bisect
+command is as follows:
------------------------------------------------
$ git bisect start
@@ -48,61 +49,62 @@ $ git bisect good v2.6.13-rc2 # v2.6.13-rc2 was the last version
# tested that was good
------------------------------------------------
-When you give at least one bad and one good versions, it will bisect
-the revision tree and say something like:
+When you have specified at least one bad and one good version, the
+command bisects the revision tree and outputs something similar to:
------------------------------------------------
Bisecting: 675 revisions left to test after this
------------------------------------------------
-and check out the state in the middle. Now, compile that kernel, and
-boot it. Now, let's say that this booted kernel works fine, then just
-do
+and then checks out the state in the middle. You would now compile
+that kernel and boot it. If the booted kernel works correctly, you
+would then issue the following command:
------------------------------------------------
$ git bisect good # this one is good
------------------------------------------------
-which will now say
+which would then output something similar to:
------------------------------------------------
Bisecting: 337 revisions left to test after this
------------------------------------------------
and you continue along, compiling that one, testing it, and depending
-on whether it is good or bad, you say "git bisect good" or "git bisect
-bad", and ask for the next bisection.
+on whether it is good or bad issuing the command "git bisect good"
+or "git bisect bad" to ask for the next bisection.
-Until you have no more left, and you'll have been left with the first
-bad kernel rev in "refs/bisect/bad".
+Eventually there will be no more revisions left to bisect, and you
+will have been left with the first bad kernel revision in "refs/bisect/bad".
Bisect reset
~~~~~~~~~~~~
-Oh, and then after you want to reset to the original head, do a
+To return to the original head after a bisect session, you issue the
+command:
------------------------------------------------
$ git bisect reset
------------------------------------------------
-to get back to the original branch, instead of being on the bisection
-commit ("git bisect start" will do that for you too, actually: it will
-reset the bisection state).
+This resets the tree to the original branch instead of being on the
+bisection commit ("git bisect start" will also do that, as it resets
+the bisection state).
Bisect visualize
~~~~~~~~~~~~~~~~
-During the bisection process, you can say
+During the bisection process, you issue the command:
------------
$ git bisect visualize
------------
-to see the currently remaining suspects in 'gitk'. `visualize` is a bit
-too long to type and `view` is provided as a synonym.
+to see the currently remaining suspects in 'gitk'. `view` may also
+be used as a synonym for `visualize`.
-If 'DISPLAY' environment variable is not set, 'git log' is used
-instead. You can even give command line options such as `-p` and
+If the 'DISPLAY' environment variable is not set, 'git log' is used
+instead. You can also give command line options such as `-p` and
`--stat`.
------------
@@ -112,57 +114,56 @@ $ git bisect view --stat
Bisect log and bisect replay
~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-The good/bad input is logged, and
+The good/bad input is logged, and:
------------
$ git bisect log
------------
shows what you have done so far. You can truncate its output somewhere
-and save it in a file, and run
+and save it in a file, and run:
------------
$ git bisect replay that-file
------------
-if you find later you made a mistake telling good/bad about a
-revision.
+if you find later that you made a mistake specifying revisions as good/bad.
-Avoiding to test a commit
+Avoiding testing a commit
~~~~~~~~~~~~~~~~~~~~~~~~~
-If in a middle of bisect session, you know what the bisect suggested
-to try next is not a good one to test (e.g. the change the commit
+If in the middle of a bisect session, you know that the next suggested
+revision is not a good one to test (e.g. the change the commit
introduces is known not to work in your environment and you know it
does not have anything to do with the bug you are chasing), you may
-want to find a near-by commit and try that instead.
+want to find a nearby commit and try that instead.
-It goes something like this:
+For example:
------------
$ git bisect good/bad # previous round was good/bad.
Bisecting: 337 revisions left to test after this
$ git bisect visualize # oops, that is uninteresting.
-$ git reset --hard HEAD~3 # try 3 revs before what
+$ git reset --hard HEAD~3 # try 3 revisions before what
# was suggested
------------
-Then compile and test the one you chose to try. After that, tell
-bisect what the result was as usual.
+Then compile and test the chosen revision. Afterwards the revision
+is marked as good/bad in the usual manner.
Bisect skip
~~~~~~~~~~~~
-Instead of choosing by yourself a nearby commit, you may just want git
-to do it for you using:
+Instead of choosing by yourself a nearby commit, you can ask git
+to do it for you by issuing the command:
------------
$ git bisect skip # Current version cannot be tested
------------
But computing the commit to test may be slower afterwards and git may
-eventually not be able to tell the first bad among a bad and one or
-more "skip"ped commits.
+eventually not be able to tell the first bad commit among a bad commit
+and one or more skipped commits.
You can even skip a range of commits, instead of just one commit,
using the "'<commit1>'..'<commit2>'" notation. For example:
@@ -174,30 +175,29 @@ $ git bisect skip v2.5..v2.6
would mean that no commit between `v2.5` excluded and `v2.6` included
can be tested.
-Note that if you want to also skip the first commit of a range you can
-use something like:
+Note that if you also want to skip the first commit of the range you
+would issue the command:
------------
$ git bisect skip v2.5 v2.5..v2.6
------------
-and the commit pointed to by `v2.5` will be skipped too.
+and the commit pointed to by `v2.5` would also be skipped.
Cutting down bisection by giving more parameters to bisect start
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-You can further cut down the number of trials if you know what part of
-the tree is involved in the problem you are tracking down, by giving
-paths parameters when you say `bisect start`, like this:
+You can further cut down the number of trials, if you know what part of
+the tree is involved in the problem you are tracking down, by specifying
+path parameters when issuing the `bisect start` command, like this:
------------
$ git bisect start -- arch/i386 include/asm-i386
------------
-If you know beforehand more than one good commits, you can narrow the
-bisect space down without doing the whole tree checkout every time you
-give good commits. You give the bad revision immediately after `start`
-and then you give all the good revisions you have:
+If you know beforehand more than one good commit, you can narrow the
+bisect space down by specifying all of the good commits immediately after
+the bad commit when issuing the `bisect start` command:
------------
$ git bisect start v2.6.20-rc6 v2.6.20-rc4 v2.6.20-rc1 --
@@ -209,38 +209,38 @@ Bisect run
~~~~~~~~~~
If you have a script that can tell if the current source code is good
-or bad, you can automatically bisect using:
+or bad, you can bisect by issuing the command:
------------
$ git bisect run my_script arguments
------------
-Note that the "run" script (`my_script` in the above example) should
-exit with code 0 in case the current source code is good. Exit with a
+Note that the script (`my_script` in the above example) should
+exit with code 0 if the current source code is good, and exit with a
code between 1 and 127 (inclusive), except 125, if the current
source code is bad.
-Any other exit code will abort the automatic bisect process. (A
-program that does "exit(-1)" leaves $? = 255, see exit(3) manual page,
-the value is chopped with "& 0377".)
+Any other exit code will abort the bisect process. It should be noted
+that a program that terminates via "exit(-1)" leaves $? = 255, (see the
+exit(3) manual page), as the value is chopped with "& 0377".
The special exit code 125 should be used when the current source code
-cannot be tested. If the "run" script exits with this code, the current
-revision will be skipped, see `git bisect skip` above.
+cannot be tested. If the script exits with this code, the current
+revision will be skipped (see `git bisect skip` above).
-You may often find that during bisect you want to have near-constant
-tweaks (e.g., s/#define DEBUG 0/#define DEBUG 1/ in a header file, or
-"revision that does not have this commit needs this patch applied to
-work around other problem this bisection is not interested in")
-applied to the revision being tested.
+You may often find that during a bisect session you want to have
+temporary modifications (e.g. s/#define DEBUG 0/#define DEBUG 1/ in a
+header file, or "revision that does not have this commit needs this
+patch applied to work around another problem this bisection is not
+interested in") applied to the revision being tested.
To cope with such a situation, after the inner 'git bisect' finds the
-next revision to test, with the "run" script, you can apply that tweak
-before compiling, run the real test, and after the test decides if the
-revision (possibly with the needed tweaks) passed the test, rewind the
-tree to the pristine state. Finally the "run" script can exit with
-the status of the real test to let the "git bisect run" command loop to
-determine the outcome.
+next revision to test, the script can apply the patch
+before compiling, run the real test, and afterwards decide if the
+revision (possibly with the needed patch) passed the test and then
+rewind the tree to the pristine state. Finally the script should exit
+with the status of the real test to let the "git bisect run" command loop
+to determine the eventual outcome of the bisect session.
EXAMPLES
--------
@@ -264,39 +264,39 @@ $ git bisect run make test # "make test" builds and tests
------------
$ cat ~/test.sh
#!/bin/sh
-make || exit 125 # this "skip"s broken builds
+make || exit 125 # this skips broken builds
make test # "make test" runs the test suite
$ git bisect start v1.3 v1.1 -- # v1.3 is bad, v1.1 is good
$ git bisect run ~/test.sh
------------
+
Here we use a "test.sh" custom script. In this script, if "make"
-fails, we "skip" the current commit.
+fails, we skip the current commit.
+
-It's safer to use a custom script outside the repo to prevent
+It is safer to use a custom script outside the repository to prevent
interactions between the bisect, make and test processes and the
script.
+
-And "make test" should "exit 0", if the test suite passes, and
-"exit 1" (for example) otherwise.
+"make test" should "exit 0", if the test suite passes, and
+"exit 1" otherwise.
* Automatically bisect a broken test case:
+
------------
$ cat ~/test.sh
#!/bin/sh
-make || exit 125 # this "skip"s broken builds
+make || exit 125 # this skips broken builds
~/check_test_case.sh # does the test case passes ?
$ git bisect start HEAD HEAD~10 -- # culprit is among the last 10
$ git bisect run ~/test.sh
------------
+
-Here "check_test_case.sh" should "exit 0", if the test case passes,
-and "exit 1" (for example) otherwise.
+Here "check_test_case.sh" should "exit 0" if the test case passes,
+and "exit 1" otherwise.
+
-It's safer if both "test.sh" and "check_test_case.sh" scripts are
-outside the repo to prevent interactions between the bisect, make and
-test processes and the scripts.
+It is safer if both "test.sh" and "check_test_case.sh" scripts are
+outside the repository to prevent interactions between the bisect,
+make and test processes and the scripts.
* Automatically bisect a broken test suite:
+
--
1.6.2.1
^ permalink raw reply related
* Re: [EGIT] assertion failure when renaming file
From: Robin Rosenberg @ 2009-03-17 18:40 UTC (permalink / raw)
To: Marcus Better; +Cc: git
In-Reply-To: <gpnrcv$mla$1@ger.gmane.org>
tisdag 17 mars 2009 10:43:52 skrev Marcus Better <marcus@better.se>:
> Hi,
Hej,
> I get this assertion failure from the Eclipse plugin 0.4.0.200903110025 whenever I try to rename an untracked file in Eclipse:
There are some ways of corrupting a repo, i.e. the association between the Git provider and the project that results in wierd
behaviours. The ones I know of are related to renaming and moving projects tracked by EGit, which works minus-well.
Could you try with a fresh workspace (you can keep the workdir as-is)?
-- robin
^ permalink raw reply
* Re: [PATCH] builtin-tag.c: remove global variable to use the callback data of git-config.
From: Junio C Hamano @ 2009-03-17 18:45 UTC (permalink / raw)
To: Carlos Rica; +Cc: Johannes Schindelin, gitster, git
In-Reply-To: <1b46aba20903171057r4fb4697eo3b8abc62a45fe858@mail.gmail.com>
Carlos Rica <jasampler@gmail.com> writes:
> On Tue, Mar 17, 2009 at 4:47 PM, Johannes Schindelin
> <Johannes.Schindelin@gmx.de> wrote:
>> Hi,
>> On Tue, 17 Mar 2009, Carlos Rica wrote:
>>> @@ -164,11 +162,10 @@ static int do_sign(struct strbuf *buffer)
>>> int len;
>>> int i, j;
>>>
>>> - if (!*signingkey) {
>>> - if (strlcpy(signingkey, git_committer_info(IDENT_ERROR_ON_NO_NAME),
>>> - sizeof(signingkey)) > sizeof(signingkey) - 1)
>>> - return error("committer info too long.");
>>> - bracket = strchr(signingkey, '>');
>>> + if (!signingkey->buf[0]) {
>>
>> It is probably better to ask for !signingkey->len (think of trying to
>> understand the code in 6 months from now).
>
> I was in doubt here. By avoiding the use of signingkey->len I was
> trying to say that you cannot rely in such field if we touch the
> buffer directly, as it happens below:
>
> bracket = strchr(signingkey->buf, '>');
> if (bracket)
> bracket[1] = '\0';
That's a wrong use of strbuf, isn't it?
^ permalink raw reply
* Ability to edit message from git rebase --interactive.
From: Olivier Goffart @ 2009-03-17 18:53 UTC (permalink / raw)
To: git
[-- Attachment #1: Type: text/plain, Size: 801 bytes --]
Hello.
I use git in a workflow in wich we often need to edit the message logs of some
commits.
The way we do it is using git rebase -i and choose edit.
But then you need to do git commit --amend and git rebase --continue, which
is error prone and add more useless steps.
The attached patch add a new keyword to git rebase interactive to just edit
the message log.
I was told on IRC that this has been discussed already not so long ago, and
looking on the archive[1], all i seen was bikesheeding . Here is a patch :-)
Do you think it make sens to have that in git?
Please CC me replies.
--
Olivier
[1] http://thread.gmane.org/gmane.comp.version-control.git/105738
(my patch is different from this one as it adds a new keyword rather than
change the behavior of one existing one)
[-- Attachment #2: editmessage.diff --]
[-- Type: text/x-patch, Size: 1158 bytes --]
commit 71793acdd9f926ea52d034b17ac3465e3a810799
Author: Olivier Goffart <ogoffart@kde.org>
Date: Tue Mar 17 19:41:40 2009 +0100
rebase interactive: add the possibility to easily edit the message log of commits
diff --git a/git-rebase--interactive.sh b/git-rebase--interactive.sh
index 3dc659d..6ded58e 100755
--- a/git-rebase--interactive.sh
+++ b/git-rebase--interactive.sh
@@ -406,6 +406,16 @@ do_next () {
die_with_patch $sha1 ""
fi
;;
+ message|m)
+ comment_for_reflog message
+
+ mark_action_done
+
+ pick_one $sha1 ||
+ die_with_patch $sha1 "Could not apply $sha1... $rest"
+
+ git commit --amend || failed=t
+ ;;
*)
warn "Unknown command: $command $sha1 $rest"
die_with_patch $sha1 "Please fix this in the file $TODO."
@@ -730,6 +740,7 @@ first and then run 'git rebase --continue' again."
# p, pick = use commit
# e, edit = use commit, but stop for amending
# s, squash = use commit, but meld into previous commit
+# m, message = use commit and promt the editor to edit the message log
#
# If you remove a line here THAT COMMIT WILL BE LOST.
# However, if you remove everything, the rebase will be aborted.
^ permalink raw reply related
* git repack: --depth=100000 causing larger not smaler pack file?
From: Kjetil Barvik @ 2009-03-17 19:05 UTC (permalink / raw)
To: git
aloha!
Yesterday I run the following command on the updated GIT respository:
git repack -adf --window=250000 --depth=100000
After 280 minutes or so it finished, but the strange thing was that
the resulting pack-file was larger than before. I had expected that
it should be smaler, or at least the same size as before.
kjetil git (my_next)$ ls -l .git/objects/pack/*
-r-------- 1 kjetil kjetil 2757280 2009-03-16 15:18 .git/objects/pack/pack-c5f15d5c48d6b3902a49046d7e8a8d717e167051.idx
-r-------- 1 kjetil kjetil 19961120 2009-03-16 15:18 .git/objects/pack/pack-c5f15d5c48d6b3902a49046d7e8a8d717e167051.pack
Before I started the pack file was around 19 250 000 bytes, and was
the result of the following commands:
1) git repack -adf --window=250000 --depth=20000
- not completly sure about the --window number here
- the resulting pack file was a litle less than 19 100 000
2) 'git fetch' to get the latest GIT patches
3) since 'git fetch' always make an extra new "smal" pack file, I run
the command 'git repack -ad --window=40000 --depth=10000' to be
able to get one singel pack file of 19 250 000 bytes or so.
I can think of one thing which is spesial with the "--depth=100000"
number, and that is that it is now larger than the total number of
objects in the pack, which is around 96000 to 97000, or so.
I have run 'git fsck --strict --full' on the pack with no resulting
error/debug output or change in the file size.
Any help on how to debug this?
-- kjetil
^ permalink raw reply
* Local clone checks out wrong branch based on remote HEAD
From: Tom Preston-Werner @ 2009-03-17 19:19 UTC (permalink / raw)
To: git
I'm having some unexpected behavior when cloning a remote repo that
has several branches at the same commit. On the remote side, the HEAD
is 'trunk':
git@remote ~/repositories/akincisor/site.git $ cat HEAD
ref: refs/heads/trunk
After cloning this with a standard `git clone`, the refs are:
[11:48][tom@solid:~/dev/sandbox/site(release)]$ git branch -r -v
origin/HEAD a52528a Fixed some routing problems
origin/release a52528a Fixed some routing problems
origin/trunk a52528a Fixed some routing problems
And the checked out branch is 'release' instead of 'trunk' as I would expect:
[11:48][tom@solid:~/dev/sandbox/site(release)]$ git branch
* release
I'm guessing that the first branch that matches the remote HEAD
revision is being checked out instead of the actual remote branch. I
would expect the correct branch to be chosen regardless of where the
branches are pointing.
Tom
--
Tom Preston-Werner
github.com/mojombo
^ permalink raw reply
* Re: Local clone checks out wrong branch based on remote HEAD
From: Daniel Barkalow @ 2009-03-17 19:39 UTC (permalink / raw)
To: Tom Preston-Werner; +Cc: git
In-Reply-To: <b97024a40903171219k8841508p774d9dc4295a09bc@mail.gmail.com>
On Tue, 17 Mar 2009, Tom Preston-Werner wrote:
> I'm having some unexpected behavior when cloning a remote repo that
> has several branches at the same commit. On the remote side, the HEAD
> is 'trunk':
>
> git@remote ~/repositories/akincisor/site.git $ cat HEAD
> ref: refs/heads/trunk
>
> After cloning this with a standard `git clone`, the refs are:
>
> [11:48][tom@solid:~/dev/sandbox/site(release)]$ git branch -r -v
> origin/HEAD a52528a Fixed some routing problems
> origin/release a52528a Fixed some routing problems
> origin/trunk a52528a Fixed some routing problems
>
> And the checked out branch is 'release' instead of 'trunk' as I would expect:
>
> [11:48][tom@solid:~/dev/sandbox/site(release)]$ git branch
> * release
>
> I'm guessing that the first branch that matches the remote HEAD
> revision is being checked out instead of the actual remote branch. I
> would expect the correct branch to be chosen regardless of where the
> branches are pointing.
Unfortunately, the current protocol version just sends:
a52528a HEAD
a52528a refs/heads/release
a52528a refs/heads/trunk
It doesn't transmit the fact that HEAD is a pointer to anything, or what
it's a pointer to. One thing you can do is just change your local repo to
point origin/HEAD where you want, and check out what you want; the
defaults are just to get you started. Another thing is that it will guess
"master" if there is one. I think there's also been discussion of a
protocol extension to transmit the information, although I don't know
where that ended up. (The protocol-agnostic transport infrastructure can
represent the information, but doesn't receive it for the normal protocol)
-Daniel
*This .sig left intentionally blank*
^ permalink raw reply
* Re: [PATCH] contrib/difftool: use a separate config namespace for difftool commands
From: Markus Heidelberg @ 2009-03-17 19:54 UTC (permalink / raw)
To: David Aguilar; +Cc: Jay Soffian, Junio C Hamano, git
In-Reply-To: <20090310070122.GB4523@gmail.com>
David Aguilar, 10.03.2009:
> On 0, Jay Soffian <jaysoffian@gmail.com> wrote:
> > On Mon, Mar 9, 2009 at 5:12 AM, David Aguilar <davvid@gmail.com> wrote:
> > > contrib/difftool/git-difftool | 6 +++---
> >
> > Aside, (for Junio I guess...), what's the reason this command is in
> > contrib, and by what criteria might it graduate to being installed
> > with the rest of the git commands?
> >
> > j.
>
> My thoughts (also for Junio, I guess..):
>
> If y'all feel that it can live with the rest of the git
> commands then that would be great =)
I'd like to see it as a general git tool, too.
Maybe it can even share some common functionality with git-mergetool.
Markus
^ permalink raw reply
* Re: [PATCH] disable post-checkout test on Cygwin
From: Alex Riesen @ 2009-03-17 20:28 UTC (permalink / raw)
To: Johannes Sixt; +Cc: Junio C Hamano, Jeff King, layer, git
In-Reply-To: <49BFD6DD.1010800@viscovery.net>
Johannes Sixt, Tue, Mar 17, 2009 17:59:09 +0100:
> Junio C Hamano schrieb:
> > Alex Riesen <raa.lkml@gmail.com> writes:
> >
> >> It is broken because of the tricks we have to play with
> >> lstat to get the bearable perfomance out of the call.
> >> Sadly, it disables access to Cygwin's executable attribute,
> >> which Windows filesystems do not have at all.
> >
> > Hmm, perhaps when checking hooks to see if they are executable, Cygwin
> > port should avoid using the "tricks"? Compared to paths inside the
> > worktree the number of hooks is a lot smaller, no?
>
> Hmm. Nowadays, we run hooks through run_hook() in run_command.c. It uses
The problem is that copy_templates_1 does an lstat on the files in
templates directory and gets 0666 mode (regular file, non-exec) for
executable file under current Cygwin port. The st_mode of that lstat
is passed to copy_file mentioned, which is useless now as we use the
Win32 version of lstat, which doesn't do x-bit.
> access(..., X_OK), not lstat(). We don't play games with access(), do we?
>
access(..., X_OK) will return -1.
^ permalink raw reply
* Re: [PATCH] disable post-checkout test on Cygwin
From: Alex Riesen @ 2009-03-17 20:34 UTC (permalink / raw)
To: Junio C Hamano; +Cc: Jeff King, layer, git
In-Reply-To: <7vprggqeh2.fsf@gitster.siamese.dyndns.org>
Junio C Hamano, Tue, Mar 17, 2009 17:52:09 +0100:
> Alex Riesen <raa.lkml@gmail.com> writes:
>
> > It is broken because of the tricks we have to play with
> > lstat to get the bearable perfomance out of the call.
> > Sadly, it disables access to Cygwin's executable attribute,
> > which Windows filesystems do not have at all.
>
> Hmm, perhaps when checking hooks to see if they are executable, Cygwin
> port should avoid using the "tricks"? Compared to paths inside the
> worktree the number of hooks is a lot smaller, no?
Yes, the damn thing is just hard to disable without ifdef in
builtin-db.c or builtin-clone.c
^ permalink raw reply
* Re: git repack: --depth=100000 causing larger not smaler pack file?
From: Nicolas Pitre @ 2009-03-17 20:38 UTC (permalink / raw)
To: Kjetil Barvik; +Cc: git
In-Reply-To: <867i2ot1fu.fsf@broadpark.no>
On Tue, 17 Mar 2009, Kjetil Barvik wrote:
> aloha!
>
> Yesterday I run the following command on the updated GIT respository:
>
> git repack -adf --window=250000 --depth=100000
>
> After 280 minutes or so it finished, but the strange thing was that
> the resulting pack-file was larger than before. I had expected that
> it should be smaler, or at least the same size as before.
>
> kjetil git (my_next)$ ls -l .git/objects/pack/*
> -r-------- 1 kjetil kjetil 2757280 2009-03-16 15:18 .git/objects/pack/pack-c5f15d5c48d6b3902a49046d7e8a8d717e167051.idx
> -r-------- 1 kjetil kjetil 19961120 2009-03-16 15:18 .git/objects/pack/pack-c5f15d5c48d6b3902a49046d7e8a8d717e167051.pack
>
> Before I started the pack file was around 19 250 000 bytes, and was
> the result of the following commands:
>
> 1) git repack -adf --window=250000 --depth=20000
> - not completly sure about the --window number here
> - the resulting pack file was a litle less than 19 100 000
>
> 2) 'git fetch' to get the latest GIT patches
>
> 3) since 'git fetch' always make an extra new "smal" pack file, I run
> the command 'git repack -ad --window=40000 --depth=10000' to be
> able to get one singel pack file of 19 250 000 bytes or so.
>
> I can think of one thing which is spesial with the "--depth=100000"
> number, and that is that it is now larger than the total number of
> objects in the pack, which is around 96000 to 97000, or so.
No, the depth should have zero negative influence on the pack size.
For tight compression, the larger the better. What this will impact
though is runtime access to the pack data afterward. The deeper a
given object is, the slower its access will be. But since the object
recency order tend to put newer objects at the top of a delta chain,
this should impact older objects more than recent ones.
> I have run 'git fsck --strict --full' on the pack with no resulting
> error/debug output or change in the file size.
There shouldn't be any.
> Any help on how to debug this?
I doubt there is anything to debug. In this case the window size is
used to evaluate a threshold slope for matching objects in the delta
search. What we want is a broader delta tree more than a deep one in
order to have more deltas with a lower depth limit. Therefore a size
threshold is applied, based on the object distance in the delta search
window (see commit c83f032e and the other ones referenced therein).
By providing a big window value, the threshold slope becomes rather flat
and ineffective, and this changes the delta match outcome. While delta
selection is based on the uncompressed delta result, the compressed size
of different deltas with the same size may vary. I suspect you might
have been unlucky in that regard and this could explain the negative
effect on the pack size.
Nicolas
^ permalink raw reply
* Re: [PATCH] disable post-checkout test on Cygwin
From: Junio C Hamano @ 2009-03-17 20:42 UTC (permalink / raw)
To: Alex Riesen; +Cc: Johannes Sixt, Jeff King, layer, git
In-Reply-To: <20090317202818.GA13458@blimp.localdomain>
Alex Riesen <raa.lkml@gmail.com> writes:
> Johannes Sixt, Tue, Mar 17, 2009 17:59:09 +0100:
>> Junio C Hamano schrieb:
>> > Alex Riesen <raa.lkml@gmail.com> writes:
>> >
>> >> It is broken because of the tricks we have to play with
>> >> lstat to get the bearable perfomance out of the call.
>> >> Sadly, it disables access to Cygwin's executable attribute,
>> >> which Windows filesystems do not have at all.
>> >
>> > Hmm, perhaps when checking hooks to see if they are executable, Cygwin
>> > port should avoid using the "tricks"? Compared to paths inside the
>> > worktree the number of hooks is a lot smaller, no?
>>
>> Hmm. Nowadays, we run hooks through run_hook() in run_command.c. It uses
>
> The problem is that copy_templates_1 does an lstat on the files in
> templates directory and gets 0666 mode (regular file, non-exec) for
> executable file under current Cygwin port. The st_mode of that lstat
> is passed to copy_file mentioned, which is useless now as we use the
> Win32 version of lstat, which doesn't do x-bit.
Ahhh.
I do not mind the patch as a band-aid to make the testsuite pass, so I'll
apply your patch as-is. Thanks.
But isn't this something shops that do deploy Cygwin version of git want
to see fixed, so that they can have a site-wide policy implemented in the
hooks copied from templates? I think we could pass mode 0 to copy_files()
and have the function special case it (and allow a platform specific
copy_files() implementated by Cygwin). lstat() in the copy_templates_1()
codepath is primarily done to see if we need to descend into a directory
or symlink() and our use of st.st_mode to pass to copy_files() is a no
cost side effect on platforms with x-bit support.
>> access(..., X_OK), not lstat(). We don't play games with access(), do we?
>
> access(..., X_OK) will return -1.
That codepath would also need to be fixed if Cygwin wants to use hooks, I
would guess.
^ permalink raw reply
* [PATCH] git-gui: Fix merge conflict display error when filename contains spaces
From: Jens Lehmann @ 2009-03-17 20:56 UTC (permalink / raw)
To: git
From f548fd124ad3790b6ce3f30989fc3ed06c58b3dd Mon Sep 17 00:00:00 2001
From: Jens Lehmann <Jens.Lehmann@web.de>
Date: Tue, 17 Mar 2009 20:06:12 +0100
Subject: [PATCH] git-gui: Fix merge conflict display error when filename contains spaces
When a merge conflict occurs in a file with spaces in the filename, git-gui showed wrongly "LOCAL: deleted".
Signed-off-by: Jens Lehmann <Jens.Lehmann@web.de>
---
To reproduce the error with git 1.6.2.1.136.g8e24, i used the following commands:
mkdir spaces
cd spaces/
git init
echo "a" >file\ with\ spaces
git add file\ with\ spaces
git commit -m a .
git checkout -b b
echo "b" >file\ with\ spaces
git commit -m b .
git checkout master
echo "c" >file\ with\ spaces
git commit -m c .
git merge b
git gui
git gui doesn't show the conflict markers as it should, displaying "LOCAL: deleted" (but my old git-gui from 1.5.3.3 works fine).
Jens
git-gui/lib/mergetool.tcl | 2 +-
1 files changed, 1 insertions(+), 1 deletions(-)
diff --git a/git-gui/lib/mergetool.tcl b/git-gui/lib/mergetool.tcl
index eb2b4b5..3e1b42b 100644
--- a/git-gui/lib/mergetool.tcl
+++ b/git-gui/lib/mergetool.tcl
@@ -88,7 +88,7 @@ proc merge_load_stages {path cont} {
set merge_stages(3) {}
set merge_stages_buf {}
- set merge_stages_fd [eval git_read ls-files -u -z -- $path]
+ set merge_stages_fd [eval git_read ls-files -u -z -- {$path}]
fconfigure $merge_stages_fd -blocking 0 -translation binary -encoding binary
fileevent $merge_stages_fd readable [list read_merge_stages $merge_stages_fd $cont]
--
1.5.3.3
____________________________________________________________________
Psssst! Schon vom neuen WEB.DE MultiMessenger gehört?
Der kann`s mit allen: http://www.produkte.web.de/messenger/?did=3123
^ permalink raw reply related
* push.default, was Re: What's cooking in git.git (Mar 2009, #04; Sat, 14)
From: Nanako Shiraishi @ 2009-03-17 21:30 UTC (permalink / raw)
To: Johannes Schindelin; +Cc: git, Junio C Hamano
In-Reply-To: <alpine.DEB.1.00.0903171125420.6393@intel-tinevez-2-302>
Quoting Johannes Schindelin <Johannes.Schindelin@gmx.de>:
> On Sat, 14 Mar 2009, Junio C Hamano wrote:
>
>> * fg/push-default (Wed Mar 11 23:01:45 2009 +0100) 1 commit
>> - New config push.default to decide default behavior for push
>>
>> Replaced the old series with the first step to allow a smooth
>> transition. Some might argue that this should not give any warning but
>> just give users this new configuration to play with first, and after we
>> know we are going to switch default some day, start the warning.
>
> IIRC Steffen posted a patch series earlier, where he initialized
> remote.origin.push upon clone (I am not sure if he provided a
> corresponding patch for checkout --track), but personally, I think that
> would be nicer than having a push.default.
Isn't recent trend to avoid such inconsistency between behavior in an existing repository and behavior in a newly created repository? For example, Jeff calls such inconsistency in
http://thread.gmane.org/gmane.comp.version-control.git/100339/focus=100433
as "this breaks in my repo, but when I make a test repo it works". Junio even called it 'madness' (^_^;)
--
Nanako Shiraishi
http://ivory.ap.teacup.com/nanako3/
^ permalink raw reply
* Re: fetch and pull
From: Nanako Shiraishi @ 2009-03-17 21:31 UTC (permalink / raw)
To: John Dlugosz; +Cc: git, Junio C Hamano
In-Reply-To: <450196A1AAAE4B42A00A8B27A59278E70A3FC0A5@EXCHANGE.trad.tradestation.com>
Quoting John Dlugosz <JDlugosz@TradeStation.com>:
> My concern is that you establish your working state based on the local 'master', only to immediately change it again when the pull updates master. But that's the way it's supposed to work?
>
> I think the documentation for git-pull might also be garbled from text being of different eras. "Normally the branch merged is the HEAD of the remote"? That will be basically random since the last thing the upstream repo user did will control what his HEAD is.
That's how it's supposed to work, and the documentation isn't from a different era, either. Majority of users clone from a central repository and keep pulling to update their clones, and in that kind of setting, HEAD will never change. A HEAD in a bare repository tells people which branch is the primary branch of the project.
I think you are confused because you are thinking that it's typical to pull from a live repository that has a working tree somebody else uses to grow his history, and you are correct that you can't predict which branch HEAD points at at any given moment. But that isn't how a typical workflow uses pull and push between repositories.
--
Nanako Shiraishi
http://ivory.ap.teacup.com/nanako3/
^ 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