<?xml version="1.0" encoding="UTF-8"?>
<rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns="http://purl.org/rss/1.0/" xmlns:taxo="http://purl.org/rss/1.0/modules/taxonomy/" xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:syn="http://purl.org/rss/1.0/modules/syndication/" xmlns:admin="http://webns.net/mvcb/">
  <channel about="http://permalink.gmane.org/gmane.comp.version-control.git">
    <title>gmane.comp.version-control.git</title>
    <link>http://permalink.gmane.org/gmane.comp.version-control.git</link>
    <description/>
    <syn:updatePeriod>hourly</syn:updatePeriod>
    <syn:updateFrequency>1</syn:updateFrequency>
    <syn:updateBase>1901-01-01T00:00+00:00</syn:updateBase>
    <items>
      <rdf:Seq>
        <rdf:li rdf:resource="http://permalink.gmane.org/gmane.comp.version-control.git/95097"/>
        <rdf:li rdf:resource="http://permalink.gmane.org/gmane.comp.version-control.git/95096"/>
        <rdf:li rdf:resource="http://permalink.gmane.org/gmane.comp.version-control.git/95095"/>
        <rdf:li rdf:resource="http://permalink.gmane.org/gmane.comp.version-control.git/95094"/>
        <rdf:li rdf:resource="http://permalink.gmane.org/gmane.comp.version-control.git/95093"/>
        <rdf:li rdf:resource="http://permalink.gmane.org/gmane.comp.version-control.git/95092"/>
        <rdf:li rdf:resource="http://permalink.gmane.org/gmane.comp.version-control.git/95091"/>
        <rdf:li rdf:resource="http://permalink.gmane.org/gmane.comp.version-control.git/95090"/>
        <rdf:li rdf:resource="http://permalink.gmane.org/gmane.comp.version-control.git/95089"/>
        <rdf:li rdf:resource="http://permalink.gmane.org/gmane.comp.version-control.git/95088"/>
        <rdf:li rdf:resource="http://permalink.gmane.org/gmane.comp.version-control.git/95087"/>
        <rdf:li rdf:resource="http://permalink.gmane.org/gmane.comp.version-control.git/95086"/>
        <rdf:li rdf:resource="http://permalink.gmane.org/gmane.comp.version-control.git/95085"/>
        <rdf:li rdf:resource="http://permalink.gmane.org/gmane.comp.version-control.git/95084"/>
        <rdf:li rdf:resource="http://permalink.gmane.org/gmane.comp.version-control.git/95083"/>
        <rdf:li rdf:resource="http://permalink.gmane.org/gmane.comp.version-control.git/95082"/>
        <rdf:li rdf:resource="http://permalink.gmane.org/gmane.comp.version-control.git/95081"/>
        <rdf:li rdf:resource="http://permalink.gmane.org/gmane.comp.version-control.git/95080"/>
        <rdf:li rdf:resource="http://permalink.gmane.org/gmane.comp.version-control.git/95079"/>
        <rdf:li rdf:resource="http://permalink.gmane.org/gmane.comp.version-control.git/95078"/>
      </rdf:Seq>
    </items>
    <image rdf:resource="http://gmane.org/img/gmane-25t.png"/>
    <textinput rdf:resource=""/>
  </channel>
  <image rdf:about="http://gmane.org/img/gmane-25t.png">
    <title>Gmane</title>
    <url>http://gmane.org/img/gmane-25t.png</url>
    <link>http://gmane.org</link>
  </image>
  <item rdf:about="http://permalink.gmane.org/gmane.comp.version-control.git/95097">
    <title>Re: [ANNOUNCE] yap: Yet Another (Git) Porcelain</title>
    <link>http://permalink.gmane.org/gmane.comp.version-control.git/95097</link>
    <description>
That's an interesting idea and something I'd like to pursue.


I was not aware of that.  I'm not firmly attached to the name I've
chosen, but I would like the command to remain short (2-3 letters).
Maybe call it YAGP and use "yg" for the command?
</description>
    <dc:creator>Steven Walter</dc:creator>
    <dc:date>2008-09-06T20:04:06</dc:date>
  </item>
  <item rdf:about="http://permalink.gmane.org/gmane.comp.version-control.git/95096">
    <title>Extremely simple Vim interface for Git</title>
    <link>http://permalink.gmane.org/gmane.comp.version-control.git/95096</link>
    <description>Here's a very simple idea for using Git from Vim editor. Add these lines 
to your ~/.vimrc file:


    command! -complete=file -nargs=* Git   call s:RunShellCommand('git '.&lt;q-args&gt;)
    command! -complete=file -nargs=* Svn   call s:RunShellCommand('svn '.&lt;q-args&gt;)
    command! -complete=file -nargs=+ Shell call s:RunShellCommand(&lt;q-args&gt;)

    let $EDITOR = '/usr/bin/gvim --nofork'

    function! s:RunShellCommand(cmdline)
        botright new
        setlocal buftype=nofile bufhidden=wipe nobuflisted noswapfile
        setlocal nowrap
        call setline(1,a:cmdline)
        call setline(2,substitute(a:cmdline,'.','=','g'))
        execute 'silent 2read !'.escape(a:cmdline,'()%#')
        setlocal nomodifiable
        1
    endfunction


Now, command :Git works just like "git" from shell except that the 
output is displayed in a Vim scratch buffer/window. The buffer will be 
wiped out from memory when the window is closed. Filename completion and 
piping works. Examples:

    :Git diff --cached
    :Git he</description>
    <dc:creator>Teemu Likonen</dc:creator>
    <dc:date>2008-09-06T19:37:44</dc:date>
  </item>
  <item rdf:about="http://permalink.gmane.org/gmane.comp.version-control.git/95095">
    <title>Re: [JGIT PATCH] Expose the raw timezone offset from PersonIdent</title>
    <link>http://permalink.gmane.org/gmane.comp.version-control.git/95095</link>
    <description>
It isn't necessary from a performance perspective, but is required
to read the commit data exactly, but in parsed form.

What I'm doing at the application level is taking a RevCommit and
converting it into a different data structure (more specifically
a Google Protocol Buffer) that has all of the parts broken out.
It looks like this:

  message GitPerson {
    required string name = 1;
    required string email = 2;
    required int32 when = 3;
    required int32 tz = 4;
  }
  
  message GitCommit {
    required string id = 1;
    repeated string parent_id = 2;
    required GitPerson author = 3;
    optional GitPerson committer = 4;
    optional string message = 5;
  }

I'm later processing the GitPerson in Python and need to use the tz
to offset when to format a time for display.  If the author has a
"funny" offset in their commit our existing getTimeZone() method
can return null, which means I have to then lie and send 0 to the
Python code.  I'd rather send the exact offset.

</description>
    <dc:creator>Shawn O. Pearce</dc:creator>
    <dc:date>2008-09-06T19:27:27</dc:date>
  </item>
  <item rdf:about="http://permalink.gmane.org/gmane.comp.version-control.git/95094">
    <title>Re: Alternates and push</title>
    <link>http://permalink.gmane.org/gmane.comp.version-control.git/95094</link>
    <description>
github should do what repo.or.cz does:

ln -s .../linus.git/refs digispeaker.git/refs/forkee

That way the refs available in Linus' tree are also available
in your tree as Git will transparently follow the symlink.

However you have to be careful to make sure `git pack-refs` isn't
run with `--all --prune` as it will delete the refs from linus.git
when executed in digispeaker.git.  Fun times when I did that to my
own repository one day.  ;-)

Though we probably should fix Git to be somewhat smarter.  But
until that stable binary is available, the symlink trick above
is a good work around.

</description>
    <dc:creator>Shawn O. Pearce</dc:creator>
    <dc:date>2008-09-06T19:21:06</dc:date>
  </item>
  <item rdf:about="http://permalink.gmane.org/gmane.comp.version-control.git/95093">
    <title>Re: [ANNOUNCE] yap: Yet Another (Git) Porcelain</title>
    <link>http://permalink.gmane.org/gmane.comp.version-control.git/95093</link>
    <description>[Back on git mailing list]

On Sat, 6 Sep 2008, Steven Walter wrote:

I can understand this.  EasyGit is more about making git self
documenting than anything more, from what I understand.


As far as I know Pyrite is one-man work.  Why not to join efforts,
bringing those two projects together?  Both share the same language,
Python.


Thanks.


By the way, please take into account 
  http://en.wikipedia.org/wiki/Yap_(disambiguation)

Most commonly known YAP is I think Yet Another Previewer, which is
the name of the DVI viewer included on the widely used MiKTeX TeX
distribution for the Microsoft Windows platform,

YAGP, or YA(G)P, is I think free of such conotations.
</description>
    <dc:creator>Jakub Narebski</dc:creator>
    <dc:date>2008-09-06T19:01:26</dc:date>
  </item>
  <item rdf:about="http://permalink.gmane.org/gmane.comp.version-control.git/95092">
    <title>Re: [ANNOUNCE] yap: Yet Another (Git) Porcelain</title>
    <link>http://permalink.gmane.org/gmane.comp.version-control.git/95092</link>
    <description>
Nope, simple bug.  Everything should still work correctly, but the
output was a bit confusing.  I just pushed a fix.
</description>
    <dc:creator>Steven Walter</dc:creator>
    <dc:date>2008-09-06T18:45:59</dc:date>
  </item>
  <item rdf:about="http://permalink.gmane.org/gmane.comp.version-control.git/95091">
    <title>Re: [ANNOUNCE] yap: Yet Another (Git) Porcelain</title>
    <link>http://permalink.gmane.org/gmane.comp.version-control.git/95091</link>
    <description>

Hmm. Bug, or am I missing something fundamental?

  $ mkdir repo &amp;&amp; cd repo
  $ yap init
  Initialized empty Git repository in /home/peff/repo/.git/
  $ echo content &gt;file
  $ yap add file
  Current branch: master
  Files with staged changes:
          (none)
  Files with unstaged changes:
          file
  $ yap add file
  Current branch: master
  Files with staged changes:
          (none)
  Files with unstaged changes:
          file
          file
  $ yap add file
  Current branch: master
  Files with staged changes:
          (none)
  Files with unstaged changes:
          file
          file
          file

-Peff
</description>
    <dc:creator>Jeff King</dc:creator>
    <dc:date>2008-09-06T18:40:33</dc:date>
  </item>
  <item rdf:about="http://permalink.gmane.org/gmane.comp.version-control.git/95090">
    <title>Re: [ANNOUNCE] yap: Yet Another (Git) Porcelain</title>
    <link>http://permalink.gmane.org/gmane.comp.version-control.git/95090</link>
    <description>
Heh, that would help.

http://repo.or.cz/w/yap.git
</description>
    <dc:creator>Steven Walter</dc:creator>
    <dc:date>2008-09-06T18:33:21</dc:date>
  </item>
  <item rdf:about="http://permalink.gmane.org/gmane.comp.version-control.git/95089">
    <title>Re: Git Community Book</title>
    <link>http://permalink.gmane.org/gmane.comp.version-control.git/95089</link>
    <description>
Hello Scott!

Nice book, I just started reading it and I have a recommendation to
make, at "Chapter 4: Git Treeishes" you write

---------
http://book.git-scm.com/4_git_treeishes.html
Range

Finally, you can specify a range of commits with the range spec. This
will give you all the commits between 7b593b5 and 51bea1 (where 51bea1
is most recent), excluding 7b593b5 but including 51bea1:

7b593b5..51bea1

This will include every commit since 7b593b:

7b593b..
---------

This in not quite correct. "commits between A and B" cannot really
apply here. I believe that "commits reachable from B and not from A"
is more precise. Actually you are already using the "reachability"
explanation at the start of "Chapter 3: Basic usage".

This issue is also described at the rev-parse man page.

Apart from that, you could also include "a...b" syntax for completeness.

-christos
</description>
    <dc:creator>Christos Τrochalakis</dc:creator>
    <dc:date>2008-09-06T18:26:45</dc:date>
  </item>
  <item rdf:about="http://permalink.gmane.org/gmane.comp.version-control.git/95088">
    <title>Re: Alternates and push</title>
    <link>http://permalink.gmane.org/gmane.comp.version-control.git/95088</link>
    <description>
What happens if I set a remote in my github digispeaker repo pointing
to github's linus repo and the set a chron script to fetch it once a
day? The alternates link is still in place.

</description>
    <dc:creator>Jon Smirl</dc:creator>
    <dc:date>2008-09-06T18:24:59</dc:date>
  </item>
  <item rdf:about="http://permalink.gmane.org/gmane.comp.version-control.git/95087">
    <title>Re: [PATCH v4] for-each-ref: `:short` format for `refname`</title>
    <link>http://permalink.gmane.org/gmane.comp.version-control.git/95087</link>
    <description>Not exactly.

Short version:

To follow my above example, with dwim_ref() we would get this:

heads/xyzzy
tags/xyzzy

Long version:

Currently we consider only rules prior to the matched rule (the rule
which gives us the short name). That is, if any of these rules will
also resolve to a valid ref, the short name is  ambiguous, else its
unambiguous. If we would consider subsequent rules past the matched
one, we may find more valid refs for this short name. Because the
current rule would match first if we try to resolve the short name, we
don't have to check these rules. We get only a "ambiguous refs"
warning.

I have no opinion if we want this 'strict unambiguousness'.

Its more a leftover from the :strip version, where the pattern was the point of
interest.

I will look at this.



Bert
</description>
    <dc:creator>Bert Wesarg</dc:creator>
    <dc:date>2008-09-06T18:16:05</dc:date>
  </item>
  <item rdf:about="http://permalink.gmane.org/gmane.comp.version-control.git/95086">
    <title>Re: Git Community Book</title>
    <link>http://permalink.gmane.org/gmane.comp.version-control.git/95086</link>
    <description>Thanks a ton for this, I'll incorporate all of this.

On Fri, Sep 5, 2008 at 11:33 PM, Shawn O. Pearce &lt;spearce&lt; at &gt;spearce.org&gt; wrote:

Sorry, the markdown thingy is translating all the '\0's to '#body' for
some freaking reason unless I write it as '\\0'.  I'll fix this - it's
difficult for me to find these sometimes.  As for the rest of the ruby
stuff, I think I'll add some comments.


That is a good idea - I don't do it that way and I certainly will
change the implementation to do so and modify these docs to reflect
that advice.


Thanks for the clarification.  I write to loose objects first largely
because it's so much easier to do.  But also because I don't mmap
objects, so packfile access is not faster for implementations that
can't do that very well.  Also, I had originally meant "less expensive
to write", but I can see that is not clear.



Interesting.  This documentation is actually from the User Manual -
I'll update this chapter first and if it looks better, I'll submit a
patch to the UM, too.


Will </description>
    <dc:creator>Scott Chacon</dc:creator>
    <dc:date>2008-09-06T18:14:22</dc:date>
  </item>
  <item rdf:about="http://permalink.gmane.org/gmane.comp.version-control.git/95085">
    <title>Re: file deletion in index lost after checkout -b</title>
    <link>http://permalink.gmane.org/gmane.comp.version-control.git/95085</link>
    <description>

Thanks; I meant to say "please do not redirect", but you got what I wanted
to say correctly.


Both correct.  1. does not involve case *0*; 2. does not do two-tree
switch but internally uses three-tree switch and uses different codepath.
</description>
    <dc:creator>Junio C Hamano</dc:creator>
    <dc:date>2008-09-06T18:10:32</dc:date>
  </item>
  <item rdf:about="http://permalink.gmane.org/gmane.comp.version-control.git/95084">
    <title>Re: Alternates and push</title>
    <link>http://permalink.gmane.org/gmane.comp.version-control.git/95084</link>
    <description>

This comes from an early (mis)design of git.

Background.

 * A git repository and the object store it uses can be separate.  From
   the beginning, you can have a"objects/" directory (aka "object store")
   that is shared by more than one repositories.  There is no Porcelain
   level support to set up two repositories that physically share the same
   object store, but the result of "git init; rm -rf .git/objects; ln -s
   $other/.git/objects .git/objects" was supposed to work (and it still
   largely works, until you gc) in the original design.

   The alternate object store does not even have to be a git repository,
   which makes things worse.  You can have everybody pointing at
   /var/cache/objects, and /var/cache does not have to be a git repository
   (i.e. no var/cache/refs).

 * The existing alternates mechanism is not about alternate repositories.
   It is about alternate object stores.  That is why each line of this
   file points at "objects" directory elsewhere, not the ".git" directory
   th</description>
    <dc:creator>Junio C Hamano</dc:creator>
    <dc:date>2008-09-06T18:06:49</dc:date>
  </item>
  <item rdf:about="http://permalink.gmane.org/gmane.comp.version-control.git/95083">
    <title>Re: [ANNOUNCE] yap: Yet Another (Git) Porcelain</title>
    <link>http://permalink.gmane.org/gmane.comp.version-control.git/95083</link>
    <description>

Link?

-Peff
</description>
    <dc:creator>Jeff King</dc:creator>
    <dc:date>2008-09-06T17:39:25</dc:date>
  </item>
  <item rdf:about="http://permalink.gmane.org/gmane.comp.version-control.git/95082">
    <title>Re: file deletion in index lost after checkout -b</title>
    <link>http://permalink.gmane.org/gmane.comp.version-control.git/95082</link>
    <description>
I changed mutt to not use M-F-T with the git list at all. Hope this one
turns out better.


I have since found out that:

1. file deletions in the working directory but not in index would not be forgotten. That
makes "file deletions in index" case rather a corner one.

2. "checkout -b -m" would do the right thing.

Cheers.
</description>
    <dc:creator>Jing Xue</dc:creator>
    <dc:date>2008-09-06T17:11:08</dc:date>
  </item>
  <item rdf:about="http://permalink.gmane.org/gmane.comp.version-control.git/95081">
    <title>Re: [ANNOUNCE] yap: Yet Another (Git) Porcelain</title>
    <link>http://permalink.gmane.org/gmane.comp.version-control.git/95081</link>
    <description>

If you're interested in cross-platformness, you might want to be
aware that there is already at least another 'yap' in Windows:
MikTeX's DVI viewer (Yet Another Previewer). Just FYI.



This is an extremely interesting idea. I've always wondered myself
if it were possible to make git-svn operation more transparent,
although it has always been my understanding that the interface
difference might be substantially driven by robustness, especially
for 'roundtrip' operation, and by the fact that svn would not
really be suited for some of the operations that are common in git
workflow. It'll be interesting to see the level of transparency
that can be achieved without bringing down the svn server ;)

I think that the most complex situations arise from cloning svn
repositories that undergo heavy structure changes in their
history, moving from a structure where there was no
trunk/branches/tags because the project was just kept in the svn
root, to thetraditional trunk/branches/tags structure (I've come
across at lea</description>
    <dc:creator>Giuseppe Bilotta</dc:creator>
    <dc:date>2008-09-06T16:39:02</dc:date>
  </item>
  <item rdf:about="http://permalink.gmane.org/gmane.comp.version-control.git/95080">
    <title>[PATCH] builtin-merge: release the lockfile in try_merge_strategy()</title>
    <link>http://permalink.gmane.org/gmane.comp.version-control.git/95080</link>
    <description>Once we committed the locked index, we should release the lockfile. In
most cases this is done automatically when the process ends, but this is
not true in this case.

Signed-off-by: Miklos Vajna &lt;vmiklos&lt; at &gt;frugalware.org&gt;
---

On Sat, Sep 06, 2008 at 04:12:23AM +0200, Miklos Vajna &lt;vmiklos&lt; at &gt;frugalware.org&gt; wrote:

Here is - I think - the proper prefix.

 builtin-merge.c |    1 +
 1 files changed, 1 insertions(+), 0 deletions(-)

diff --git a/builtin-merge.c b/builtin-merge.c
index b857cf6..bb09e6f 100644
--- a/builtin-merge.c
+++ b/builtin-merge.c
&lt; at &gt;&lt; at &gt; -576,6 +576,7 &lt; at &gt;&lt; at &gt; static int try_merge_strategy(const char *strategy, struct commit_list *common,
 (write_cache(index_fd, active_cache, active_nr) ||
  commit_locked_index(lock)))
 die ("unable to write %s", get_index_file());
+rollback_lock_file(lock);
 return clean ? 0 : 1;
 } else {
 args = xmalloc((4 + commit_list_count(common) +
</description>
    <dc:creator>Miklos Vajna</dc:creator>
    <dc:date>2008-09-06T16:29:49</dc:date>
  </item>
  <item rdf:about="http://permalink.gmane.org/gmane.comp.version-control.git/95079">
    <title>Re: Alternates and push</title>
    <link>http://permalink.gmane.org/gmane.comp.version-control.git/95079</link>
    <description>
Long-standing mis-feature in git's logic in deciding what to push.
It's been reported a few times, but apparently it's hard to fix, or at
least it never hsa been fixed as far as I know.

I work around it by ssh'ing into master.kernel.org and doing a "git
branch -f origin &lt;commit-id-of-master-on-linus's-tree&gt;".  As long as
there is one branch which is up-to-date, git will avoid pushing a huge
number of objects to master.kernel.org.  Of course, this workaround
only works if you have shell access....

- Ted
</description>
    <dc:creator>Theodore Tso</dc:creator>
    <dc:date>2008-09-06T16:20:30</dc:date>
  </item>
  <item rdf:about="http://permalink.gmane.org/gmane.comp.version-control.git/95078">
    <title>[EGIT PATCH] Add an action to set quickdiff baseline to first parent of HEAD</title>
    <link>http://permalink.gmane.org/gmane.comp.version-control.git/95078</link>
    <description>This is useful when reviewing code.

Signed-off-by: Robin Rosenberg &lt;robin.rosenberg&lt; at &gt;dewire.com&gt;
---
 org.spearce.egit.ui/plugin.xml                     |    7 +++++
 .../actions/ResetQuickdiffBaselineAction.java      |    2 +-
 .../ResetQuickdiffBaselineHeadParentAction.java    |   24 ++++++++++++++++++++
 3 files changed, 32 insertions(+), 1 deletions(-)
 create mode 100644 org.spearce.egit.ui/src/org/spearce/egit/ui/internal/actions/ResetQuickdiffBaselineHeadParentAction.java

diff --git a/org.spearce.egit.ui/plugin.xml b/org.spearce.egit.ui/plugin.xml
index 55207eb..2472c9b 100644
--- a/org.spearce.egit.ui/plugin.xml
+++ b/org.spearce.egit.ui/plugin.xml
&lt; at &gt;&lt; at &gt; -150,6 +150,13 &lt; at &gt;&lt; at &gt;
        label="Reset quickdiff baseline to HEAD"
        menubarPath="additions"&gt;
  &lt;/action&gt;
+ &lt;action
+       class="org.spearce.egit.ui.internal.actions.ResetQuickdiffBaselineHeadParentAction"
+       enablesFor="*"
+       id="org.spearce.egit.ui.resetquickdiffheadparentbaseline"
+       label="Reset quickdiff baseline to </description>
    <dc:creator>Robin Rosenberg</dc:creator>
    <dc:date>2008-09-06T15:48:22</dc:date>
  </item>
  <item rdf:about="http://permalink.gmane.org/gmane.comp.version-control.git/95077">
    <title>Re: [ANNOUNCE] yap: Yet Another (Git) Porcelain</title>
    <link>http://permalink.gmane.org/gmane.comp.version-control.git/95077</link>
    <description>

A question, and a request.

First, a question: how your yap porcelain differs from efforts of
EasyGit (eg) and Pyrite?

And a request: could you add (short) information about your work to
Git Wiki: http://git.or.cz/gitwiki/InterfacesFrontendsAndTools,
of course in the "Version Control Interface layers" section? 

TIA.
</description>
    <dc:creator>Jakub Narebski</dc:creator>
    <dc:date>2008-09-06T15:36:40</dc:date>
  </item>
  <textinput about="http://search.gmane.org/?group=$group=gmane.comp.version-control.git">
    <title>Search Engine</title>
    <description>Search the mailing list at Gmane</description>
    <name>query</name>
    <link>http://search.gmane.org/?group=$group=gmane.comp.version-control.git</link>
  </textinput>
</rdf:RDF>
