mercurial-scm/hg: comparison mercurial/merge.py

equal deleted inserted replaced

-:346af7687c6f
+:89a2afe31e82
 abortconflicts.add(f)
 else:
 if config == b'warn':
 warnconflicts.add(f)
 mresult.addfile(
-f, mergestatemod.ACTION_GET, (fl2, True), b'remote created',
+f,
+mergestatemod.ACTION_GET,
+(fl2, True),
+b'remote created',
 )
 for f in sorted(abortconflicts):
 warn = repo.ui.warn
 if f in pathconflicts:
 if not branchmerge:
 for f in wctx.removed():
 if f not in mctx:
 mresult.addfile(
-f, mergestatemod.ACTION_FORGET, None, b"forget removed",
+f,
+mergestatemod.ACTION_FORGET,
+None,
+b"forget removed",
 )
 def _checkcollision(repo, wmf, mresult):
 """
 _(b'conflict in file \'%s\' is outside narrow clone') % f
 )
 class mergeresult(object):
-'''An object representing result of merging manifests.
+"""An object representing result of merging manifests.
 It has information about what actions need to be performed on dirstate
-mapping of divergent renames and other such cases.'''
+mapping of divergent renames and other such cases."""
 def __init__(self):
 """
 filemapping: dict of filename as keys and action related info as values
 diverge: mapping of source name -> list of dest name for
 def updatevalues(self, diverge, renamedelete):
 self._diverge = diverge
 self._renamedelete = renamedelete
 def addfile(self, filename, action, data, message):
-""" adds a new file to the mergeresult object
+"""adds a new file to the mergeresult object
 filename: file which we are adding
 action: one of mergestatemod.ACTION_*
 data: a tuple of information like fctx and ctx related to this merge
 message: a message about the merge
 self._filemapping[filename] = (action, data, message)
 self._actionmapping[action][filename] = (data, message)
 def getfile(self, filename, default_return=None):
-""" returns (action, args, msg) about this file
+"""returns (action, args, msg) about this file
-returns default_return if the file is not present """
+returns default_return if the file is not present"""
 if filename in self._filemapping:
 return self._filemapping[filename]
 return default_return
 def files(self, actions=None):
-""" returns files on which provided action needs to perfromed
+"""returns files on which provided action needs to perfromed
 If actions is None, all files are returned
 """
 # TODO: think whether we should return renamedelete and
 # diverge filenames also
 for a in actions:
 for f in self._actionmapping[a]:
 yield f
 def removefile(self, filename):
-""" removes a file from the mergeresult object as the file might
+"""removes a file from the mergeresult object as the file might
-not merging anymore """
+not merging anymore"""
 action, data, message = self._filemapping[filename]
 del self._filemapping[filename]
 del self._actionmapping[action][filename]
 def getactions(self, actions, sort=False):
-""" get list of files which are marked with these actions
+"""get list of files which are marked with these actions
 if sort is true, files for each action is sorted and then added
 Returns a list of tuple of form (filename, data, message)
 """
 for a in actions:
 self._actionmapping[a]
 ):
 yield f, args, msg
 def len(self, actions=None):
-""" returns number of files which needs actions
+"""returns number of files which needs actions
 if actions is passed, total of number of files in that action
-only is returned """
+only is returned"""
 if actions is None:
 return len(self._filemapping)
 return sum(len(self._actionmapping[a]) for a in actions)
 else:
 for key, val in pycompat.iteritems(self._filemapping):
 yield key, val
 def addcommitinfo(self, filename, key, value):
-""" adds key-value information about filename which will be required
+"""adds key-value information about filename which will be required
-while committing this merge """
+while committing this merge"""
 self._commitinfo[filename][key] = value
 @property
 def diverge(self):
 return self._diverge
 def commitinfo(self):
 return self._commitinfo
 @property
 def actionsdict(self):
-""" returns a dictionary of actions to be perfomed with action as key
+"""returns a dictionary of actions to be perfomed with action as key
-and a list of files and related arguments as values """
+and a list of files and related arguments as values"""
 res = collections.defaultdict(list)
 for a, d in pycompat.iteritems(self._actionmapping):
 for f, (args, msg) in pycompat.iteritems(d):
 res[a].append((f, args, msg))
 return res
 self._actionmapping = collections.defaultdict(dict)
 for f, (act, data, msg) in pycompat.iteritems(self._filemapping):
 self._actionmapping[act][f] = data, msg
 def hasconflicts(self):
-""" tells whether this merge resulted in some actions which can
+"""tells whether this merge resulted in some actions which can
-result in conflicts or not """
+result in conflicts or not"""
 for a in self._actionmapping.keys():
 if (
 a
 not in (
 mergestatemod.ACTION_GET,
 a = ma[f]
 fla = ma.flags(f)
 nol = b'l' not in fl1 + fl2 + fla
 if n2 == a and fl2 == fla:
 mresult.addfile(
-f, mergestatemod.ACTION_KEEP, (), b'remote unchanged',
+f,
+mergestatemod.ACTION_KEEP,
+(),
+b'remote unchanged',
 )
 elif n1 == a and fl1 == fla:  # local unchanged - use remote
 if n1 == n2:  # optimization: keep local content
 mresult.addfile(
 f,
 )
 elif n1 == addednodeid:
 # This file was locally added. We should forget it instead of
 # deleting it.
 mresult.addfile(
-f, mergestatemod.ACTION_FORGET, None, b'remote deleted',
+f,
+mergestatemod.ACTION_FORGET,
+None,
+b'remote deleted',
 )
 else:
 mresult.addfile(
-f, mergestatemod.ACTION_REMOVE, None, b'other deleted',
+f,
+mergestatemod.ACTION_REMOVE,
+None,
+b'other deleted',
 )
 if branchmerge:
 # the file must be absent after merging,
 # howeber the user might make
 # the file reappear using revert and if they does,
 return mresult
 def _resolvetrivial(repo, wctx, mctx, ancestor, mresult):
 """Resolves false conflicts where the nodeid changed but the content
 remained the same."""
 # We force a copy of actions.items() because we're going to mutate
 # actions as we resolve trivial conflicts.
 for f in list(mresult.files((mergestatemod.ACTION_CHANGED_DELETED,))):
 if f in ancestor and not wctx[f].cmp(ancestor[f]):
 # local did change but ended up with same content
 )
 prefetch = scmutil.prefetchfiles
 matchfiles = scmutil.matchfiles
 prefetch(
-repo, [(ctx.rev(), matchfiles(repo, files),)],
+repo,
+[
+(
+ctx.rev(),
+matchfiles(repo, files),
+)
+],
 )
 @attr.s(frozen=True)
 class updateresult(object):
 or self.unresolvedcount
 )
 def applyupdates(
-repo, mresult, wctx, mctx, overwrite, wantfiledata, labels=None,
+repo,
+mresult,
+wctx,
+mctx,
+overwrite,
+wantfiledata,
+labels=None,
 ):
 """apply the merge action list to the working directory
 mresult is a mergeresult object representing result of the merge
 wctx is the working copy context
 from . import dirstate
 if dirstate.rustmod is not None:
 # When using rust status, fsmonitor becomes necessary at higher sizes
 fsmonitorthreshold = repo.ui.configint(
-b'fsmonitor', b'warn_update_file_count_rust',
+b'fsmonitor',
+b'warn_update_file_count_rust',
 )
 try:
 # avoid cycle: extensions -> cmdutil -> merge
 from . import extensions
 )
 % prompts,
 0,
 ):
 mresult.addfile(
-f, mergestatemod.ACTION_REMOVE, None, b'prompt delete',
+f,
+mergestatemod.ACTION_REMOVE,
+None,
+b'prompt delete',
 )
 elif f in p1:
 mresult.addfile(
 f,
 mergestatemod.ACTION_ADD_MODIFIED,
 None,
 b'prompt keep',
 )
 else:
 mresult.addfile(
-f, mergestatemod.ACTION_ADD, None, b'prompt keep',
+f,
+mergestatemod.ACTION_ADD,
+None,
+b'prompt keep',
 )
 elif m == mergestatemod.ACTION_DELETED_CHANGED:
 f1, f2, fa, move, anc = args
 flags = p2[f2].flags()
 if (
 repo, mresult.len((mergestatemod.ACTION_GET,)), p1.node()
 )
 wantfiledata = updatedirstate and not branchmerge
 stats, getfiledata = applyupdates(
-repo, mresult, wc, p2, overwrite, wantfiledata, labels=labels,
+repo,
+mresult,
+wc,
+p2,
+overwrite,
+wantfiledata,
+labels=labels,
 )
 if updatedirstate:
 with repo.dirstate.parentchange():
 repo.setparents(fp1, fp2)

changeset 45942	89a2afe31e82
parent 45940	10dbc80d4be7
child 46361	dfca84970da8
child 46692	39f23d20ea47