mdw@git.distorted.org.uk Git - stgit/blob - stgit/commands/sync.py

   1 __copyright__ = """
   2 Copyright (C) 2006, Catalin Marinas <catalin.marinas@gmail.com>
   3
   4 This program is free software; you can redistribute it and/or modify
   5 it under the terms of the GNU General Public License version 2 as
   6 published by the Free Software Foundation.
   7
   8 This program is distributed in the hope that it will be useful,
   9 but WITHOUT ANY WARRANTY; without even the implied warranty of
  10 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11 GNU General Public License for more details.
  12
  13 You should have received a copy of the GNU General Public License
  14 along with this program; if not, write to the Free Software
  15 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  16 """
  17
  18 import sys, os
  19 from optparse import OptionParser, make_option
  20
  21 import stgit.commands.common
  22 from stgit.commands.common import *
  23 from stgit.utils import *
  24 from stgit import stack, git
  25
  26
  27 help = 'synchronise patches with a branch or a series'
  28 usage = """%prog [options] [<patch1>] [<patch2>] [<patch3>..<patch4>]
  29
  30 For each of the specified patches perform a three-way merge with the
  31 same patch in the specified branch or series. The command can be used
  32 for keeping patches on several branches in sync. Note that the
  33 operation may fail for some patches because of conflicts. The patches
  34 in the series must apply cleanly.
  35
  36 The sync operation can be reverted for individual patches with --undo."""
  37
  38 options = [make_option('-a', '--all',
  39                        help = 'synchronise all the patches',
  40                        action = 'store_true'),
  41            make_option('-B', '--ref-branch',
  42                        help = 'syncronise patches with BRANCH'),
  43            make_option('-s', '--series',
  44                        help = 'syncronise patches with SERIES'),
  45            make_option('--undo',
  46                        help = 'undo the synchronisation of the current patch',
  47                        action = 'store_true')]
  48
  49 def __check_all():
  50     check_local_changes()
  51     check_conflicts()
  52     check_head_top_equal()
  53
  54 def __branch_merge_patch(remote_series, pname):
  55     """Merge a patch from a remote branch into the current tree.
  56     """
  57     patch = remote_series.get_patch(pname)
  58     git.merge(patch.get_bottom(), git.get_head(), patch.get_top())
  59
  60 def __series_merge_patch(base, patchdir, pname):
  61     """Merge a patch file with the given StGIT patch.
  62     """
  63     patchfile = os.path.join(patchdir, pname)
  64     git.apply_patch(filename = patchfile, base = base)
  65
  66 def func(parser, options, args):
  67     """Synchronise a range of patches
  68     """
  69     global crt_series
  70
  71     if options.undo:
  72         if options.ref_branch or options.series:
  73             raise CmdException, \
  74                   '--undo cannot be specified with --ref-branch or --series'
  75         __check_all()
  76
  77         out.start('Undoing the sync of "%s"' % crt_series.get_current())
  78         crt_series.undo_refresh()
  79         git.reset()
  80         out.done()
  81         return
  82
  83     if options.ref_branch:
  84         # the main function already made crt_series to be the remote
  85         # branch
  86         remote_series = stack.Series(options.ref_branch)
  87         if options.ref_branch == crt_series.get_name():
  88             raise CmdException, 'Cannot synchronise with the current branch'
  89         remote_patches = remote_series.get_applied()
  90
  91         # the merge function merge_patch(patch, pname)
  92         merge_patch = lambda patch, pname: \
  93                       __branch_merge_patch(remote_series, pname)
  94     elif options.series:
  95         patchdir = os.path.dirname(options.series)
  96
  97         remote_patches = []
  98         f = file(options.series)
  99         for line in f:
 100             p = re.sub('#.*$', '', line).strip()
 101             if not p:
 102                 continue
 103             remote_patches.append(p)
 104         f.close()
 105
 106         # the merge function merge_patch(patch, pname)
 107         merge_patch = lambda patch, pname: \
 108                       __series_merge_patch(patch.get_bottom(), patchdir, pname)
 109     else:
 110         raise CmdException, 'No remote branch or series specified'
 111
 112     applied = crt_series.get_applied()
 113
 114     if options.all:
 115         patches = applied
 116     elif len(args) != 0:
 117         patches = parse_patches(args, applied, ordered = True)
 118     elif applied:
 119         patches = [crt_series.get_current()]
 120     else:
 121         parser.error('no patches applied')
 122
 123     if not patches:
 124         raise CmdException, 'No patches to synchronise'
 125
 126     __check_all()
 127
 128     # only keep the patches to be synchronised
 129     sync_patches = [p for p in patches if p in remote_patches]
 130     if not sync_patches:
 131         raise CmdException, 'No common patches to be synchronised'
 132
 133     # pop to the one before the first patch to be synchronised
 134     popped = applied[applied.index(sync_patches[0]) + 1:]
 135     if popped:
 136         pop_patches(popped[::-1])
 137
 138     for p in sync_patches:
 139         if p in popped:
 140             # push to this patch
 141             idx = popped.index(p) + 1
 142             push_patches(popped[:idx])
 143             del popped[:idx]
 144
 145         # the actual sync
 146         out.start('Synchronising "%s"' % p)
 147
 148         patch = crt_series.get_patch(p)
 149         bottom = patch.get_bottom()
 150         top = patch.get_top()
 151
 152         # reset the patch backup information. That's needed in case we
 153         # undo the sync but there were no changes made
 154         patch.set_bottom(bottom, backup = True)
 155         patch.set_top(top, backup = True)
 156
 157         # the actual merging (either from a branch or an external file)
 158         merge_patch(patch, p)
 159
 160         if git.local_changes(verbose = False):
 161             # index (cache) already updated by the git merge. The
 162             # backup information was already reset above
 163             crt_series.refresh_patch(cache_update = False, backup = False,
 164                                      log = 'sync')
 165             out.done('updated')
 166         else:
 167             out.done()
 168
 169     # push the remaining patches
 170     if popped:
 171         push_patches(popped)