| Alphare |
| hg-reviewers |
| Automatic diff as part of commit; lint not applicable. |
| Automatic diff as part of commit; unit tests not applicable. |
| Path | Packages | |||
|---|---|---|---|---|
| M | mercurial/filemerge.py (160 lines) |
| Status | Author | Revision | |
|---|---|---|---|
| Closed | martinvonz | ||
| Closed | martinvonz | ||
| Closed | martinvonz | ||
| Closed | martinvonz | ||
| Closed | martinvonz | ||
| Closed | martinvonz | ||
| Closed | martinvonz | ||
| Closed | martinvonz | ||
| Closed | martinvonz | ||
| Closed | martinvonz | ||
| Closed | martinvonz | ||
| Closed | martinvonz | ||
| Closed | martinvonz | ||
| Closed | martinvonz | ||
| Closed | martinvonz | ||
| Closed | martinvonz | ||
| Closed | martinvonz |
| style = _eoltype(data) | style = _eoltype(data) | ||||
| if style: | if style: | ||||
| newdata = data.replace(style, tostyle) | newdata = data.replace(style, tostyle) | ||||
| if newdata != data: | if newdata != data: | ||||
| util.writefile(file, newdata) | util.writefile(file, newdata) | ||||
| @internaltool(b'prompt', nomerge) | @internaltool(b'prompt', nomerge) | ||||
| def _iprompt(repo, mynode, fcd, fco, fca, toolconf, labels=None): | def _iprompt(repo, mynode, local, other, base, toolconf): | ||||
| """Asks the user which of the local `p1()` or the other `p2()` version to | """Asks the user which of the local `p1()` or the other `p2()` version to | ||||
| keep as the merged version.""" | keep as the merged version.""" | ||||
| ui = repo.ui | ui = repo.ui | ||||
| fd = fcd.path() | fd = local.fctx.path() | ||||
| uipathfn = scmutil.getuipathfn(repo) | uipathfn = scmutil.getuipathfn(repo) | ||||
| # Avoid prompting during an in-memory merge since it doesn't support merge | # Avoid prompting during an in-memory merge since it doesn't support merge | ||||
| # conflicts. | # conflicts. | ||||
| if fcd.changectx().isinmemory(): | if local.fctx.changectx().isinmemory(): | ||||
| raise error.InMemoryMergeConflictsError( | raise error.InMemoryMergeConflictsError( | ||||
| b'in-memory merge does not support file conflicts' | b'in-memory merge does not support file conflicts' | ||||
| ) | ) | ||||
| prompts = partextras(labels) | prompts = partextras([local.label, other.label]) | ||||
| prompts[b'fd'] = uipathfn(fd) | prompts[b'fd'] = uipathfn(fd) | ||||
| try: | try: | ||||
| if fco.isabsent(): | if other.fctx.isabsent(): | ||||
| index = ui.promptchoice(_localchangedotherdeletedmsg % prompts, 2) | index = ui.promptchoice(_localchangedotherdeletedmsg % prompts, 2) | ||||
| choice = [b'local', b'other', b'unresolved'][index] | choice = [b'local', b'other', b'unresolved'][index] | ||||
| elif fcd.isabsent(): | elif local.fctx.isabsent(): | ||||
| index = ui.promptchoice(_otherchangedlocaldeletedmsg % prompts, 2) | index = ui.promptchoice(_otherchangedlocaldeletedmsg % prompts, 2) | ||||
| choice = [b'other', b'local', b'unresolved'][index] | choice = [b'other', b'local', b'unresolved'][index] | ||||
| else: | else: | ||||
| # IMPORTANT: keep the last line of this prompt ("What do you want to | # IMPORTANT: keep the last line of this prompt ("What do you want to | ||||
| # do?") very short, see comment next to _localchangedotherdeletedmsg | # do?") very short, see comment next to _localchangedotherdeletedmsg | ||||
| # at the top of the file for details. | # at the top of the file for details. | ||||
| index = ui.promptchoice( | index = ui.promptchoice( | ||||
| _( | _( | ||||
| b"file '%(fd)s' needs to be resolved.\n" | b"file '%(fd)s' needs to be resolved.\n" | ||||
| b"You can keep (l)ocal%(l)s, take (o)ther%(o)s, or leave " | b"You can keep (l)ocal%(l)s, take (o)ther%(o)s, or leave " | ||||
| b"(u)nresolved.\n" | b"(u)nresolved.\n" | ||||
| b"What do you want to do?" | b"What do you want to do?" | ||||
| b"$$ &Local $$ &Other $$ &Unresolved" | b"$$ &Local $$ &Other $$ &Unresolved" | ||||
| ) | ) | ||||
| % prompts, | % prompts, | ||||
| 2, | 2, | ||||
| ) | ) | ||||
| choice = [b'local', b'other', b'unresolved'][index] | choice = [b'local', b'other', b'unresolved'][index] | ||||
| if choice == b'other': | if choice == b'other': | ||||
| return _iother(repo, mynode, fcd, fco, fca, toolconf, labels) | return _iother(repo, mynode, local, other, base, toolconf) | ||||
| elif choice == b'local': | elif choice == b'local': | ||||
| return _ilocal(repo, mynode, fcd, fco, fca, toolconf, labels) | return _ilocal(repo, mynode, local, other, base, toolconf) | ||||
| elif choice == b'unresolved': | elif choice == b'unresolved': | ||||
| return _ifail(repo, mynode, fcd, fco, fca, toolconf, labels) | return _ifail(repo, mynode, local, other, base, toolconf) | ||||
| except error.ResponseExpected: | except error.ResponseExpected: | ||||
| ui.write(b"\n") | ui.write(b"\n") | ||||
| return _ifail(repo, mynode, fcd, fco, fca, toolconf, labels) | return _ifail(repo, mynode, local, other, base, toolconf) | ||||
| @internaltool(b'local', nomerge) | @internaltool(b'local', nomerge) | ||||
| def _ilocal(repo, mynode, fcd, fco, fca, toolconf, labels=None): | def _ilocal(repo, mynode, local, other, base, toolconf): | ||||
| """Uses the local `p1()` version of files as the merged version.""" | """Uses the local `p1()` version of files as the merged version.""" | ||||
| return 0, fcd.isabsent() | return 0, local.fctx.isabsent() | ||||
| @internaltool(b'other', nomerge) | @internaltool(b'other', nomerge) | ||||
| def _iother(repo, mynode, fcd, fco, fca, toolconf, labels=None): | def _iother(repo, mynode, local, other, base, toolconf): | ||||
| """Uses the other `p2()` version of files as the merged version.""" | """Uses the other `p2()` version of files as the merged version.""" | ||||
| if fco.isabsent(): | if other.fctx.isabsent(): | ||||
| # local changed, remote deleted -- 'deleted' picked | # local changed, remote deleted -- 'deleted' picked | ||||
| _underlyingfctxifabsent(fcd).remove() | _underlyingfctxifabsent(local.fctx).remove() | ||||
| deleted = True | deleted = True | ||||
| else: | else: | ||||
| _underlyingfctxifabsent(fcd).write(fco.data(), fco.flags()) | _underlyingfctxifabsent(local.fctx).write( | ||||
| other.fctx.data(), other.fctx.flags() | |||||
| ) | |||||
| deleted = False | deleted = False | ||||
| return 0, deleted | return 0, deleted | ||||
| @internaltool(b'fail', nomerge) | @internaltool(b'fail', nomerge) | ||||
| def _ifail(repo, mynode, fcd, fco, fca, toolconf, labels=None): | def _ifail(repo, mynode, local, other, base, toolconf): | ||||
| """ | """ | ||||
| Rather than attempting to merge files that were modified on both | Rather than attempting to merge files that were modified on both | ||||
| branches, it marks them as unresolved. The resolve command must be | branches, it marks them as unresolved. The resolve command must be | ||||
| used to resolve these conflicts.""" | used to resolve these conflicts.""" | ||||
| # for change/delete conflicts write out the changed version, then fail | # for change/delete conflicts write out the changed version, then fail | ||||
| if fcd.isabsent(): | if local.fctx.isabsent(): | ||||
| _underlyingfctxifabsent(fcd).write(fco.data(), fco.flags()) | _underlyingfctxifabsent(local.fctx).write( | ||||
| other.fctx.data(), other.fctx.flags() | |||||
| ) | |||||
| return 1, False | return 1, False | ||||
| def _underlyingfctxifabsent(filectx): | def _underlyingfctxifabsent(filectx): | ||||
| """Sometimes when resolving, our fcd is actually an absentfilectx, but | """Sometimes when resolving, our fcd is actually an absentfilectx, but | ||||
| we want to write to it (to do the resolve). This helper returns the | we want to write to it (to do the resolve). This helper returns the | ||||
| underyling workingfilectx in that case. | underyling workingfilectx in that case. | ||||
| """ | """ | ||||
| if filectx.isabsent(): | if filectx.isabsent(): | ||||
| return filectx.changectx()[filectx.path()] | return filectx.changectx()[filectx.path()] | ||||
| else: | else: | ||||
| return filectx | return filectx | ||||
| def _premerge(repo, fcd, fco, fca, toolconf, backup, labels): | def _premerge(repo, local, other, base, toolconf, backup): | ||||
| tool, toolpath, binary, symlink, scriptfn = toolconf | tool, toolpath, binary, symlink, scriptfn = toolconf | ||||
| if symlink or fcd.isabsent() or fco.isabsent(): | if symlink or local.fctx.isabsent() or other.fctx.isabsent(): | ||||
| return 1 | return 1 | ||||
| ui = repo.ui | ui = repo.ui | ||||
| validkeep = [b'keep', b'keep-merge3', b'keep-mergediff'] | validkeep = [b'keep', b'keep-merge3', b'keep-mergediff'] | ||||
| # do we attempt to simplemerge first? | # do we attempt to simplemerge first? | ||||
| try: | try: | ||||
| premerge = _toolbool(ui, tool, b"premerge", not binary) | premerge = _toolbool(ui, tool, b"premerge", not binary) | ||||
| except error.ConfigError: | except error.ConfigError: | ||||
| premerge = _toolstr(ui, tool, b"premerge", b"").lower() | premerge = _toolstr(ui, tool, b"premerge", b"").lower() | ||||
| if premerge not in validkeep: | if premerge not in validkeep: | ||||
| _valid = b', '.join([b"'" + v + b"'" for v in validkeep]) | _valid = b', '.join([b"'" + v + b"'" for v in validkeep]) | ||||
| raise error.ConfigError( | raise error.ConfigError( | ||||
| _(b"%s.premerge not valid ('%s' is neither boolean nor %s)") | _(b"%s.premerge not valid ('%s' is neither boolean nor %s)") | ||||
| % (tool, premerge, _valid) | % (tool, premerge, _valid) | ||||
| ) | ) | ||||
| if premerge: | if premerge: | ||||
| mode = b'merge' | mode = b'merge' | ||||
| if premerge == b'keep-mergediff': | if premerge == b'keep-mergediff': | ||||
| mode = b'mergediff' | mode = b'mergediff' | ||||
| elif premerge == b'keep-merge3': | elif premerge == b'keep-merge3': | ||||
| mode = b'merge3' | mode = b'merge3' | ||||
| local = simplemerge.MergeInput(fcd, labels[0]) | |||||
| other = simplemerge.MergeInput(fco, labels[1]) | |||||
| base = simplemerge.MergeInput(fca, labels[2]) | |||||
| r = simplemerge.simplemerge( | r = simplemerge.simplemerge( | ||||
| ui, local, base, other, quiet=True, mode=mode | ui, local, base, other, quiet=True, mode=mode | ||||
| ) | ) | ||||
| if not r: | if not r: | ||||
| ui.debug(b" premerge successful\n") | ui.debug(b" premerge successful\n") | ||||
| return 0 | return 0 | ||||
| if premerge not in validkeep: | if premerge not in validkeep: | ||||
| # restore from backup and try again | # restore from backup and try again | ||||
| _restorebackup(fcd, backup) | _restorebackup(local.fctx, backup) | ||||
| return 1 # continue merging | return 1 # continue merging | ||||
| def _mergecheck(repo, mynode, fcd, fco, fca, toolconf): | def _mergecheck(repo, mynode, fcd, fco, fca, toolconf): | ||||
| tool, toolpath, binary, symlink, scriptfn = toolconf | tool, toolpath, binary, symlink, scriptfn = toolconf | ||||
| uipathfn = scmutil.getuipathfn(repo) | uipathfn = scmutil.getuipathfn(repo) | ||||
| if symlink: | if symlink: | ||||
| repo.ui.warn( | repo.ui.warn( | ||||
| _(b'warning: internal %s cannot merge symlinks for %s\n') | _(b'warning: internal %s cannot merge symlinks for %s\n') | ||||
| % (tool, uipathfn(fcd.path())) | % (tool, uipathfn(fcd.path())) | ||||
| ) | ) | ||||
| return False | return False | ||||
| if fcd.isabsent() or fco.isabsent(): | if fcd.isabsent() or fco.isabsent(): | ||||
| repo.ui.warn( | repo.ui.warn( | ||||
| _( | _( | ||||
| b'warning: internal %s cannot merge change/delete ' | b'warning: internal %s cannot merge change/delete ' | ||||
| b'conflict for %s\n' | b'conflict for %s\n' | ||||
| ) | ) | ||||
| % (tool, uipathfn(fcd.path())) | % (tool, uipathfn(fcd.path())) | ||||
| ) | ) | ||||
| return False | return False | ||||
| return True | return True | ||||
| def _merge(repo, fcd, fco, fca, labels, mode): | def _merge(repo, local, other, base, mode): | ||||
| """ | """ | ||||
| Uses the internal non-interactive simple merge algorithm for merging | Uses the internal non-interactive simple merge algorithm for merging | ||||
| files. It will fail if there are any conflicts and leave markers in | files. It will fail if there are any conflicts and leave markers in | ||||
| the partially merged file. Markers will have two sections, one for each side | the partially merged file. Markers will have two sections, one for each side | ||||
| of merge, unless mode equals 'union' which suppresses the markers.""" | of merge, unless mode equals 'union' which suppresses the markers.""" | ||||
| ui = repo.ui | ui = repo.ui | ||||
| local = simplemerge.MergeInput(fcd) | |||||
| local.label = labels[0] | |||||
| other = simplemerge.MergeInput(fco) | |||||
| other.label = labels[1] | |||||
| base = simplemerge.MergeInput(fca) | |||||
| base.label = labels[2] | |||||
| r = simplemerge.simplemerge(ui, local, base, other, mode=mode) | r = simplemerge.simplemerge(ui, local, base, other, mode=mode) | ||||
| return True, r, False | return True, r, False | ||||
| @internaltool( | @internaltool( | ||||
| b'union', | b'union', | ||||
| fullmerge, | fullmerge, | ||||
| _( | _( | ||||
| b"warning: conflicts while merging %s! " | b"warning: conflicts while merging %s! " | ||||
| b"(edit, then use 'hg resolve --mark')\n" | b"(edit, then use 'hg resolve --mark')\n" | ||||
| ), | ), | ||||
| precheck=_mergecheck, | precheck=_mergecheck, | ||||
| ) | ) | ||||
| def _iunion(repo, mynode, fcd, fco, fca, toolconf, backup, labels=None): | def _iunion(repo, mynode, local, other, base, toolconf, backup): | ||||
| """ | """ | ||||
| Uses the internal non-interactive simple merge algorithm for merging | Uses the internal non-interactive simple merge algorithm for merging | ||||
| files. It will use both left and right sides for conflict regions. | files. It will use both left and right sides for conflict regions. | ||||
| No markers are inserted.""" | No markers are inserted.""" | ||||
| return _merge(repo, fcd, fco, fca, labels, b'union') | return _merge(repo, local, other, base, b'union') | ||||
| @internaltool( | @internaltool( | ||||
| b'merge', | b'merge', | ||||
| fullmerge, | fullmerge, | ||||
| _( | _( | ||||
| b"warning: conflicts while merging %s! " | b"warning: conflicts while merging %s! " | ||||
| b"(edit, then use 'hg resolve --mark')\n" | b"(edit, then use 'hg resolve --mark')\n" | ||||
| ), | ), | ||||
| precheck=_mergecheck, | precheck=_mergecheck, | ||||
| ) | ) | ||||
| def _imerge(repo, mynode, fcd, fco, fca, toolconf, backup, labels=None): | def _imerge(repo, mynode, local, other, base, toolconf, backup): | ||||
| """ | """ | ||||
| Uses the internal non-interactive simple merge algorithm for merging | Uses the internal non-interactive simple merge algorithm for merging | ||||
| files. It will fail if there are any conflicts and leave markers in | files. It will fail if there are any conflicts and leave markers in | ||||
| the partially merged file. Markers will have two sections, one for each side | the partially merged file. Markers will have two sections, one for each side | ||||
| of merge.""" | of merge.""" | ||||
| return _merge(repo, fcd, fco, fca, labels, b'merge') | return _merge(repo, local, other, base, b'merge') | ||||
| @internaltool( | @internaltool( | ||||
| b'merge3', | b'merge3', | ||||
| fullmerge, | fullmerge, | ||||
| _( | _( | ||||
| b"warning: conflicts while merging %s! " | b"warning: conflicts while merging %s! " | ||||
| b"(edit, then use 'hg resolve --mark')\n" | b"(edit, then use 'hg resolve --mark')\n" | ||||
| ), | ), | ||||
| precheck=_mergecheck, | precheck=_mergecheck, | ||||
| ) | ) | ||||
| def _imerge3(repo, mynode, fcd, fco, fca, toolconf, backup, labels=None): | def _imerge3(repo, mynode, local, other, base, toolconf, backup): | ||||
| """ | """ | ||||
| Uses the internal non-interactive simple merge algorithm for merging | Uses the internal non-interactive simple merge algorithm for merging | ||||
| files. It will fail if there are any conflicts and leave markers in | files. It will fail if there are any conflicts and leave markers in | ||||
| the partially merged file. Marker will have three sections, one from each | the partially merged file. Marker will have three sections, one from each | ||||
| side of the merge and one for the base content.""" | side of the merge and one for the base content.""" | ||||
| return _merge(repo, fcd, fco, fca, labels, b'merge3') | return _merge(repo, local, other, base, b'merge3') | ||||
| @internaltool( | @internaltool( | ||||
| b'merge3-lie-about-conflicts', | b'merge3-lie-about-conflicts', | ||||
| fullmerge, | fullmerge, | ||||
| b'', | b'', | ||||
| precheck=_mergecheck, | precheck=_mergecheck, | ||||
| ) | ) | ||||
| b'mergediff', | b'mergediff', | ||||
| fullmerge, | fullmerge, | ||||
| _( | _( | ||||
| b"warning: conflicts while merging %s! " | b"warning: conflicts while merging %s! " | ||||
| b"(edit, then use 'hg resolve --mark')\n" | b"(edit, then use 'hg resolve --mark')\n" | ||||
| ), | ), | ||||
| precheck=_mergecheck, | precheck=_mergecheck, | ||||
| ) | ) | ||||
| def _imerge_diff(repo, mynode, fcd, fco, fca, toolconf, backup, labels=None): | def _imerge_diff(repo, mynode, local, other, base, toolconf, backup): | ||||
| """ | """ | ||||
| Uses the internal non-interactive simple merge algorithm for merging | Uses the internal non-interactive simple merge algorithm for merging | ||||
| files. It will fail if there are any conflicts and leave markers in | files. It will fail if there are any conflicts and leave markers in | ||||
| the partially merged file. The marker will have two sections, one with the | the partially merged file. The marker will have two sections, one with the | ||||
| content from one side of the merge, and one with a diff from the base | content from one side of the merge, and one with a diff from the base | ||||
| content to the content on the other side. (experimental)""" | content to the content on the other side. (experimental)""" | ||||
| return _merge(repo, fcd, fco, fca, labels, b'mergediff') | return _merge(repo, local, other, base, b'mergediff') | ||||
| @internaltool(b'merge-local', mergeonly, precheck=_mergecheck) | @internaltool(b'merge-local', mergeonly, precheck=_mergecheck) | ||||
| def _imergelocal(repo, mynode, fcd, fco, fca, toolconf, backup, labels=None): | def _imergelocal(repo, mynode, local, other, base, toolconf, backup): | ||||
| """ | """ | ||||
| Like :merge, but resolve all conflicts non-interactively in favor | Like :merge, but resolve all conflicts non-interactively in favor | ||||
| of the local `p1()` changes.""" | of the local `p1()` changes.""" | ||||
| return _merge(repo, fcd, fco, fca, labels, b'local') | return _merge(repo, local, other, base, b'local') | ||||
| @internaltool(b'merge-other', mergeonly, precheck=_mergecheck) | @internaltool(b'merge-other', mergeonly, precheck=_mergecheck) | ||||
| def _imergeother(repo, mynode, fcd, fco, fca, toolconf, backup, labels=None): | def _imergeother(repo, mynode, local, other, base, toolconf, backup): | ||||
| """ | """ | ||||
| Like :merge, but resolve all conflicts non-interactively in favor | Like :merge, but resolve all conflicts non-interactively in favor | ||||
| of the other `p2()` changes.""" | of the other `p2()` changes.""" | ||||
| return _merge(repo, fcd, fco, fca, labels, b'other') | return _merge(repo, local, other, base, b'other') | ||||
| @internaltool( | @internaltool( | ||||
| b'tagmerge', | b'tagmerge', | ||||
| mergeonly, | mergeonly, | ||||
| _( | _( | ||||
| b"automatic tag merging of %s failed! " | b"automatic tag merging of %s failed! " | ||||
| b"(use 'hg resolve --tool :merge' or another merge " | b"(use 'hg resolve --tool :merge' or another merge " | ||||
| b"tool of your choice)\n" | b"tool of your choice)\n" | ||||
| ), | ), | ||||
| ) | ) | ||||
| def _itagmerge(repo, mynode, fcd, fco, fca, toolconf, backup, labels=None): | def _itagmerge(repo, mynode, local, other, base, toolconf, backup): | ||||
| """ | """ | ||||
| Uses the internal tag merge algorithm (experimental). | Uses the internal tag merge algorithm (experimental). | ||||
| """ | """ | ||||
| success, status = tagmerge.merge(repo, fcd, fco, fca) | success, status = tagmerge.merge(repo, local.fctx, other.fctx, base.fctx) | ||||
| return success, status, False | return success, status, False | ||||
| @internaltool(b'dump', fullmerge, binary=True, symlink=True) | @internaltool(b'dump', fullmerge, binary=True, symlink=True) | ||||
| def _idump(repo, mynode, fcd, fco, fca, toolconf, backup, labels=None): | def _idump(repo, mynode, local, other, base, toolconf, backup): | ||||
| """ | """ | ||||
| Creates three versions of the files to merge, containing the | Creates three versions of the files to merge, containing the | ||||
| contents of local, other and base. These files can then be used to | contents of local, other and base. These files can then be used to | ||||
| perform a merge manually. If the file to be merged is named | perform a merge manually. If the file to be merged is named | ||||
| ``a.txt``, these files will accordingly be named ``a.txt.local``, | ``a.txt``, these files will accordingly be named ``a.txt.local``, | ||||
| ``a.txt.other`` and ``a.txt.base`` and they will be placed in the | ``a.txt.other`` and ``a.txt.base`` and they will be placed in the | ||||
| same directory as ``a.txt``. | same directory as ``a.txt``. | ||||
| This implies premerge. Therefore, files aren't dumped, if premerge | This implies premerge. Therefore, files aren't dumped, if premerge | ||||
| runs successfully. Use :forcedump to forcibly write files out. | runs successfully. Use :forcedump to forcibly write files out. | ||||
| """ | """ | ||||
| a = _workingpath(repo, fcd) | a = _workingpath(repo, local.fctx) | ||||
| fd = fcd.path() | fd = local.fctx.path() | ||||
| from . import context | from . import context | ||||
| if isinstance(fcd, context.overlayworkingfilectx): | if isinstance(local.fctx, context.overlayworkingfilectx): | ||||
| raise error.InMemoryMergeConflictsError( | raise error.InMemoryMergeConflictsError( | ||||
| b'in-memory merge does not support the :dump tool.' | b'in-memory merge does not support the :dump tool.' | ||||
| ) | ) | ||||
| util.writefile(a + b".local", fcd.decodeddata()) | util.writefile(a + b".local", local.fctx.decodeddata()) | ||||
| repo.wwrite(fd + b".other", fco.data(), fco.flags()) | repo.wwrite(fd + b".other", other.fctx.data(), other.fctx.flags()) | ||||
| repo.wwrite(fd + b".base", fca.data(), fca.flags()) | repo.wwrite(fd + b".base", base.fctx.data(), base.fctx.flags()) | ||||
| return False, 1, False | return False, 1, False | ||||
| @internaltool(b'forcedump', mergeonly, binary=True, symlink=True) | @internaltool(b'forcedump', mergeonly, binary=True, symlink=True) | ||||
| def _forcedump(repo, mynode, fcd, fco, fca, toolconf, backup, labels=None): | def _forcedump(repo, mynode, local, other, base, toolconf, backup): | ||||
| """ | """ | ||||
| Creates three versions of the files as same as :dump, but omits premerge. | Creates three versions of the files as same as :dump, but omits premerge. | ||||
| """ | """ | ||||
| return _idump(repo, mynode, fcd, fco, fca, toolconf, backup, labels=labels) | return _idump(repo, mynode, local, other, base, toolconf, backup) | ||||
| def _xmergeimm(repo, mynode, fcd, fco, fca, toolconf, backup, labels=None): | def _xmergeimm(repo, mynode, local, other, base, toolconf, backup): | ||||
| # In-memory merge simply raises an exception on all external merge tools, | # In-memory merge simply raises an exception on all external merge tools, | ||||
| # for now. | # for now. | ||||
| # | # | ||||
| # It would be possible to run most tools with temporary files, but this | # It would be possible to run most tools with temporary files, but this | ||||
| # raises the question of what to do if the user only partially resolves the | # raises the question of what to do if the user only partially resolves the | ||||
| # file -- we can't leave a merge state. (Copy to somewhere in the .hg/ | # file -- we can't leave a merge state. (Copy to somewhere in the .hg/ | ||||
| # directory and tell the user how to get it is my best idea, but it's | # directory and tell the user how to get it is my best idea, but it's | ||||
| # clunky.) | # clunky.) | ||||
| # things for us to import cmdutil. | # things for us to import cmdutil. | ||||
| tres = formatter.templateresources(ui, repo) | tres = formatter.templateresources(ui, repo) | ||||
| t = formatter.maketemplater( | t = formatter.maketemplater( | ||||
| ui, tmpl, defaults=templatekw.keywords, resources=tres | ui, tmpl, defaults=templatekw.keywords, resources=tres | ||||
| ) | ) | ||||
| ui.status(t.renderdefault(props)) | ui.status(t.renderdefault(props)) | ||||
| def _xmerge(repo, mynode, fcd, fco, fca, toolconf, backup, labels): | def _xmerge(repo, mynode, local, other, base, toolconf, backup): | ||||
| fcd = local.fctx | |||||
| fco = other.fctx | |||||
| fca = base.fctx | |||||
| tool, toolpath, binary, symlink, scriptfn = toolconf | tool, toolpath, binary, symlink, scriptfn = toolconf | ||||
| uipathfn = scmutil.getuipathfn(repo) | uipathfn = scmutil.getuipathfn(repo) | ||||
| if fcd.isabsent() or fco.isabsent(): | if fcd.isabsent() or fco.isabsent(): | ||||
| repo.ui.warn( | repo.ui.warn( | ||||
| _(b'warning: %s cannot merge change/delete conflict for %s\n') | _(b'warning: %s cannot merge change/delete conflict for %s\n') | ||||
| % (tool, uipathfn(fcd.path())) | % (tool, uipathfn(fcd.path())) | ||||
| ) | ) | ||||
| return False, 1, None | return False, 1, None | ||||
| localpath = _workingpath(repo, fcd) | localpath = _workingpath(repo, fcd) | ||||
| args = _toolstr(repo.ui, tool, b"args") | args = _toolstr(repo.ui, tool, b"args") | ||||
| with _maketempfiles( | with _maketempfiles( | ||||
| repo, fco, fca, repo.wvfs.join(backup.path()), b"$output" in args | repo, fco, fca, repo.wvfs.join(backup.path()), b"$output" in args | ||||
| ) as temppaths: | ) as temppaths: | ||||
| basepath, otherpath, localoutputpath = temppaths | basepath, otherpath, localoutputpath = temppaths | ||||
| outpath = b"" | outpath = b"" | ||||
| mylabel, otherlabel = labels[:2] | |||||
| baselabel = labels[2] | |||||
| env = { | env = { | ||||
| b'HG_FILE': fcd.path(), | b'HG_FILE': fcd.path(), | ||||
| b'HG_MY_NODE': short(mynode), | b'HG_MY_NODE': short(mynode), | ||||
| b'HG_OTHER_NODE': short(fco.changectx().node()), | b'HG_OTHER_NODE': short(fco.changectx().node()), | ||||
| b'HG_BASE_NODE': short(fca.changectx().node()), | b'HG_BASE_NODE': short(fca.changectx().node()), | ||||
| b'HG_MY_ISLINK': b'l' in fcd.flags(), | b'HG_MY_ISLINK': b'l' in fcd.flags(), | ||||
| b'HG_OTHER_ISLINK': b'l' in fco.flags(), | b'HG_OTHER_ISLINK': b'l' in fco.flags(), | ||||
| b'HG_BASE_ISLINK': b'l' in fca.flags(), | b'HG_BASE_ISLINK': b'l' in fca.flags(), | ||||
| b'HG_MY_LABEL': mylabel, | b'HG_MY_LABEL': local.label, | ||||
| b'HG_OTHER_LABEL': otherlabel, | b'HG_OTHER_LABEL': other.label, | ||||
| b'HG_BASE_LABEL': baselabel, | b'HG_BASE_LABEL': base.label, | ||||
| } | } | ||||
| ui = repo.ui | ui = repo.ui | ||||
| if b"$output" in args: | if b"$output" in args: | ||||
| # read input from backup, write to original | # read input from backup, write to original | ||||
| outpath = localpath | outpath = localpath | ||||
| localpath = localoutputpath | localpath = localoutputpath | ||||
| replace = { | replace = { | ||||
| b'local': localpath, | b'local': localpath, | ||||
| b'base': basepath, | b'base': basepath, | ||||
| b'other': otherpath, | b'other': otherpath, | ||||
| b'output': outpath, | b'output': outpath, | ||||
| b'labellocal': mylabel, | b'labellocal': local.label, | ||||
| b'labelother': otherlabel, | b'labelother': other.label, | ||||
| b'labelbase': baselabel, | b'labelbase': base.label, | ||||
| } | } | ||||
| args = util.interpolate( | args = util.interpolate( | ||||
| br'\$', | br'\$', | ||||
| replace, | replace, | ||||
| args, | args, | ||||
| lambda s: procutil.shellquote(util.localpath(s)), | lambda s: procutil.shellquote(util.localpath(s)), | ||||
| ) | ) | ||||
| if _toolbool(ui, tool, b"gui"): | if _toolbool(ui, tool, b"gui"): | ||||
| ui, repo, b"merge", toolpath, mergefn, {b'args': argslist}, True | ui, repo, b"merge", toolpath, mergefn, {b'args': argslist}, True | ||||
| ) | ) | ||||
| if raised: | if raised: | ||||
| r = 1 | r = 1 | ||||
| repo.ui.debug(b'merge tool returned: %d\n' % r) | repo.ui.debug(b'merge tool returned: %d\n' % r) | ||||
| return True, r, False | return True, r, False | ||||
| def _formatlabel(input, template, pad): | def _populate_label_detail(input, template, pad): | ||||
| """Applies the given template to the ctx, prefixed by the label. | """Applies the given template to the ctx, prefixed by the label. | ||||
| Pad is the minimum width of the label prefix, so that multiple markers | Pad is the minimum width of the label prefix, so that multiple markers | ||||
| can have aligned templated parts. | can have aligned templated parts. | ||||
| """ | """ | ||||
| ctx = input.fctx.changectx() | ctx = input.fctx.changectx() | ||||
| if ctx.node() is None: | if ctx.node() is None: | ||||
| ctx = ctx.p1() | ctx = ctx.p1() | ||||
| props = {b'ctx': ctx} | props = {b'ctx': ctx} | ||||
| templateresult = template.renderdefault(props) | templateresult = template.renderdefault(props) | ||||
| label = (b'%s:' % input.label).ljust(pad + 1) | label = (b'%s:' % input.label).ljust(pad + 1) | ||||
| mark = b'%s %s' % (label, templateresult) | mark = b'%s %s' % (label, templateresult) | ||||
| mark = mark.splitlines()[0] # split for safety | mark = mark.splitlines()[0] # split for safety | ||||
| # 8 for the prefix of conflict marker lines (e.g. '<<<<<<< ') | # 8 for the prefix of conflict marker lines (e.g. '<<<<<<< ') | ||||
| input.label = stringutil.ellipsis(mark, 80 - 8) | input.label = stringutil.ellipsis(mark, 80 - 8) | ||||
| def _formatlabels(repo, inputs, tool=None): | def _populate_label_details(repo, inputs, tool=None): | ||||
| """Formats the given labels using the conflict marker template. | """Formats the given labels using the conflict marker template. | ||||
| Returns a list of formatted labels. | Returns a list of formatted labels. | ||||
| """ | """ | ||||
| ui = repo.ui | ui = repo.ui | ||||
| template = ui.config(b'command-templates', b'mergemarker') | template = ui.config(b'command-templates', b'mergemarker') | ||||
| if tool is not None: | if tool is not None: | ||||
| template = _toolstr(ui, tool, b'mergemarkertemplate', template) | template = _toolstr(ui, tool, b'mergemarkertemplate', template) | ||||
| template = templater.unquotestring(template) | template = templater.unquotestring(template) | ||||
| tres = formatter.templateresources(ui, repo) | tres = formatter.templateresources(ui, repo) | ||||
| tmpl = formatter.maketemplater( | tmpl = formatter.maketemplater( | ||||
| ui, template, defaults=templatekw.keywords, resources=tres | ui, template, defaults=templatekw.keywords, resources=tres | ||||
| ) | ) | ||||
| pad = max(len(input.label) for input in inputs) | pad = max(len(input.label) for input in inputs) | ||||
| return [_formatlabel(input, tmpl, pad) for input in inputs] | for input in inputs: | ||||
| _populate_label_detail(input, tmpl, pad) | |||||
| def partextras(labels): | def partextras(labels): | ||||
| """Return a dictionary of extra labels for use in prompts to the user | """Return a dictionary of extra labels for use in prompts to the user | ||||
| Intended use is in strings of the form "(l)ocal%(l)s". | Intended use is in strings of the form "(l)ocal%(l)s". | ||||
| """ | """ | ||||
| if labels is None: | if labels is None: | ||||
| labels.append(b'base') | labels.append(b'base') | ||||
| local = simplemerge.MergeInput(fcd, labels[0]) | local = simplemerge.MergeInput(fcd, labels[0]) | ||||
| other = simplemerge.MergeInput(fco, labels[1]) | other = simplemerge.MergeInput(fco, labels[1]) | ||||
| base = simplemerge.MergeInput(fca, labels[2]) | base = simplemerge.MergeInput(fca, labels[2]) | ||||
| if mergetype == nomerge: | if mergetype == nomerge: | ||||
| return func( | return func( | ||||
| repo, | repo, | ||||
| mynode, | mynode, | ||||
| fcd, | local, | ||||
| fco, | other, | ||||
| fca, | base, | ||||
| toolconf, | toolconf, | ||||
| [local.label, other.label, base.label], | |||||
| ) | ) | ||||
| if orig != fco.path(): | if orig != fco.path(): | ||||
| ui.status( | ui.status( | ||||
| _(b"merging %s and %s to %s\n") | _(b"merging %s and %s to %s\n") | ||||
| % (uipathfn(orig), uipathfn(fco.path()), fduipath) | % (uipathfn(orig), uipathfn(fco.path()), fduipath) | ||||
| ) | ) | ||||
| else: | else: | ||||
| # space-constrained areas of the UI, but still get full information | # space-constrained areas of the UI, but still get full information | ||||
| # in conflict markers if premerge is 'keep' or 'keep-merge3'. | # in conflict markers if premerge is 'keep' or 'keep-merge3'. | ||||
| labeltool = None | labeltool = None | ||||
| if markerstyle != b'basic': | if markerstyle != b'basic': | ||||
| # respect 'tool's mergemarkertemplate (which defaults to | # respect 'tool's mergemarkertemplate (which defaults to | ||||
| # command-templates.mergemarker) | # command-templates.mergemarker) | ||||
| labeltool = tool | labeltool = tool | ||||
| if internalmarkerstyle != b'basic' or markerstyle != b'basic': | if internalmarkerstyle != b'basic' or markerstyle != b'basic': | ||||
| _formatlabels(repo, [local, other, base], tool=labeltool) | _populate_label_details( | ||||
| repo, [local, other, base], tool=labeltool | |||||
| ) | |||||
| r = _premerge( | r = _premerge( | ||||
| repo, | repo, | ||||
| fcd, | local, | ||||
| fco, | other, | ||||
| fca, | base, | ||||
| toolconf, | toolconf, | ||||
| backup, | backup, | ||||
| labels=[local.label, other.label, base.label], | |||||
| ) | ) | ||||
| # we're done if premerge was successful (r is 0) | # we're done if premerge was successful (r is 0) | ||||
| if not r: | if not r: | ||||
| return r, False | return r, False | ||||
| # Reset to basic labels | # Reset to basic labels | ||||
| local.label = labels[0] | local.label = labels[0] | ||||
| other.label = labels[1] | other.label = labels[1] | ||||
| base.label = labels[2] | base.label = labels[2] | ||||
| if markerstyle != b'basic': | if markerstyle != b'basic': | ||||
| _formatlabels(repo, [local, other, base], tool=tool) | _populate_label_details(repo, [local, other, base], tool=tool) | ||||
| needcheck, r, deleted = func( | needcheck, r, deleted = func( | ||||
| repo, | repo, | ||||
| mynode, | mynode, | ||||
| fcd, | local, | ||||
| fco, | other, | ||||
| fca, | base, | ||||
| toolconf, | toolconf, | ||||
| backup, | backup, | ||||
| labels=[local.label, other.label, base.label], | |||||
| ) | ) | ||||
| if needcheck: | if needcheck: | ||||
| r = _check(repo, r, ui, tool, fcd, backup) | r = _check(repo, r, ui, tool, fcd, backup) | ||||
| if r: | if r: | ||||
| if onfailure: | if onfailure: | ||||
| if wctx.isinmemory(): | if wctx.isinmemory(): | ||||