Jan PeŇ°ta <jan.pe...@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.
--
To unsubscribe from this list: send the line "unsubscribe git" in
the body of a message to majord...@vger.kernel.org
More majordomo info at  http://vger.kernel.org/majordomo-info.html

Reply via email to