1 # Copyright (C) 2007 Brendan Cully <brendan@kublai.com>

     2 # Published under the GNU GPL

     3 

     4 '''

     5 imerge - interactive merge

     6 '''

     7 

     8 from mercurial.i18n import _

     9 from mercurial.node import *

    10 from mercurial import commands, cmdutil, hg, merge, util

    11 import os, tarfile

    12 

    13 class InvalidStateFileException(Exception): pass

    14 

    15 class ImergeStateFile(object):

    16     def __init__(self, im):

    17         self.im = im

    18 

    19     def save(self, dest):

    20         tf = tarfile.open(dest, 'w:gz')

    21 

    22         st = os.path.join(self.im.path, 'status')

    23         tf.add(st, os.path.join('.hg', 'imerge', 'status'))

    24 

    25         for f in self.im.resolved:

    26             abssrc = self.im.repo.wjoin(f)

    27             tf.add(abssrc, f)

    28 

    29         tf.close()

    30 

    31     def load(self, source):

    32         wlock = self.im.repo.wlock()

    33         lock = self.im.repo.lock()

    34 

    35         tf = tarfile.open(source, 'r')

    36         contents = tf.getnames()

    37         statusfile = os.path.join('.hg', 'imerge', 'status')

    38         if statusfile not in contents:

    39             raise InvalidStateFileException('no status file')

    40 

    41         tf.extract(statusfile, self.im.repo.root)

    42         self.im.load()

    43         p1 = self.im.parents[0].node()

    44         p2 = self.im.parents[1].node()

    45         if self.im.repo.dirstate.parents()[0] != p1:

    46             hg.clean(self.im.repo, self.im.parents[0].node())

    47         self.im.start(p2)

    48         tf.extractall(self.im.repo.root)

    49         self.im.load()

    50 

    51 class Imerge(object):

    52     def __init__(self, ui, repo):

    53         self.ui = ui

    54         self.repo = repo

    55 

    56         self.path = repo.join('imerge')

    57         self.opener = util.opener(self.path)

    58 

    59         self.parents = [self.repo.changectx(n)

    60                         for n in self.repo.dirstate.parents()]

    61         self.conflicts = {}

    62         self.resolved = []

    63 

    64     def merging(self):

    65         return self.parents[1].node() != nullid

    66 

    67     def load(self):

    68         # status format. \0-delimited file, fields are

    69         # p1, p2, conflict count, conflict filenames, resolved filenames

    70         # conflict filenames are pairs of localname, remotename

    71 

    72         statusfile = self.opener('status')

    73 

    74         status = statusfile.read().split('\0')

    75         if len(status) < 3:

    76             raise util.Abort('invalid imerge status file')

    77 

    78         try:

    79             self.parents = [self.repo.changectx(n) for n in status[:2]]

    80         except LookupError:

    81             raise util.Abort('merge parent %s not in repository' % short(p))

    82 

    83         status = status[2:]

    84         conflicts = int(status.pop(0)) * 2

    85         self.resolved = status[conflicts:]

    86         for i in xrange(0, conflicts, 2):

    87             self.conflicts[status[i]] = status[i+1]

    88 

    89     def save(self):

    90         lock = self.repo.lock()

    91 

    92         if not os.path.isdir(self.path):

    93             os.mkdir(self.path)

    94         fd = self.opener('status', 'wb')

    95 

    96         out = [hex(n.node()) for n in self.parents]

    97         out.append(str(len(self.conflicts)))

    98         for f in sorted(self.conflicts):

    99             out.append(f)

   100             out.append(self.conflicts[f])

   101         out.extend(self.resolved)

   102 

   103         fd.write('\0'.join(out))

   104 

   105     def remaining(self):

   106         return [f for f in self.conflicts if f not in self.resolved]

   107 

   108     def filemerge(self, fn):

   109         wlock = self.repo.wlock()

   110 

   111         fo = self.conflicts[fn]

   112         return merge.filemerge(self.repo, fn, fo, self.parents[0],

   113                                self.parents[1])

   114 

   115     def start(self, rev=None):

   116         _filemerge = merge.filemerge

   117         def filemerge(repo, fw, fo, wctx, mctx):

   118             self.conflicts[fw] = fo

   119 

   120         merge.filemerge = filemerge

   121         commands.merge(self.ui, self.repo, rev=rev)

   122         merge.filemerge = _filemerge

   123 

   124         self.parents = [self.repo.changectx(n)

   125                         for n in self.repo.dirstate.parents()]

   126         self.save()

   127 

   128     def resume(self):

   129         self.load()

   130 

   131         dp = self.repo.dirstate.parents()

   132         if self.parents[0].node() != dp[0] or self.parents[1].node() != dp[1]:

   133             raise util.Abort('imerge state does not match working directory')

   134 

   135     def status(self):

   136         self.ui.write('merging %s and %s\n' % \

   137                       (short(self.parents[0].node()),

   138                        short(self.parents[1].node())))

   139 

   140         if self.resolved:

   141             self.ui.write('resolved:\n')

   142             for fn in self.resolved:

   143                 self.ui.write('  %s\n' % fn)

   144         remaining = [f for f in self.conflicts if f not in self.resolved]

   145         if remaining:

   146             self.ui.write('remaining:\n')

   147             for fn in remaining:

   148                 fo = self.conflicts[fn]

   149                 if fn == fo:

   150                     self.ui.write('  %s\n' % (fn,))

   151                 else:

   152                     self.ui.write('  %s (%s)\n' % (fn, fo))

   153         else:

   154             self.ui.write('all conflicts resolved\n')

   155 

   156     def next(self):

   157         remaining = self.remaining()

   158         return remaining and remaining[0]

   159 

   160     def resolve(self, files):

   161         resolved = dict.fromkeys(self.resolved)

   162         for fn in files:

   163             if fn not in self.conflicts:

   164                 raise util.Abort('%s is not in the merge set' % fn)

   165             resolved[fn] = True

   166         self.resolved = sorted(resolved)

   167         self.save()

   168         return 0

   169 

   170     def unresolve(self, files):

   171         resolved = dict.fromkeys(self.resolved)

   172         for fn in files:

   173             if fn not in resolved:

   174                 raise util.Abort('%s is not resolved' % fn)

   175             del resolved[fn]

   176         self.resolved = sorted(resolved)

   177         self.save()

   178         return 0

   179 

   180     def pickle(self, dest):

   181         '''write current merge state to file to be resumed elsewhere'''

   182         state = ImergeStateFile(self)

   183         return state.save(dest)

   184 

   185     def unpickle(self, source):

   186         '''read merge state from file'''

   187         state = ImergeStateFile(self)

   188         return state.load(source)

   189 

   190 def load(im, source):

   191     if im.merging():

   192         raise util.Abort('there is already a merge in progress '

   193                          '(update -C <rev> to abort it)' )

   194     m, a, r, d =  im.repo.status()[:4]

   195     if m or a or r or d:

   196         raise util.Abort('working directory has uncommitted changes')

   197 

   198     rc = im.unpickle(source)

   199     if not rc:

   200         im.status()

   201     return rc

   202 

   203 def merge_(im, filename=None):

   204     if not filename:

   205         filename = im.next()

   206         if not filename:

   207             im.ui.write('all conflicts resolved\n')

   208             return 0

   209 

   210     rc = im.filemerge(filename)

   211     if not rc:

   212         im.resolve([filename])

   213         if not im.next():

   214             im.ui.write('all conflicts resolved\n')

   215             return 0

   216     return rc

   217 

   218 def next(im):

   219     n = im.next()

   220     if n:

   221         im.ui.write('%s\n' % n)

   222     else:

   223         im.ui.write('all conflicts resolved\n')

   224     return 0

   225 

   226 def resolve(im, *files):

   227     if not files:

   228         raise util.Abort('resolve requires at least one filename')

   229     return im.resolve(files)

   230 

   231 def save(im, dest):

   232     return im.pickle(dest)

   233 

   234 def status(im):

   235     im.status()

   236     return 0

   237 

   238 def unresolve(im, *files):

   239     if not files:

   240         raise util.Abort('unresolve requires at least one filename')

   241     return im.unresolve(files)

   242 

   243 subcmdtable = {

   244     'load': load,

   245     'merge': merge_,

   246     'next': next,

   247     'resolve': resolve,

   248     'save': save,

   249     'status': status,

   250     'unresolve': unresolve

   251 }

   252 

   253 def dispatch(im, args, opts):

   254     def complete(s, choices):

   255         candidates = []

   256         for choice in choices:

   257             if choice.startswith(s):

   258                 candidates.append(choice)

   259         return candidates

   260 

   261     c, args = args[0], args[1:]

   262     cmd = complete(c, subcmdtable.keys())

   263     if not cmd:

   264         raise cmdutil.UnknownCommand('imerge ' + c)

   265     if len(cmd) > 1:

   266         raise cmdutil.AmbiguousCommand('imerge ' + c, sorted(cmd))

   267     cmd = cmd[0]

   268 

   269     func = subcmdtable[cmd]

   270     try:

   271         return func(im, *args)

   272     except TypeError:

   273         raise cmdutil.ParseError('imerge', '%s: invalid arguments' % cmd)

   274 

   275 def imerge(ui, repo, *args, **opts):

   276     '''interactive merge

   277 

   278     imerge lets you split a merge into pieces. When you start a merge

   279     with imerge, the names of all files with conflicts are recorded.

   280     You can then merge any of these files, and if the merge is

   281     successful, they will be marked as resolved. When all files are

   282     resolved, the merge is complete.

   283 

   284     If no merge is in progress, hg imerge [rev] will merge the working

   285     directory with rev (defaulting to the other head if the repository

   286     only has two heads). You may also resume a saved merge with

   287     hg imerge load <file>.

   288 

   289     If a merge is in progress, hg imerge will default to merging the

   290     next unresolved file.

   291 

   292     The following subcommands are available:

   293 

   294     status:

   295       show the current state of the merge

   296     next:

   297       show the next unresolved file merge

   298     merge [<file>]:

   299       merge <file>. If the file merge is successful, the file will be

   300       recorded as resolved. If no file is given, the next unresolved

   301       file will be merged.

   302     resolve <file>...:

   303       mark files as successfully merged

   304     unresolve <file>...:

   305       mark files as requiring merging.

   306     save <file>:

   307       save the state of the merge to a file to be resumed elsewhere

   308     load <file>:

   309       load the state of the merge from a file created by save

   310     '''

   311 

   312     im = Imerge(ui, repo)

   313 

   314     if im.merging():

   315         im.resume()

   316     else:

   317         rev = opts.get('rev')

   318         if rev and args:

   319             raise util.Abort('please specify just one revision')

   320         

   321         if len(args) == 2 and args[0] == 'load':

   322             pass

   323         else:

   324             if args:

   325                 rev = args[0]

   326             im.start(rev=rev)

   327             args = ['status']

   328 

   329     if not args:

   330         args = ['merge']

   331 

   332     return dispatch(im, args, opts)

   333 

   334 cmdtable = {

   335     '^imerge':

   336     (imerge,

   337      [('r', 'rev', '', _('revision to merge'))], 'hg imerge [command]')

   338 }