The dirstate dirs object is owned by the map, so move management of that object
there. A future implementation of the dirstate will manage the dirs object
differently.
| Automatic diff as part of commit; lint not applicable. |
| Automatic diff as part of commit; unit tests not applicable. |
| def copied(self, file): | def copied(self, file): | ||||
| return self._map.copymap.get(file, None) | return self._map.copymap.get(file, None) | ||||
| def copies(self): | def copies(self): | ||||
| return self._map.copymap | return self._map.copymap | ||||
| def _droppath(self, f): | def _droppath(self, f): | ||||
| if self[f] not in "?r" and "dirs" in self._map.__dict__: | |||||
| self._map.dirs.delpath(f) | |||||
| if "filefoldmap" in self._map.__dict__: | if "filefoldmap" in self._map.__dict__: | ||||
| normed = util.normcase(f) | normed = util.normcase(f) | ||||
| if normed in self._map.filefoldmap: | if normed in self._map.filefoldmap: | ||||
| del self._map.filefoldmap[normed] | del self._map.filefoldmap[normed] | ||||
| self._updatedfiles.add(f) | self._updatedfiles.add(f) | ||||
| def _addpath(self, f, state, mode, size, mtime): | def _addpath(self, f, state, mode, size, mtime): | ||||
| oldstate = self[f] | oldstate = self[f] | ||||
| if state == 'a' or oldstate == 'r': | if state == 'a' or oldstate == 'r': | ||||
| scmutil.checkfilename(f) | scmutil.checkfilename(f) | ||||
| if f in self._map.dirs: | if f in self._map.dirs: | ||||
| raise error.Abort(_('directory %r already in dirstate') % f) | raise error.Abort(_('directory %r already in dirstate') % f) | ||||
| # shadows | # shadows | ||||
| for d in util.finddirs(f): | for d in util.finddirs(f): | ||||
| if d in self._map.dirs: | if d in self._map.dirs: | ||||
| break | break | ||||
| entry = self._map.get(d) | entry = self._map.get(d) | ||||
| if entry is not None and entry[0] != 'r': | if entry is not None and entry[0] != 'r': | ||||
| raise error.Abort( | raise error.Abort( | ||||
| _('file %r in dirstate clashes with %r') % (d, f)) | _('file %r in dirstate clashes with %r') % (d, f)) | ||||
| if oldstate in "?r" and "dirs" in self._map.__dict__: | |||||
| self._map.dirs.addpath(f) | |||||
| self._dirty = True | self._dirty = True | ||||
| self._updatedfiles.add(f) | self._updatedfiles.add(f) | ||||
| self._map.addfile(f, state, mode, size, mtime) | self._map.addfile(f, oldstate, state, mode, size, mtime) | ||||
| def normal(self, f): | def normal(self, f): | ||||
| '''Mark a file normal and clean.''' | '''Mark a file normal and clean.''' | ||||
| s = os.lstat(self._join(f)) | s = os.lstat(self._join(f)) | ||||
| mtime = s.st_mtime | mtime = s.st_mtime | ||||
| self._addpath(f, 'n', s.st_mode, | self._addpath(f, 'n', s.st_mode, | ||||
| s.st_size & _rangemask, mtime & _rangemask) | s.st_size & _rangemask, mtime & _rangemask) | ||||
| self._map.copymap.pop(f, None) | self._map.copymap.pop(f, None) | ||||
| '''Mark a file added.''' | '''Mark a file added.''' | ||||
| self._addpath(f, 'a', 0, -1, -1) | self._addpath(f, 'a', 0, -1, -1) | ||||
| self._map.copymap.pop(f, None) | self._map.copymap.pop(f, None) | ||||
| def remove(self, f): | def remove(self, f): | ||||
| '''Mark a file removed.''' | '''Mark a file removed.''' | ||||
| self._dirty = True | self._dirty = True | ||||
| self._droppath(f) | self._droppath(f) | ||||
| oldstate = self[f] | |||||
| size = 0 | size = 0 | ||||
| if self._pl[1] != nullid: | if self._pl[1] != nullid: | ||||
| entry = self._map.get(f) | entry = self._map.get(f) | ||||
| if entry is not None: | if entry is not None: | ||||
| # backup the previous state | # backup the previous state | ||||
| if entry[0] == 'm': # merge | if entry[0] == 'm': # merge | ||||
| size = -1 | size = -1 | ||||
| elif entry[0] == 'n' and entry[2] == -2: # other parent | elif entry[0] == 'n' and entry[2] == -2: # other parent | ||||
| size = -2 | size = -2 | ||||
| self._map.otherparentset.add(f) | self._map.otherparentset.add(f) | ||||
| self._map.removefile(f, size) | self._map.removefile(f, oldstate, size) | ||||
| if size == 0: | if size == 0: | ||||
| self._map.copymap.pop(f, None) | self._map.copymap.pop(f, None) | ||||
| def merge(self, f): | def merge(self, f): | ||||
| '''Mark a file merged.''' | '''Mark a file merged.''' | ||||
| if self._pl[1] == nullid: | if self._pl[1] == nullid: | ||||
| return self.normallookup(f) | return self.normallookup(f) | ||||
| return self.otherparent(f) | return self.otherparent(f) | ||||
| def drop(self, f): | def drop(self, f): | ||||
| '''Drop a file from the dirstate''' | '''Drop a file from the dirstate''' | ||||
| if self._map.dropfile(f): | oldstate = self[f] | ||||
| if self._map.dropfile(f, oldstate): | |||||
| self._dirty = True | self._dirty = True | ||||
| self._droppath(f) | self._droppath(f) | ||||
| self._map.copymap.pop(f, None) | self._map.copymap.pop(f, None) | ||||
| def _discoverpath(self, path, normed, ignoremissing, exists, storemap): | def _discoverpath(self, path, normed, ignoremissing, exists, storemap): | ||||
| if exists is None: | if exists is None: | ||||
| exists = os.path.lexists(os.path.join(self._root, path)) | exists = os.path.lexists(os.path.join(self._root, path)) | ||||
| if not exists: | if not exists: | ||||
| files in the dirstate, excluding any files that are marked as removed. | files in the dirstate, excluding any files that are marked as removed. | ||||
| - `filefoldmap` is a dict mapping normalized filenames to the denormalized | - `filefoldmap` is a dict mapping normalized filenames to the denormalized | ||||
| form that they appear as in the dirstate. | form that they appear as in the dirstate. | ||||
| - `dirfoldmap` is a dict mapping normalized directory names to the | - `dirfoldmap` is a dict mapping normalized directory names to the | ||||
| denormalized form that they appear as in the dirstate. | denormalized form that they appear as in the dirstate. | ||||
| Once instantiated, the dirs, filefoldmap and dirfoldmap views must be | Once instantiated, the filefoldmap and dirfoldmap views must be maintained | ||||
| maintained by the caller. | by the caller. | ||||
| """ | """ | ||||
| def __init__(self, ui, opener, root): | def __init__(self, ui, opener, root): | ||||
| self._ui = ui | self._ui = ui | ||||
| self._opener = opener | self._opener = opener | ||||
| self._root = root | self._root = root | ||||
| self._filename = 'dirstate' | self._filename = 'dirstate' | ||||
| def keys(self): | def keys(self): | ||||
| return self._map.keys() | return self._map.keys() | ||||
| def preload(self): | def preload(self): | ||||
| """Loads the underlying data, if it's not already loaded""" | """Loads the underlying data, if it's not already loaded""" | ||||
| self._map | self._map | ||||
| def addfile(self, f, state, mode, size, mtime): | def addfile(self, f, oldstate, state, mode, size, mtime): | ||||
| """Add a tracked file to the dirstate.""" | """Add a tracked file to the dirstate.""" | ||||
| if oldstate in "?r" and "dirs" in self.__dict__: | |||||
| self.dirs.addpath(f) | |||||
| self._map[f] = dirstatetuple(state, mode, size, mtime) | self._map[f] = dirstatetuple(state, mode, size, mtime) | ||||
| if state != 'n' or mtime == -1: | if state != 'n' or mtime == -1: | ||||
| self.nonnormalset.add(f) | self.nonnormalset.add(f) | ||||
| if size == -2: | if size == -2: | ||||
| self.otherparentset.add(f) | self.otherparentset.add(f) | ||||
| def removefile(self, f, size): | def removefile(self, f, oldstate, size): | ||||
| """ | """ | ||||
| Mark a file as removed in the dirstate. | Mark a file as removed in the dirstate. | ||||
| The `size` parameter is used to store sentinel values that indicate | The `size` parameter is used to store sentinel values that indicate | ||||
| the file's previous state. In the future, we should refactor this | the file's previous state. In the future, we should refactor this | ||||
| to be more explicit about what that state is. | to be more explicit about what that state is. | ||||
| """ | """ | ||||
| if oldstate not in "?r" and "dirs" in self.__dict__: | |||||
| self.dirs.delpath(f) | |||||
| self._map[f] = dirstatetuple('r', 0, size, 0) | self._map[f] = dirstatetuple('r', 0, size, 0) | ||||
| self.nonnormalset.add(f) | self.nonnormalset.add(f) | ||||
| def dropfile(self, f): | def dropfile(self, f, oldstate): | ||||
| """ | """ | ||||
| Remove a file from the dirstate. Returns True if the file was | Remove a file from the dirstate. Returns True if the file was | ||||
| previously recorded. | previously recorded. | ||||
| """ | """ | ||||
| exists = self._map.pop(f, None) is not None | exists = self._map.pop(f, None) is not None | ||||
| if exists: | |||||
| if oldstate != "r" and "dirs" in self.__dict__: | |||||
| self.dirs.delpath(f) | |||||
| self.nonnormalset.discard(f) | self.nonnormalset.discard(f) | ||||
| return exists | return exists | ||||
| def clearambiguoustimes(self, files, now): | def clearambiguoustimes(self, files, now): | ||||
| for f in files: | for f in files: | ||||
| e = self.get(f) | e = self.get(f) | ||||
| if e is not None and e[0] == 'n' and e[3] == now: | if e is not None and e[0] == 'n' and e[3] == now: | ||||
| self._map[f] = dirstatetuple(e[0], e[1], e[2], -1) | self._map[f] = dirstatetuple(e[0], e[1], e[2], -1) | ||||