mercurial/commands.py
changeset 44856 b7808443ed6a
parent 44851 708ad5cf5e5a
child 44865 233ee525dcef
equal deleted inserted replaced
44855:1d2d353e5c4a 44856:b7808443ed6a
    44     hbisect,
    44     hbisect,
    45     help,
    45     help,
    46     hg,
    46     hg,
    47     logcmdutil,
    47     logcmdutil,
    48     merge as mergemod,
    48     merge as mergemod,
       
    49     mergestate as mergestatemod,
    49     narrowspec,
    50     narrowspec,
    50     obsolete,
    51     obsolete,
    51     obsutil,
    52     obsutil,
    52     patch,
    53     patch,
    53     phases,
    54     phases,
  5936     uipathfn = scmutil.getuipathfn(repo)
  5937     uipathfn = scmutil.getuipathfn(repo)
  5937 
  5938 
  5938     if show:
  5939     if show:
  5939         ui.pager(b'resolve')
  5940         ui.pager(b'resolve')
  5940         fm = ui.formatter(b'resolve', opts)
  5941         fm = ui.formatter(b'resolve', opts)
  5941         ms = mergemod.mergestate.read(repo)
  5942         ms = mergestatemod.mergestate.read(repo)
  5942         wctx = repo[None]
  5943         wctx = repo[None]
  5943         m = scmutil.match(wctx, pats, opts)
  5944         m = scmutil.match(wctx, pats, opts)
  5944 
  5945 
  5945         # Labels and keys based on merge state.  Unresolved path conflicts show
  5946         # Labels and keys based on merge state.  Unresolved path conflicts show
  5946         # as 'P'.  Resolved path conflicts show as 'R', the same as normal
  5947         # as 'P'.  Resolved path conflicts show as 'R', the same as normal
  5947         # resolved conflicts.
  5948         # resolved conflicts.
  5948         mergestateinfo = {
  5949         mergestateinfo = {
  5949             mergemod.MERGE_RECORD_UNRESOLVED: (b'resolve.unresolved', b'U'),
  5950             mergestatemod.MERGE_RECORD_UNRESOLVED: (
  5950             mergemod.MERGE_RECORD_RESOLVED: (b'resolve.resolved', b'R'),
  5951                 b'resolve.unresolved',
  5951             mergemod.MERGE_RECORD_UNRESOLVED_PATH: (
  5952                 b'U',
       
  5953             ),
       
  5954             mergestatemod.MERGE_RECORD_RESOLVED: (b'resolve.resolved', b'R'),
       
  5955             mergestatemod.MERGE_RECORD_UNRESOLVED_PATH: (
  5952                 b'resolve.unresolved',
  5956                 b'resolve.unresolved',
  5953                 b'P',
  5957                 b'P',
  5954             ),
  5958             ),
  5955             mergemod.MERGE_RECORD_RESOLVED_PATH: (b'resolve.resolved', b'R'),
  5959             mergestatemod.MERGE_RECORD_RESOLVED_PATH: (
  5956             mergemod.MERGE_RECORD_DRIVER_RESOLVED: (
  5960                 b'resolve.resolved',
       
  5961                 b'R',
       
  5962             ),
       
  5963             mergestatemod.MERGE_RECORD_DRIVER_RESOLVED: (
  5957                 b'resolve.driverresolved',
  5964                 b'resolve.driverresolved',
  5958                 b'D',
  5965                 b'D',
  5959             ),
  5966             ),
  5960         }
  5967         }
  5961 
  5968 
  5962         for f in ms:
  5969         for f in ms:
  5963             if not m(f):
  5970             if not m(f):
  5964                 continue
  5971                 continue
  5965 
  5972 
  5966             if ms[f] == mergemod.MERGE_RECORD_MERGED_OTHER:
  5973             if ms[f] == mergestatemod.MERGE_RECORD_MERGED_OTHER:
  5967                 continue
  5974                 continue
  5968             label, key = mergestateinfo[ms[f]]
  5975             label, key = mergestateinfo[ms[f]]
  5969             fm.startitem()
  5976             fm.startitem()
  5970             fm.context(ctx=wctx)
  5977             fm.context(ctx=wctx)
  5971             fm.condwrite(not nostatus, b'mergestatus', b'%s ', key, label=label)
  5978             fm.condwrite(not nostatus, b'mergestatus', b'%s ', key, label=label)
  5973             fm.plain(b'%s\n' % uipathfn(f), label=label)
  5980             fm.plain(b'%s\n' % uipathfn(f), label=label)
  5974         fm.end()
  5981         fm.end()
  5975         return 0
  5982         return 0
  5976 
  5983 
  5977     with repo.wlock():
  5984     with repo.wlock():
  5978         ms = mergemod.mergestate.read(repo)
  5985         ms = mergestatemod.mergestate.read(repo)
  5979 
  5986 
  5980         if not (ms.active() or repo.dirstate.p2() != nullid):
  5987         if not (ms.active() or repo.dirstate.p2() != nullid):
  5981             raise error.Abort(
  5988             raise error.Abort(
  5982                 _(b'resolve command not applicable when not merging')
  5989                 _(b'resolve command not applicable when not merging')
  5983             )
  5990             )
  5984 
  5991 
  5985         wctx = repo[None]
  5992         wctx = repo[None]
  5986 
  5993 
  5987         if (
  5994         if (
  5988             ms.mergedriver
  5995             ms.mergedriver
  5989             and ms.mdstate() == mergemod.MERGE_DRIVER_STATE_UNMARKED
  5996             and ms.mdstate() == mergestatemod.MERGE_DRIVER_STATE_UNMARKED
  5990         ):
  5997         ):
  5991             proceed = mergemod.driverpreprocess(repo, ms, wctx)
  5998             proceed = mergemod.driverpreprocess(repo, ms, wctx)
  5992             ms.commit()
  5999             ms.commit()
  5993             # allow mark and unmark to go through
  6000             # allow mark and unmark to go through
  5994             if not mark and not unmark and not proceed:
  6001             if not mark and not unmark and not proceed:
  6010             if not m(f):
  6017             if not m(f):
  6011                 continue
  6018                 continue
  6012 
  6019 
  6013             didwork = True
  6020             didwork = True
  6014 
  6021 
  6015             if ms[f] == mergemod.MERGE_RECORD_MERGED_OTHER:
  6022             if ms[f] == mergestatemod.MERGE_RECORD_MERGED_OTHER:
  6016                 continue
  6023                 continue
  6017 
  6024 
  6018             # don't let driver-resolved files be marked, and run the conclude
  6025             # don't let driver-resolved files be marked, and run the conclude
  6019             # step if asked to resolve
  6026             # step if asked to resolve
  6020             if ms[f] == mergemod.MERGE_RECORD_DRIVER_RESOLVED:
  6027             if ms[f] == mergestatemod.MERGE_RECORD_DRIVER_RESOLVED:
  6021                 exact = m.exact(f)
  6028                 exact = m.exact(f)
  6022                 if mark:
  6029                 if mark:
  6023                     if exact:
  6030                     if exact:
  6024                         ui.warn(
  6031                         ui.warn(
  6025                             _(b'not marking %s as it is driver-resolved\n')
  6032                             _(b'not marking %s as it is driver-resolved\n')
  6035                     runconclude = True
  6042                     runconclude = True
  6036                 continue
  6043                 continue
  6037 
  6044 
  6038             # path conflicts must be resolved manually
  6045             # path conflicts must be resolved manually
  6039             if ms[f] in (
  6046             if ms[f] in (
  6040                 mergemod.MERGE_RECORD_UNRESOLVED_PATH,
  6047                 mergestatemod.MERGE_RECORD_UNRESOLVED_PATH,
  6041                 mergemod.MERGE_RECORD_RESOLVED_PATH,
  6048                 mergestatemod.MERGE_RECORD_RESOLVED_PATH,
  6042             ):
  6049             ):
  6043                 if mark:
  6050                 if mark:
  6044                     ms.mark(f, mergemod.MERGE_RECORD_RESOLVED_PATH)
  6051                     ms.mark(f, mergestatemod.MERGE_RECORD_RESOLVED_PATH)
  6045                 elif unmark:
  6052                 elif unmark:
  6046                     ms.mark(f, mergemod.MERGE_RECORD_UNRESOLVED_PATH)
  6053                     ms.mark(f, mergestatemod.MERGE_RECORD_UNRESOLVED_PATH)
  6047                 elif ms[f] == mergemod.MERGE_RECORD_UNRESOLVED_PATH:
  6054                 elif ms[f] == mergestatemod.MERGE_RECORD_UNRESOLVED_PATH:
  6048                     ui.warn(
  6055                     ui.warn(
  6049                         _(b'%s: path conflict must be resolved manually\n')
  6056                         _(b'%s: path conflict must be resolved manually\n')
  6050                         % uipathfn(f)
  6057                         % uipathfn(f)
  6051                     )
  6058                     )
  6052                 continue
  6059                 continue
  6054             if mark:
  6061             if mark:
  6055                 if markcheck:
  6062                 if markcheck:
  6056                     fdata = repo.wvfs.tryread(f)
  6063                     fdata = repo.wvfs.tryread(f)
  6057                     if (
  6064                     if (
  6058                         filemerge.hasconflictmarkers(fdata)
  6065                         filemerge.hasconflictmarkers(fdata)
  6059                         and ms[f] != mergemod.MERGE_RECORD_RESOLVED
  6066                         and ms[f] != mergestatemod.MERGE_RECORD_RESOLVED
  6060                     ):
  6067                     ):
  6061                         hasconflictmarkers.append(f)
  6068                         hasconflictmarkers.append(f)
  6062                 ms.mark(f, mergemod.MERGE_RECORD_RESOLVED)
  6069                 ms.mark(f, mergestatemod.MERGE_RECORD_RESOLVED)
  6063             elif unmark:
  6070             elif unmark:
  6064                 ms.mark(f, mergemod.MERGE_RECORD_UNRESOLVED)
  6071                 ms.mark(f, mergestatemod.MERGE_RECORD_UNRESOLVED)
  6065             else:
  6072             else:
  6066                 # backup pre-resolve (merge uses .orig for its own purposes)
  6073                 # backup pre-resolve (merge uses .orig for its own purposes)
  6067                 a = repo.wjoin(f)
  6074                 a = repo.wjoin(f)
  6068                 try:
  6075                 try:
  6069                     util.copyfile(a, a + b".resolve")
  6076                     util.copyfile(a, a + b".resolve")
  6940     parents = ctx.parents()
  6947     parents = ctx.parents()
  6941     pnode = parents[0].node()
  6948     pnode = parents[0].node()
  6942     marks = []
  6949     marks = []
  6943 
  6950 
  6944     try:
  6951     try:
  6945         ms = mergemod.mergestate.read(repo)
  6952         ms = mergestatemod.mergestate.read(repo)
  6946     except error.UnsupportedMergeRecords as e:
  6953     except error.UnsupportedMergeRecords as e:
  6947         s = b' '.join(e.recordtypes)
  6954         s = b' '.join(e.recordtypes)
  6948         ui.warn(
  6955         ui.warn(
  6949             _(b'warning: merge state has unsupported record types: %s\n') % s
  6956             _(b'warning: merge state has unsupported record types: %s\n') % s
  6950         )
  6957         )