Updating not actual branch

Updating not actual branch

[Jan Pešta]

Hi All,

I have a question if there is a posibility tu update a branch which is not
actual working copy.

I have following situation:

A - B - C - I - J                       master
               \ - D - E - F               feature 1
                                 \ G - H     feature 2 (working copy)

I would like tu update whole tree with latest changes in master

A - B - C - I - J                                              master
                           \ - D* - E* - F*                  feature 1
                                                   \ G* - H*     feature 2
(working copy)


Is there some way how to do it without swithing to each branch and update
them manually?

Thanks,
Jan

Re: Updating not actual branch

[Konstantin Khomoutov]

On Tue, 12 Mar 2013 14:22:00 +0100
Jan Pešta <jan.pesta@certicon.cz> wrote:

> I have a question if there is a posibility tu update a branch which
> is not actual working copy.
> 
> I have following situation:
> 
> A - B - C - I - J                       master
>                \ - D - E - F               feature 1
>                                  \ G - H     feature 2 (working copy)
> 
> I would like tu update whole tree with latest changes in master
> 
> A - B - C - I - J                                              master
>                            \ - D* - E* - F*                  feature 1
>                                                    \ G* - H*
> feature 2 (working copy)
> 
> 
> Is there some way how to do it without swithing to each branch and
> update them manually?

It's partially possible to do: you are able to forcibly fetch a remote
object into any local branch provided it's not checked out.  Hence, in
your case you'll be able to update any branch excapt for "feature 2".

To do this, you could use the explicit refspec when fetching, like this:

$ git fetch origin +src1:dst1 '+blooper 1:feature 1'

(Consult the `git fetch` manual for more info on using refspecs.)

One possible downside is that I'm not sure this approach would play
nicely with remote branches, if you have any.  I mean, direct fetching
into local branches will unlikely to update their matching "upstream"
remote branches.

So supposedly a better way to go would be to write a script which would
go like this:
1) Do a simple one-argument `git fetch <remotename>` to fetch from
   the specified remote and update its remote branches.
2) Run `git for-each-ref`, and for each local branch found first check
   whether it's currently checked out (that is, HEAD points at it)
   and ignore the branch if it is; otherwise do `git update-ref`
   updating the branch pointer from its upstream branch -- referring to
   that using the <ref>@{upstream} syntax.
   (Consult the gitrevisions manual for more info on this syntax.)

Re: Updating not actual branch

[Junio C Hamano]

Jan Pešta <jan.pesta@certicon.cz> writes:

> I have following situation:
>
> A - B - C - I - J                       master
>                \ - D - E - F               feature 1
>                                  \ G - H     feature 2 (working copy)
>
> I would like tu update whole tree with latest changes in master
>
> A - B - C - I - J                                              master
>                            \ - D* - E* - F*                  feature 1
>                                                    \ G* - H*     feature 2
> (working copy)
>
>
> Is there some way how to do it without swithing to each branch and update
> them manually?

With these asterisks I would assume that you are rebasing feature #n
on top of updated master.  As rebasing requires you to have a
working tree, so that you can resolve potential conflicts between
your work and work done on the updated upstream, you fundamentally
would need to check out the branch you work on.

In the case you depicted where feature-1 is a complete subset of
feature-2, you are rebasing both of them, and you do not end up in
a nasty conflict, you could start from this state:

    A---B---C master
             \
              D---E---F feature-1
                       \
                        G---H feature-2

update the master from the upstream:

    $ git checkout master ; git pull

    A---B---C---I---J master
             \
              D---E---F feature-1
                       \
                        G---H feature-2

rebase feature-2 on top of the updated master:

    $ git rebase master feature-2

                                G'--H' feature-2
                               /
                      D'--E'--F'
                     /
    A---B---C---I---J master
             \
              D---E---F feature-1
                       \
                        G---H

and finally repoint feature-1 to its updated version:

    $ git branch -f feature-1 F'

                                G'--H' feature-2
                               /
                      D'--E'--F' feature-1
                     /
    A---B---C---I---J master
             \
              D---E---F
                       \
                        G---H

Depending on the interaction between commits C..J and C..F, your
rebasing of feature-2 may end up not losing any of D', E' or F'.
Imagine the case where J was committed on the upstream by applying
the same patch as the original E; E' will become redundant and the
result of your "git rebase master feature-2" may look like this
instead:

                            G'--H' feature-2
                           /
                      D'--F'
                     /
    A---B---C---I---J master
             \
              D---E---F feature-1
                       \
                        G---H

Or J could remove something E depends on, in which case you may have
to add it back with a new commit X when you rebase feature-2, like
so:

                                    G'--H' feature-2
                                   /
                      D'--X---E'--F'
                     /
    A---B---C---I---J master
             \
              D---E---F feature-1
                       \
                        G---H

Because you cannot mechanically decide where the tip of updated
feature-1 has to be, you would need to use your brain to decide
where to repoint the tip of feature-1 in the last step.