hgext/imerge.py
changeset 5064 420e1166a876
parent 5063 86327d13d916
parent 5056 34a54cc5df1b
child 5065 12930b97a729
equal deleted inserted replaced
5063:86327d13d916 5064:420e1166a876
    42         tf.extract(statusfile, self.im.repo.root)
    42         tf.extract(statusfile, self.im.repo.root)
    43         p1, p2 = self.im.load()
    43         p1, p2 = self.im.load()
    44         if self.im.repo.dirstate.parents()[0] != p1.node():
    44         if self.im.repo.dirstate.parents()[0] != p1.node():
    45             hg.clean(self.im.repo, p1.node())
    45             hg.clean(self.im.repo, p1.node())
    46         self.im.start(p2.node())
    46         self.im.start(p2.node())
    47         tf.extractall(self.im.repo.root)
    47         for tarinfo in tf:
       
    48             tf.extract(tarinfo, self.im.repo.root)
    48         self.im.load()
    49         self.im.load()
    49 
    50 
    50 class Imerge(object):
    51 class Imerge(object):
    51     def __init__(self, ui, repo):
    52     def __init__(self, ui, repo):
    52         self.ui = ui
    53         self.ui = ui
    89     def save(self):
    90     def save(self):
    90         lock = self.repo.lock()
    91         lock = self.repo.lock()
    91 
    92 
    92         if not os.path.isdir(self.path):
    93         if not os.path.isdir(self.path):
    93             os.mkdir(self.path)
    94             os.mkdir(self.path)
    94         fd = self.opener('status', 'wb')
    95         statusfile = self.opener('status', 'wb')
    95 
    96 
    96         out = [hex(n.node()) for n in self.wctx.parents()]
    97         out = [hex(n.node()) for n in self.wctx.parents()]
    97         out.append(str(len(self.conflicts)))
    98         out.append(str(len(self.conflicts)))
    98         for f in sorted(self.conflicts):
    99         conflicts = self.conflicts.items()
    99             out.append(f)
   100         conflicts.sort()
   100             out.extend(self.conflicts[f])
   101         for fw, fd_fo in conflicts:
       
   102             out.append(fw)
       
   103             out.extend(fd_fo)
   101         out.extend(self.resolved)
   104         out.extend(self.resolved)
   102 
   105 
   103         fd.write('\0'.join(out))
   106         statusfile.write('\0'.join(out))
   104 
   107 
   105     def remaining(self):
   108     def remaining(self):
   106         return [f for f in self.conflicts if f not in self.resolved]
   109         return [f for f in self.conflicts if f not in self.resolved]
   107 
   110 
   108     def filemerge(self, fn):
   111     def filemerge(self, fn):
   161         resolved = dict.fromkeys(self.resolved)
   164         resolved = dict.fromkeys(self.resolved)
   162         for fn in files:
   165         for fn in files:
   163             if fn not in self.conflicts:
   166             if fn not in self.conflicts:
   164                 raise util.Abort('%s is not in the merge set' % fn)
   167                 raise util.Abort('%s is not in the merge set' % fn)
   165             resolved[fn] = True
   168             resolved[fn] = True
   166         self.resolved = sorted(resolved)
   169         self.resolved = resolved.keys()
       
   170         self.resolved.sort()
   167         self.save()
   171         self.save()
   168         return 0
   172         return 0
   169 
   173 
   170     def unresolve(self, files):
   174     def unresolve(self, files):
   171         resolved = dict.fromkeys(self.resolved)
   175         resolved = dict.fromkeys(self.resolved)
   172         for fn in files:
   176         for fn in files:
   173             if fn not in resolved:
   177             if fn not in resolved:
   174                 raise util.Abort('%s is not resolved' % fn)
   178                 raise util.Abort('%s is not resolved' % fn)
   175             del resolved[fn]
   179             del resolved[fn]
   176         self.resolved = sorted(resolved)
   180         self.resolved = resolved.keys()
       
   181         self.resolved.sort()
   177         self.save()
   182         self.save()
   178         return 0
   183         return 0
   179 
   184 
   180     def pickle(self, dest):
   185     def pickle(self, dest):
   181         '''write current merge state to file to be resumed elsewhere'''
   186         '''write current merge state to file to be resumed elsewhere'''
   261     c, args = args[0], args[1:]
   266     c, args = args[0], args[1:]
   262     cmd = complete(c, subcmdtable.keys())
   267     cmd = complete(c, subcmdtable.keys())
   263     if not cmd:
   268     if not cmd:
   264         raise cmdutil.UnknownCommand('imerge ' + c)
   269         raise cmdutil.UnknownCommand('imerge ' + c)
   265     if len(cmd) > 1:
   270     if len(cmd) > 1:
   266         raise cmdutil.AmbiguousCommand('imerge ' + c, sorted(cmd))
   271         cmd.sort()
       
   272         raise cmdutil.AmbiguousCommand('imerge ' + c, cmd)
   267     cmd = cmd[0]
   273     cmd = cmd[0]
   268 
   274 
   269     func = subcmdtable[cmd]
   275     func = subcmdtable[cmd]
   270     try:
   276     try:
   271         return func(im, *args)
   277         return func(im, *args)