This is an archive of the discontinued Mercurial Phabricator instance.

Status	Author	Revision
Closed	SimonSapin	D11546 dirstate-v2: Add internal documentation
Closed	SimonSapin	D11545 dirstate-v2: Move data file info in the docket closer together
Closed	marmoute	D11608 dirstate-item: drop the legacy new_normal constructor
Closed	marmoute	D11607 dirstate-item: replace call to new_possibly_dirty
Closed	marmoute	D11606 dirstate-item: replace a call to new_possibly_dirty
Closed	marmoute	D11605 dirstate-item: drop the legacy new_possibly_dirty constructor
Closed	marmoute	D11604 dirstate-item: replace call to new_possibly_dirty
Closed	marmoute	D11603 dirstate-item: drop the legacy new_from_p2 constructor
Closed	marmoute	D11602 dirstate-item: replace call to new_from_p2
Closed	marmoute	D11601 dirstate-item: drop the legacy new_added constructor
Closed	marmoute	D11600 dirstate-item: replace call to new_added
Closed	marmoute	D11599 dirstate-item: drop the legacy new_merged constructor
Closed	marmoute	D11598 dirstate-item: replace call to new_merged
Closed	marmoute	D11597 dirstate-item: drop the `merged` property
Closed	marmoute	D11596 dirstate-item: replace another usage of `merged`
Closed	marmoute	D11595 dirstate-item: replace a `merged` usage with `from_p2`
Closed	marmoute	D11594 dirstate-item: drop the `from_p2` property
Closed	marmoute	D11593 dirstate-item: directly use `p2_info` in `v1_size`
Closed	marmoute	D11592 dirstate-item: use the `p2_info` property to replace more verbose call
Closed	marmoute	D11591 status: process `from_p2` file the same as `merged` one
Closed	marmoute	D11590 dirstate: drop an incorrect comment
Closed	marmoute	D11589 dirstate: drop some duplicated code
Abandoned	pulkit	D11588 dirstate: drop some duplicated code
Closed	marmoute	D11587 dirstate: align the dirstate's API to the lower level ones
Closed	marmoute	D11586 dirstate-item: introduce a `p1_tracked` property
Closed	marmoute	D11585 dirstate-item: introduce a `p2_info` property that combine two others
Closed	marmoute	D11584 dirstate: narrow gathering of parent data
Closed	marmoute	D11583 dirstate: align the dirstatemap's API to the data change
Closed	marmoute	D11558 dirstate-v2: Store a bitfield on disk instead of v1-like state
Closed	marmoute	D11557 dirstate-item: change the internal storage and constructor value
Closed	marmoute	D11582 dirstatemap: drop legacy method on the dirstatemap wrapper
Closed	marmoute	D11581 dirstatemap: align the Rust wrapper implementation of `setparent`
Closed	marmoute	D11580 dirstatemap: fix copymap.pop in Rust to return the value it pops
Closed	marmoute	D11579 dirstate-item: implement `drop_merge_data` on the Rust DirstateItem
Closed	marmoute	D11578 dirstatemap: use a common implement for reset_state
Closed	marmoute	D11577 dirstatemap: add a common `_drop_entry` method for dirstatemap
Closed	marmoute	D11576 dirstatemap: use common code for set_clean
Closed	marmoute	D11575 dirstatemap: use common code for set_possibly_dirty
Closed	marmoute	D11574 dirstatemap: use a common implement for set_tracked
Closed	marmoute	D11573 dirstatemap: add a common `_insert_entry` method for dirstatemap
Closed	marmoute	D11572 dirstatemap: use a common implementation for `dirstatemap.set_untracked`
Closed	marmoute	D11571 dirstatemap: add a common `_refresh_entry` method for dirstatemap
Closed	marmoute	D11570 dirstatemap: create `_dirs_incr/_dirs_decr` methods on the common class
Closed	marmoute	D11569 dirstatemap: small rework of the `set_untracked` method
Closed	marmoute	D11568 dirstatemap: arrange methods by category
Closed	marmoute	D11567 dirstatemap: move a multiple simple functions in the common class
Closed	marmoute	D11566 dirstatemap: rename `_rustmap` to `_map`
Closed	marmoute	D11565 dirstatemap: use a common __init__ for dirstatemap
Closed	marmoute	D11564 dirstatemap: introduce a common base for the dirstatemap class

Diff 30623

mercurial/dirstate.py

	clean,			clean,
	ignored,			ignored,
	unknown,			unknown,
	warnings,			warnings,
	bad,			bad,
	traversed,			traversed,
	dirty,			dirty,
	) = rustmod.status(			) = rustmod.status(
	self._map._rustmap,			self._map._map,
	matcher,			matcher,
	self._rootdir,			self._rootdir,
	self._ignorefiles(),			self._ignorefiles(),
	self._checkexec,			self._checkexec,
	self._lastnormaltime,			self._lastnormaltime,
	bool(list_clean),			bool(list_clean),
	bool(list_ignored),			bool(list_ignored),
	bool(list_unknown),			bool(list_unknown),
	return (lookup, status)			return (lookup, status)

	def matches(self, match):			def matches(self, match):
	"""			"""
	return files in the dirstate (in whatever state) filtered by match			return files in the dirstate (in whatever state) filtered by match
	"""			"""
	dmap = self._map			dmap = self._map
	if rustmod is not None:			if rustmod is not None:
	dmap = self._map._rustmap			dmap = self._map._map

	if match.always():			if match.always():
	return dmap.keys()			return dmap.keys()
	files = match.files()			files = match.files()
	if match.isexact():			if match.isexact():
	# fast path -- filter the other way around, since typically files is			# fast path -- filter the other way around, since typically files is
	# much smaller than dmap			# much smaller than dmap
	return [f for f in files if f in dmap]			return [f for f in files if f in dmap]

mercurial/dirstatemap.py

	elif possibly_dirty:			elif possibly_dirty:
	item = DirstateItem.new_possibly_dirty()			item = DirstateItem.new_possibly_dirty()
	else:			else:
	assert size is not None			assert size is not None
	assert mtime is not None			assert mtime is not None
	size = size & rangemask			size = size & rangemask
	mtime = mtime & rangemask			mtime = mtime & rangemask
	item = DirstateItem.new_normal(mode, size, mtime)			item = DirstateItem.new_normal(mode, size, mtime)
	self._rustmap.addfile(f, item)			self._map.addfile(f, item)
	if added:			if added:
	self.copymap.pop(f, None)			self.copymap.pop(f, None)

	def reset_state(			def reset_state(
	self,			self,
	filename,			filename,
	wc_tracked=False,			wc_tracked=False,
	p1_tracked=False,			p1_tracked=False,
	b'`merged` argument incompatible with `clean_p1`/`clean_p2`'			b'`merged` argument incompatible with `clean_p1`/`clean_p2`'
	)			)
	raise error.ProgrammingError(msg)			raise error.ProgrammingError(msg)
	# copy information are now outdated			# copy information are now outdated
	# (maybe new information should be in directly passed to this function)			# (maybe new information should be in directly passed to this function)
	self.copymap.pop(filename, None)			self.copymap.pop(filename, None)

	if not (p1_tracked or p2_tracked or wc_tracked):			if not (p1_tracked or p2_tracked or wc_tracked):
	self._rustmap.drop_item_and_copy_source(filename)			self._map.drop_item_and_copy_source(filename)
	elif merged:			elif merged:
	# XXX might be merged and removed ?			# XXX might be merged and removed ?
	entry = self.get(filename)			entry = self.get(filename)
	if entry is not None and entry.tracked:			if entry is not None and entry.tracked:
	# XXX mostly replicate dirstate.other parent. We should get			# XXX mostly replicate dirstate.other parent. We should get
	# the higher layer to pass us more reliable data where `merged`			# the higher layer to pass us more reliable data where `merged`
	# actually mean merged. Dropping the else clause will show			# actually mean merged. Dropping the else clause will show
	# failure in `test-graft.t`			# failure in `test-graft.t`
	def set_tracked(self, filename):			def set_tracked(self, filename):
	new = False			new = False
	entry = self.get(filename)			entry = self.get(filename)
	if entry is None:			if entry is None:
	self.addfile(filename, added=True)			self.addfile(filename, added=True)
	new = True			new = True
	elif not entry.tracked:			elif not entry.tracked:
	entry.set_tracked()			entry.set_tracked()
	self._rustmap.set_dirstate_item(filename, entry)			self._map.set_dirstate_item(filename, entry)
	new = True			new = True
	else:			else:
	# XXX This is probably overkill for more case, but we need this to			# XXX This is probably overkill for more case, but we need this to
	# fully replace the `normallookup` call with `set_tracked` one.			# fully replace the `normallookup` call with `set_tracked` one.
	# Consider smoothing this in the future.			# Consider smoothing this in the future.
	self.set_possibly_dirty(filename)			self.set_possibly_dirty(filename)
	return new			return new

	def set_untracked(self, f):			def set_untracked(self, f):
	"""Mark a file as no longer tracked in the dirstate map"""			"""Mark a file as no longer tracked in the dirstate map"""
	# in merge is only trigger more logic, so it "fine" to pass it.			# in merge is only trigger more logic, so it "fine" to pass it.
	#			#
	# the inner rust dirstate map code need to be adjusted once the API			# the inner rust dirstate map code need to be adjusted once the API
	# for dirstate/dirstatemap/DirstateItem is a bit more settled			# for dirstate/dirstatemap/DirstateItem is a bit more settled
	entry = self.get(f)			entry = self.get(f)
	if entry is None:			if entry is None:
	return False			return False
	else:			else:
	if entry.added:			if entry.added:
	self._rustmap.drop_item_and_copy_source(f)			self._map.drop_item_and_copy_source(f)
	else:			else:
	self._rustmap.removefile(f, in_merge=True)			self._map.removefile(f, in_merge=True)
	return True			return True

	def removefile(self, args, *kwargs):			def removefile(self, args, *kwargs):
	return self._rustmap.removefile(args, *kwargs)			return self._map.removefile(args, *kwargs)

	def get(self, args, *kwargs):			def get(self, args, *kwargs):
	return self._rustmap.get(args, *kwargs)			return self._map.get(args, *kwargs)

	@property			@property
	def copymap(self):			def copymap(self):
	return self._rustmap.copymap()			return self._map.copymap()

	def debug_iter(self, all):			def debug_iter(self, all):
	"""			"""
	Return an iterator of (filename, state, mode, size, mtime) tuples			Return an iterator of (filename, state, mode, size, mtime) tuples

	`all`: also include with `state == b' '` dirstate tree nodes that			`all`: also include with `state == b' '` dirstate tree nodes that
	don't have an associated `DirstateItem`.			don't have an associated `DirstateItem`.

	"""			"""
	return self._rustmap.debug_iter(all)			return self._map.debug_iter(all)

	def preload(self):			def preload(self):
	self._rustmap			self._map

	def clear(self):			def clear(self):
	self._rustmap.clear()			self._map.clear()
	self.setparents(			self.setparents(
	self._nodeconstants.nullid, self._nodeconstants.nullid			self._nodeconstants.nullid, self._nodeconstants.nullid
	)			)
	util.clearcachedproperty(self, b"_dirs")			util.clearcachedproperty(self, b"_dirs")
	util.clearcachedproperty(self, b"_alldirs")			util.clearcachedproperty(self, b"_alldirs")
	util.clearcachedproperty(self, b"dirfoldmap")			util.clearcachedproperty(self, b"dirfoldmap")

	def items(self):			def items(self):
	return self._rustmap.items()			return self._map.items()

	def keys(self):			def keys(self):
	return iter(self._rustmap)			return iter(self._map)

	def __contains__(self, key):			def __contains__(self, key):
	return key in self._rustmap			return key in self._map

	def __getitem__(self, item):			def __getitem__(self, item):
	return self._rustmap[item]			return self._map[item]

	def __len__(self):			def __len__(self):
	return len(self._rustmap)			return len(self._map)

	def __iter__(self):			def __iter__(self):
	return iter(self._rustmap)			return iter(self._map)

	# forward for python2,3 compat			# forward for python2,3 compat
	iteritems = items			iteritems = items

	def _opendirstatefile(self):			def _opendirstatefile(self):
	fp, mode = txnutil.trypending(			fp, mode = txnutil.trypending(
	self._root, self._opener, self._filename			self._root, self._opener, self._filename
	)			)
	if fold_p2:			if fold_p2:
	# Collect into an intermediate list to avoid a `RuntimeError`			# Collect into an intermediate list to avoid a `RuntimeError`
	# exception due to mutation during iteration.			# exception due to mutation during iteration.
	# TODO: move this the whole loop to Rust where `iter_mut`			# TODO: move this the whole loop to Rust where `iter_mut`
	# enables in-place mutation of elements of a collection while			# enables in-place mutation of elements of a collection while
	# iterating it, without mutating the collection itself.			# iterating it, without mutating the collection itself.
	candidatefiles = [			candidatefiles = [
	(f, s)			(f, s)
	for f, s in self._rustmap.items()			for f, s in self._map.items()
	if s.merged or s.from_p2			if s.merged or s.from_p2
	]			]
	for f, s in candidatefiles:			for f, s in candidatefiles:
	# Discard "merged" markers when moving away from a merge state			# Discard "merged" markers when moving away from a merge state
	if s.merged:			if s.merged:
	source = self.copymap.get(f)			source = self.copymap.get(f)
	if source:			if source:
	copies[f] = source			copies[f] = source
	b'dirstate only has a docket in v2 format'			b'dirstate only has a docket in v2 format'
	)			)
	self._docket = docketmod.DirstateDocket.parse(			self._docket = docketmod.DirstateDocket.parse(
	self._readdirstatefile(), self._nodeconstants			self._readdirstatefile(), self._nodeconstants
	)			)
	return self._docket			return self._docket

	@propertycache			@propertycache
	def _rustmap(self):			def _map(self):
	"""			"""
	Fills the Dirstatemap when called.			Fills the Dirstatemap when called.
	"""			"""
	# ignore HG_PENDING because identity is used only for writing			# ignore HG_PENDING because identity is used only for writing
	self.identity = util.filestat.frompath(			self.identity = util.filestat.frompath(
	self._opener.join(self._filename)			self._opener.join(self._filename)
	)			)

	if self._use_dirstate_v2:			if self._use_dirstate_v2:
	if self.docket.uuid:			if self.docket.uuid:
	# TODO: use mmap when possible			# TODO: use mmap when possible
	data = self._opener.read(self.docket.data_filename())			data = self._opener.read(self.docket.data_filename())
	else:			else:
	data = b''			data = b''
	self._rustmap = rustmod.DirstateMap.new_v2(			self._map = rustmod.DirstateMap.new_v2(
	data, self.docket.data_size, self.docket.tree_metadata			data, self.docket.data_size, self.docket.tree_metadata
	)			)
	parents = self.docket.parents			parents = self.docket.parents
	else:			else:
	self._rustmap, parents = rustmod.DirstateMap.new_v1(			self._map, parents = rustmod.DirstateMap.new_v1(
	self._readdirstatefile()			self._readdirstatefile()
	)			)

	if parents and not self._dirtyparents:			if parents and not self._dirtyparents:
	self.setparents(*parents)			self.setparents(*parents)

	self.__contains__ = self._rustmap.__contains__			self.__contains__ = self._map.__contains__
	self.__getitem__ = self._rustmap.__getitem__			self.__getitem__ = self._map.__getitem__
	self.get = self._rustmap.get			self.get = self._map.get
	return self._rustmap			return self._map

	def write(self, tr, st, now):			def write(self, tr, st, now):
	if not self._use_dirstate_v2:			if not self._use_dirstate_v2:
	p1, p2 = self.parents()			p1, p2 = self.parents()
	packed = self._rustmap.write_v1(p1, p2, now)			packed = self._map.write_v1(p1, p2, now)
	st.write(packed)			st.write(packed)
	st.close()			st.close()
	self._dirtyparents = False			self._dirtyparents = False
	return			return

	# We can only append to an existing data file if there is one			# We can only append to an existing data file if there is one
	can_append = self.docket.uuid is not None			can_append = self.docket.uuid is not None
	packed, meta, append = self._rustmap.write_v2(now, can_append)			packed, meta, append = self._map.write_v2(now, can_append)
	if append:			if append:
	docket = self.docket			docket = self.docket
	data_filename = docket.data_filename()			data_filename = docket.data_filename()
	if tr:			if tr:
	tr.add(data_filename, docket.data_size)			tr.add(data_filename, docket.data_size)
	with self._opener(data_filename, b'r+b') as fp:			with self._opener(data_filename, b'r+b') as fp:
	fp.seek(docket.data_size)			fp.seek(docket.data_size)
	assert fp.tell() == docket.data_size			assert fp.tell() == docket.data_size
	unlink = lambda _tr=None: self._opener.unlink(data_filename)			unlink = lambda _tr=None: self._opener.unlink(data_filename)
	if tr:			if tr:
	category = b"dirstate-v2-clean-" + old_docket.uuid			category = b"dirstate-v2-clean-" + old_docket.uuid
	tr.addpostclose(category, unlink)			tr.addpostclose(category, unlink)
	else:			else:
	unlink()			unlink()
	self._docket = new_docket			self._docket = new_docket
	# Reload from the newly-written file			# Reload from the newly-written file
	util.clearcachedproperty(self, b"_rustmap")			util.clearcachedproperty(self, b"_map")
	self._dirtyparents = False			self._dirtyparents = False

	@propertycache			@propertycache
	def filefoldmap(self):			def filefoldmap(self):
	"""Returns a dictionary mapping normalized case paths to their			"""Returns a dictionary mapping normalized case paths to their
	non-normalized versions.			non-normalized versions.
	"""			"""
	return self._rustmap.filefoldmapasdict()			return self._map.filefoldmapasdict()

	def hastrackeddir(self, d):			def hastrackeddir(self, d):
	return self._rustmap.hastrackeddir(d)			return self._map.hastrackeddir(d)

	def hasdir(self, d):			def hasdir(self, d):
	return self._rustmap.hasdir(d)			return self._map.hasdir(d)

	@propertycache			@propertycache
	def identity(self):			def identity(self):
	self._rustmap			self._map
	return self.identity			return self.identity

	@propertycache			@propertycache
	def dirfoldmap(self):			def dirfoldmap(self):
	f = {}			f = {}
	normcase = util.normcase			normcase = util.normcase
	for name in self._rustmap.tracked_dirs():			for name in self._map.tracked_dirs():
	f[normcase(name)] = name			f[normcase(name)] = name
	return f			return f

	def set_possibly_dirty(self, filename):			def set_possibly_dirty(self, filename):
	"""record that the current state of the file on disk is unknown"""			"""record that the current state of the file on disk is unknown"""
	entry = self[filename]			entry = self[filename]
	entry.set_possibly_dirty()			entry.set_possibly_dirty()
	self._rustmap.set_dirstate_item(filename, entry)			self._map.set_dirstate_item(filename, entry)

	def set_clean(self, filename, mode, size, mtime):			def set_clean(self, filename, mode, size, mtime):
	"""mark a file as back to a clean state"""			"""mark a file as back to a clean state"""
	entry = self[filename]			entry = self[filename]
	mtime = mtime & rangemask			mtime = mtime & rangemask
	size = size & rangemask			size = size & rangemask
	entry.set_clean(mode, size, mtime)			entry.set_clean(mode, size, mtime)
	self._rustmap.set_dirstate_item(filename, entry)			self._map.set_dirstate_item(filename, entry)
	self._rustmap.copymap().pop(filename, None)			self._map.copymap().pop(filename, None)

	def __setitem__(self, key, value):			def __setitem__(self, key, value):
	assert isinstance(value, DirstateItem)			assert isinstance(value, DirstateItem)
	self._rustmap.set_dirstate_item(key, value)			self._map.set_dirstate_item(key, value)

Diff	ID	Description	Created	Lint	Unit
Base		Base
Diff 1	30554		Oct 2 2021, 11:04 AM	★	★
Diff 2	30623	rHG5fc2dfb073d664632c1cdcaa02a6a2bb8414a243	Oct 1 2021, 11:10 AM	★	★

This is an archive of the discontinued Mercurial Phabricator instance.

dirstatemap: rename `_rustmap` to `_map`ClosedPublic

Details

Diff Detail

Event Timeline

Revision ContentsChangeset List

Diff 30623

mercurial/dirstate.py

mercurial/dirstatemap.py

dirstatemap: rename `_rustmap` to `_map`
ClosedPublic

Revision Contents
Changeset List