mercurial/merge.py
changeset 3314 ecc1bf27378c
parent 3313 f009a6f12a59
child 3315 e8be5942335d
equal deleted inserted replaced
3313:f009a6f12a59 3314:ecc1bf27378c
   208             # are files different?
   208             # are files different?
   209             if n != m2[f]:
   209             if n != m2[f]:
   210                 a = ma.get(f, nullid)
   210                 a = ma.get(f, nullid)
   211                 # are both different from the ancestor?
   211                 # are both different from the ancestor?
   212                 if not overwrite and n != a and m2[f] != a:
   212                 if not overwrite and n != a and m2[f] != a:
   213                     act("versions differ", "m", f, fmerge(f))
   213                     act("versions differ", "m", f, f, f, fmerge(f), False)
   214                 # are we clobbering?
   214                 # are we clobbering?
   215                 # is remote's version newer?
   215                 # is remote's version newer?
   216                 # or are we going back in time and clean?
   216                 # or are we going back in time and clean?
   217                 elif overwrite or m2[f] != a or (backwards and not n[20:]):
   217                 elif overwrite or m2[f] != a or (backwards and not n[20:]):
   218                     act("remote is newer", "g", f, m2.execf(f))
   218                     act("remote is newer", "g", f, m2.execf(f))
   224                 if overwrite or fmerge(f) != m1.execf(f):
   224                 if overwrite or fmerge(f) != m1.execf(f):
   225                     act("update permissions", "e", f, m2.execf(f))
   225                     act("update permissions", "e", f, m2.execf(f))
   226         elif f in copy:
   226         elif f in copy:
   227             f2 = copy[f]
   227             f2 = copy[f]
   228             if f in ma: # case 3,20 A/B/A
   228             if f in ma: # case 3,20 A/B/A
   229                 act("remote moved", "c",
   229                 act("remote moved", "m", f, f2, f2, fmerge(f, f2, f), True)
   230                     f, f2, f2, fmerge(f, f2, f), True)
       
   231             else:
   230             else:
   232                 if f2 in m1: # case 2 A,B/B/B
   231                 if f2 in m1: # case 2 A,B/B/B
   233                     act("local copied", "c",
   232                     act("local copied", "m",
   234                         f, f2, f, fmerge(f, f2, f2), False)
   233                         f, f2, f, fmerge(f, f2, f2), False)
   235                 else: # case 4,21 A/B/B
   234                 else: # case 4,21 A/B/B
   236                     act("local moved", "c",
   235                     act("local moved", "m",
   237                         f, f2, f, fmerge(f, f2, f2), False)
   236                         f, f2, f, fmerge(f, f2, f2), False)
   238         elif f in ma:
   237         elif f in ma:
   239             if n != ma[f] and not overwrite:
   238             if n != ma[f] and not overwrite:
   240                 if repo.ui.prompt(
   239                 if repo.ui.prompt(
   241                     (_(" local changed %s which remote deleted\n") % f) +
   240                     (_(" local changed %s which remote deleted\n") % f) +
   256         if f in copy:
   255         if f in copy:
   257             f2 = copy[f]
   256             f2 = copy[f]
   258             if f2 not in m2: # already seen
   257             if f2 not in m2: # already seen
   259                 continue
   258                 continue
   260             # rename case 1, A/A,B/A
   259             # rename case 1, A/A,B/A
   261             act("remote copied", "c", f2, f, f, fmerge(f2, f, f2), False)
   260             act("remote copied", "m", f2, f, f, fmerge(f2, f, f2), False)
   262         elif f in ma:
   261         elif f in ma:
   263             if overwrite or backwards:
   262             if overwrite or backwards:
   264                 act("recreating", "g", f, m2.execf(f))
   263                 act("recreating", "g", f, m2.execf(f))
   265             elif n != ma[f]:
   264             elif n != ma[f]:
   266                 if repo.ui.prompt(
   265                 if repo.ui.prompt(
   287             except OSError, inst:
   286             except OSError, inst:
   288                 if inst.errno != errno.ENOENT:
   287                 if inst.errno != errno.ENOENT:
   289                     repo.ui.warn(_("update failed to remove %s: %s!\n") %
   288                     repo.ui.warn(_("update failed to remove %s: %s!\n") %
   290                                  (f, inst.strerror))
   289                                  (f, inst.strerror))
   291             removed +=1
   290             removed +=1
   292         elif m == "c": # copy
   291         elif m == "m": # merge
   293             f2, fd, flag, move = a[2:]
   292             f2, fd, flag, move = a[2:]
   294             repo.ui.status(_("merging %s and %s to %s\n") % (f, f2, fd))
   293             if f != f2:
       
   294                 repo.ui.status(_("merging %s and %s to %s\n") % (f, f2, fd))
       
   295             else:
       
   296                 repo.ui.status(_("merging %s\n") % f)
   295             if filemerge(repo, f, f2, fd, wctx, mctx, move):
   297             if filemerge(repo, f, f2, fd, wctx, mctx, move):
   296                 unresolved += 1
   298                 unresolved += 1
   297             util.set_exec(repo.wjoin(fd), flag)
   299             util.set_exec(repo.wjoin(fd), flag)
   298             merged += 1
       
   299         elif m == "m": # merge
       
   300             flag = a[2]
       
   301             repo.ui.status(_("merging %s\n") % f)
       
   302             if filemerge(repo, f, f, f, wctx, mctx, False):
       
   303                 unresolved += 1
       
   304             util.set_exec(repo.wjoin(f), flag)
       
   305             merged += 1
   300             merged += 1
   306         elif m == "g": # get
   301         elif m == "g": # get
   307             flag = a[2]
   302             flag = a[2]
   308             repo.ui.note(_("getting %s\n") % f)
   303             repo.ui.note(_("getting %s\n") % f)
   309             t = mctx.filectx(f).data()
   304             t = mctx.filectx(f).data()
   330             if branchmerge:
   325             if branchmerge:
   331                 repo.dirstate.update([f], 'n', st_mtime=-1)
   326                 repo.dirstate.update([f], 'n', st_mtime=-1)
   332             else:
   327             else:
   333                 repo.dirstate.update([f], 'n')
   328                 repo.dirstate.update([f], 'n')
   334         elif m == "m": # merge
   329         elif m == "m": # merge
   335             flag = a[2]
   330             f2, fd, flag, move = a[2:]
   336             if branchmerge:
   331             if branchmerge:
   337                 # We've done a branch merge, mark this file as merged
   332                 # We've done a branch merge, mark this file as merged
   338                 # so that we properly record the merger later
   333                 # so that we properly record the merger later
   339                 repo.dirstate.update([f], 'm')
   334                 repo.dirstate.update([fd], 'm')
   340             else:
   335             else:
   341                 # We've update-merged a locally modified file, so
   336                 # We've update-merged a locally modified file, so
   342                 # we set the dirstate to emulate a normal checkout
   337                 # we set the dirstate to emulate a normal checkout
   343                 # of that file some time in the past. Thus our
   338                 # of that file some time in the past. Thus our
   344                 # merge will appear as a normal local file
   339                 # merge will appear as a normal local file
   345                 # modification.
   340                 # modification.
   346                 fl = repo.file(f)
       
   347                 f_len = mctx.filectx(f).size()
       
   348                 repo.dirstate.update([f], 'n', st_size=f_len, st_mtime=-1)
       
   349         elif m == "c": # copy
       
   350             f2, fd, flag, move = a[2:]
       
   351             if branchmerge:
       
   352                 # We've done a branch merge, mark this file as merged
       
   353                 # so that we properly record the merger later
       
   354                 repo.dirstate.update([fd], 'm')
       
   355             else:
       
   356                 # We've update-merged a locally modified file, so
       
   357                 # we set the dirstate to emulate a normal checkout
       
   358                 # of that file some time in the past. Thus our
       
   359                 # merge will appear as a normal local file
       
   360                 # modification.
       
   361                 fl = repo.file(f)
       
   362                 f_len = mctx.filectx(f).size()
   341                 f_len = mctx.filectx(f).size()
   363                 repo.dirstate.update([fd], 'n', st_size=f_len, st_mtime=-1)
   342                 repo.dirstate.update([fd], 'n', st_size=f_len, st_mtime=-1)
   364             if move:
   343             if f != f2: # copy/rename
   365                 repo.dirstate.update([f], 'r')
   344                 if move:
   366             if f != fd:
   345                     repo.dirstate.update([f], 'r')
   367                 repo.dirstate.copy(f, fd)
   346                 if f != fd:
   368             else:
   347                     repo.dirstate.copy(f, fd)
   369                 repo.dirstate.copy(f2, fd)
   348                 else:
       
   349                     repo.dirstate.copy(f2, fd)
   370 
   350 
   371 def update(repo, node, branchmerge=False, force=False, partial=None,
   351 def update(repo, node, branchmerge=False, force=False, partial=None,
   372            wlock=None, show_stats=True, remind=True):
   352            wlock=None, show_stats=True, remind=True):
   373 
   353 
   374     overwrite = force and not branchmerge
   354     overwrite = force and not branchmerge