This is an archive of the discontinued Mercurial Phabricator instance.

Differential D6967

shelve: add method for storing mergestate in changeset extras
AbandonedPublic

Authored by navaneeth.suresh on Oct 4 2019, 4:46 PM.

Details

Reviewers
None
Group Reviewers
hg-reviewers
Summary

We store mergestate records in .hg/merge. This patch adds a method
of storage in changeset extras. This will help in the exchange of
mergestate records to other repos. Also, this can be used by
shelve --unresolved to store the mergestate records.

It uses the storage format supported for hg versions 3.7 or later. For the
time being, I have omitted the storage of the content of the local version
of unresolved files.

Diff Detail

Repository
rHG Mercurial
Lint
Lint Skipped
Unit
Unit Tests Skipped

Revision Contents
Changeset List

PathPackages
Mmercurial/shelve.py (64 lines)

Diff 16809

mercurial/shelve.py

shelve". shelve".
""" """
from __future__ import absolute_import from __future__ import absolute_import
import collections import collections
import errno import errno
import itertools import itertools
import stat import stat
import struct
from .i18n import _ from .i18n import _
from . import ( from . import (
bookmarks, bookmarks,
bundle2, bundle2,
bundlerepo, bundlerepo,
changegroup, changegroup,
cmdutil, cmdutil,
util, util,
vfs as vfsmod, vfs as vfsmod,
) )
from .utils import ( from .utils import (
dateutil, dateutil,
stringutil, stringutil,
) )
_pack = struct.pack
_unpack = struct.unpack
backupdir = 'shelve-backup' backupdir = 'shelve-backup'
shelvedir = 'shelved' shelvedir = 'shelved'
shelvefileextensions = ['hg', 'patch', 'shelve'] shelvefileextensions = ['hg', 'patch', 'shelve']
# universal extension is present in all types of shelves # universal extension is present in all types of shelves
patchextension = 'patch' patchextension = 'patch'
# we never need the user, so we use a # we never need the user, so we use a
# generic user for all shelve operations # generic user for all shelve operations
shelveuser = 'shelve@localhost' shelveuser = 'shelve@localhost'
# Merge state record types. See ``mergestate`` docs for more.
RECORD_LOCAL = b'L'
RECORD_OTHER = b'O'
RECORD_MERGED = b'F'
RECORD_CHANGEDELETE_CONFLICT = b'C'
RECORD_MERGE_DRIVER_MERGE = b'D'
RECORD_PATH_CONFLICT = b'P'
RECORD_MERGE_DRIVER_STATE = b'm'
RECORD_FILE_VALUES = b'f'
RECORD_LABELS = b'l'
RECORD_OVERRIDE = b't'
RECORD_UNSUPPORTED_MANDATORY = b'X'
RECORD_UNSUPPORTED_ADVISORY = b'x'
MERGE_DRIVER_STATE_UNMARKED = b'u'
MERGE_DRIVER_STATE_MARKED = b'm'
MERGE_DRIVER_STATE_SUCCESS = b's'
MERGE_RECORD_UNRESOLVED = b'u'
MERGE_RECORD_RESOLVED = b'r'
MERGE_RECORD_UNRESOLVED_PATH = b'pu'
MERGE_RECORD_RESOLVED_PATH = b'pr'
MERGE_RECORD_DRIVER_RESOLVED = b'd'
ACTION_FORGET = b'f'
ACTION_REMOVE = b'r'
ACTION_ADD = b'a'
ACTION_GET = b'g'
ACTION_PATH_CONFLICT = b'p'
ACTION_PATH_CONFLICT_RESOLVE = b'pr'
ACTION_ADD_MODIFIED = b'am'
ACTION_CREATED = b'c'
ACTION_DELETED_CHANGED = b'dc'
ACTION_CHANGED_DELETED = b'cd'
ACTION_MERGE = b'm'
ACTION_LOCAL_DIR_RENAME_GET = b'dg'
ACTION_DIR_RENAME_MOVE_LOCAL = b'dm'
ACTION_KEEP = b'k'
ACTION_EXEC = b'e'
ACTION_CREATED_MERGE = b'cm'
class shelvedfile(object): class shelvedfile(object):
"""Helper for the file storing a single shelve """Helper for the file storing a single shelve
Handles common functions on shelve files (.hg/.patch) using Handles common functions on shelve files (.hg/.patch) using
the vfs layer""" the vfs layer"""
def __init__(self, repo, name, filetype=None): def __init__(self, repo, name, filetype=None):
self.repo = repo self.repo = repo
self.name = name self.name = name
info = {'node': nodemod.hex(node)} info = {'node': nodemod.hex(node)}
shelvedfile(repo, name, 'shelve').writeinfo(info) shelvedfile(repo, name, 'shelve').writeinfo(info)
bases = list(mutableancestors(repo[node])) bases = list(mutableancestors(repo[node]))
shelvedfile(repo, name, 'hg').writebundle(bases, node) shelvedfile(repo, name, 'hg').writebundle(bases, node)
with shelvedfile(repo, name, patchextension).opener('wb') as fp: with shelvedfile(repo, name, patchextension).opener('wb') as fp:
cmdutil.exportfile(repo, [node], fp, opts=mdiff.diffopts(git=True), cmdutil.exportfile(repo, [node], fp, opts=mdiff.diffopts(git=True),
match=match) match=match)
def _storeunresolvedmerge(ui, repo, name=None, extra=None):
"""Store the mergestate information in changeset extra
This will clear the mergestate and also stores the mergestate
information for later restoration.
"""
ms = merge.mergestate.read(repo)
records = ms._readrecords()
allowlist = (RECORD_LOCAL, RECORD_OTHER, RECORD_MERGED)
mergedata = ''
for key, data in records:
assert len(key) == 1
if key not in allowlist:
key, data = RECORD_OVERRIDE, '%s%s' % (key, data)
format = '>sI%is' % len(data)
mergedata = ''.join([mergedata, _pack(format, key, len(data), data)])
extra['mergerecords'] = mergedata
ms.reset()
def _includeunknownfiles(repo, pats, opts, extra): def _includeunknownfiles(repo, pats, opts, extra):
s = repo.status(match=scmutil.match(repo[None], pats, opts), s = repo.status(match=scmutil.match(repo[None], pats, opts),
unknown=True) unknown=True)
if s.unknown: if s.unknown:
extra['shelve_unknown'] = '\0'.join(s.unknown) extra['shelve_unknown'] = '\0'.join(s.unknown)
repo[None].add(s.unknown) repo[None].add(s.unknown)
def _finishshelve(repo, tr): def _finishshelve(repo, tr):