| Alphare |
| hg-reviewers |
This is a lot of book keeping for something that was only used to clear
ambiguous time. Since this is no no longer in use, we can drop it.
| Automatic diff as part of commit; lint not applicable. |
| Automatic diff as part of commit; unit tests not applicable. |
| Path | Packages | |||
|---|---|---|---|---|
| M | mercurial/dirstate.py (22 lines) |
| Status | Author | Revision | |
|---|---|---|---|
| Closed | marmoute | ||
| Closed | marmoute | ||
| Closed | marmoute | ||
| Closed | marmoute | ||
| Closed | marmoute | ||
| Closed | marmoute | ||
| Closed | SimonSapin | ||
| Closed | SimonSapin | ||
| Closed | SimonSapin | ||
| Closed | SimonSapin | ||
| Closed | SimonSapin | ||
| Closed | SimonSapin | ||
| Closed | SimonSapin | ||
| Closed | SimonSapin | ||
| Closed | SimonSapin |
| self._lastnormaltime = 0 | self._lastnormaltime = 0 | ||||
| self._ui = ui | self._ui = ui | ||||
| self._filecache = {} | self._filecache = {} | ||||
| self._parentwriters = 0 | self._parentwriters = 0 | ||||
| self._filename = b'dirstate' | self._filename = b'dirstate' | ||||
| self._pendingfilename = b'%s.pending' % self._filename | self._pendingfilename = b'%s.pending' % self._filename | ||||
| self._plchangecallbacks = {} | self._plchangecallbacks = {} | ||||
| self._origpl = None | self._origpl = None | ||||
| self._updatedfiles = set() | |||||
| self._mapcls = dirstatemap.dirstatemap | self._mapcls = dirstatemap.dirstatemap | ||||
| # Access and cache cwd early, so we don't access it for the first time | # Access and cache cwd early, so we don't access it for the first time | ||||
| # after a working-copy update caused it to not exist (accessing it then | # after a working-copy update caused it to not exist (accessing it then | ||||
| # raises an exception). | # raises an exception). | ||||
| self._cwd | self._cwd | ||||
| def prefetch_parents(self): | def prefetch_parents(self): | ||||
| """make sure the parents are loaded | """make sure the parents are loaded | ||||
| possibly_dirty=True, | possibly_dirty=True, | ||||
| ) | ) | ||||
| # Also fix up otherparent markers | # Also fix up otherparent markers | ||||
| elif s.from_p2: | elif s.from_p2: | ||||
| source = self._map.copymap.get(f) | source = self._map.copymap.get(f) | ||||
| if source: | if source: | ||||
| copies[f] = source | copies[f] = source | ||||
| self._check_new_tracked_filename(f) | self._check_new_tracked_filename(f) | ||||
| self._updatedfiles.add(f) | |||||
| self._map.reset_state( | self._map.reset_state( | ||||
| f, | f, | ||||
| p1_tracked=False, | p1_tracked=False, | ||||
| wc_tracked=True, | wc_tracked=True, | ||||
| ) | ) | ||||
| return copies | return copies | ||||
| def setbranch(self, branch): | def setbranch(self, branch): | ||||
| rereads the dirstate. Use localrepo.invalidatedirstate() if you want to | rereads the dirstate. Use localrepo.invalidatedirstate() if you want to | ||||
| check whether the dirstate has changed before rereading it.""" | check whether the dirstate has changed before rereading it.""" | ||||
| for a in ("_map", "_branch", "_ignore"): | for a in ("_map", "_branch", "_ignore"): | ||||
| if a in self.__dict__: | if a in self.__dict__: | ||||
| delattr(self, a) | delattr(self, a) | ||||
| self._lastnormaltime = 0 | self._lastnormaltime = 0 | ||||
| self._dirty = False | self._dirty = False | ||||
| self._updatedfiles.clear() | |||||
| self._parentwriters = 0 | self._parentwriters = 0 | ||||
| self._origpl = None | self._origpl = None | ||||
| def copy(self, source, dest): | def copy(self, source, dest): | ||||
| """Mark dest as a copy of source. Unmark dest if source is None.""" | """Mark dest as a copy of source. Unmark dest if source is None.""" | ||||
| if source == dest: | if source == dest: | ||||
| return | return | ||||
| self._dirty = True | self._dirty = True | ||||
| if source is not None: | if source is not None: | ||||
| self._map.copymap[dest] = source | self._map.copymap[dest] = source | ||||
| self._updatedfiles.add(source) | else: | ||||
| self._updatedfiles.add(dest) | self._map.copymap.pop(dest, None) | ||||
| elif self._map.copymap.pop(dest, None): | |||||
| self._updatedfiles.add(dest) | |||||
| 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 | ||||
| @requires_no_parents_change | @requires_no_parents_change | ||||
| def set_tracked(self, filename): | def set_tracked(self, filename): | ||||
| """a "public" method for generic code to mark a file as tracked | """a "public" method for generic code to mark a file as tracked | ||||
| This function is to be called outside of "update/merge" case. For | This function is to be called outside of "update/merge" case. For | ||||
| example by a command like `hg add X`. | example by a command like `hg add X`. | ||||
| return True the file was previously untracked, False otherwise. | return True the file was previously untracked, False otherwise. | ||||
| """ | """ | ||||
| self._dirty = True | self._dirty = True | ||||
| self._updatedfiles.add(filename) | |||||
| entry = self._map.get(filename) | entry = self._map.get(filename) | ||||
| if entry is None or not entry.tracked: | if entry is None or not entry.tracked: | ||||
| self._check_new_tracked_filename(filename) | self._check_new_tracked_filename(filename) | ||||
| return self._map.set_tracked(filename) | return self._map.set_tracked(filename) | ||||
| @requires_no_parents_change | @requires_no_parents_change | ||||
| def set_untracked(self, filename): | def set_untracked(self, filename): | ||||
| """a "public" method for generic code to mark a file as untracked | """a "public" method for generic code to mark a file as untracked | ||||
| This function is to be called outside of "update/merge" case. For | This function is to be called outside of "update/merge" case. For | ||||
| example by a command like `hg remove X`. | example by a command like `hg remove X`. | ||||
| return True the file was previously tracked, False otherwise. | return True the file was previously tracked, False otherwise. | ||||
| """ | """ | ||||
| ret = self._map.set_untracked(filename) | ret = self._map.set_untracked(filename) | ||||
| if ret: | if ret: | ||||
| self._dirty = True | self._dirty = True | ||||
| self._updatedfiles.add(filename) | |||||
| return ret | return ret | ||||
| @requires_no_parents_change | @requires_no_parents_change | ||||
| def set_clean(self, filename, parentfiledata=None): | def set_clean(self, filename, parentfiledata=None): | ||||
| """record that the current state of the file on disk is known to be clean""" | """record that the current state of the file on disk is known to be clean""" | ||||
| self._dirty = True | self._dirty = True | ||||
| self._updatedfiles.add(filename) | |||||
| if parentfiledata: | if parentfiledata: | ||||
| (mode, size, mtime) = parentfiledata | (mode, size, mtime) = parentfiledata | ||||
| else: | else: | ||||
| (mode, size, mtime) = self._get_filedata(filename) | (mode, size, mtime) = self._get_filedata(filename) | ||||
| if not self._map[filename].tracked: | if not self._map[filename].tracked: | ||||
| self._check_new_tracked_filename(filename) | self._check_new_tracked_filename(filename) | ||||
| self._map.set_clean(filename, mode, size, mtime) | self._map.set_clean(filename, mode, size, mtime) | ||||
| if mtime > self._lastnormaltime: | if mtime > self._lastnormaltime: | ||||
| # Remember the most recent modification timeslot for status(), | # Remember the most recent modification timeslot for status(), | ||||
| # to make sure we won't miss future size-preserving file content | # to make sure we won't miss future size-preserving file content | ||||
| # modifications that happen within the same timeslot. | # modifications that happen within the same timeslot. | ||||
| self._lastnormaltime = mtime | self._lastnormaltime = mtime | ||||
| @requires_no_parents_change | @requires_no_parents_change | ||||
| 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""" | ||||
| self._dirty = True | self._dirty = True | ||||
| self._updatedfiles.add(filename) | |||||
| self._map.set_possibly_dirty(filename) | self._map.set_possibly_dirty(filename) | ||||
| @requires_parents_change | @requires_parents_change | ||||
| def update_file_p1( | def update_file_p1( | ||||
| self, | self, | ||||
| filename, | filename, | ||||
| p1_tracked, | p1_tracked, | ||||
| ): | ): | ||||
| # the underlying reference might have changed, we will have to | # the underlying reference might have changed, we will have to | ||||
| # check it. | # check it. | ||||
| possibly_dirty = True | possibly_dirty = True | ||||
| elif not (p1_tracked or wc_tracked): | elif not (p1_tracked or wc_tracked): | ||||
| # the file is no longer relevant to anyone | # the file is no longer relevant to anyone | ||||
| if self._map.get(filename) is not None: | if self._map.get(filename) is not None: | ||||
| self._map.reset_state(filename) | self._map.reset_state(filename) | ||||
| self._dirty = True | self._dirty = True | ||||
| self._updatedfiles.add(filename) | |||||
| elif (not p1_tracked) and wc_tracked: | elif (not p1_tracked) and wc_tracked: | ||||
| if entry is not None and entry.added: | if entry is not None and entry.added: | ||||
| return # avoid dropping copy information (maybe?) | return # avoid dropping copy information (maybe?) | ||||
| elif p1_tracked and not wc_tracked: | elif p1_tracked and not wc_tracked: | ||||
| pass | pass | ||||
| else: | else: | ||||
| assert False, 'unreachable' | assert False, 'unreachable' | ||||
| # this mean we are doing call for file we do not really care about the | # this mean we are doing call for file we do not really care about the | ||||
| # data (eg: added or removed), however this should be a minor overhead | # data (eg: added or removed), however this should be a minor overhead | ||||
| # compared to the overall update process calling this. | # compared to the overall update process calling this. | ||||
| parentfiledata = None | parentfiledata = None | ||||
| if wc_tracked: | if wc_tracked: | ||||
| parentfiledata = self._get_filedata(filename) | parentfiledata = self._get_filedata(filename) | ||||
| self._updatedfiles.add(filename) | |||||
| self._map.reset_state( | self._map.reset_state( | ||||
| filename, | filename, | ||||
| wc_tracked, | wc_tracked, | ||||
| p1_tracked, | p1_tracked, | ||||
| possibly_dirty=possibly_dirty, | possibly_dirty=possibly_dirty, | ||||
| parentfiledata=parentfiledata, | parentfiledata=parentfiledata, | ||||
| ) | ) | ||||
| if ( | if ( | ||||
| msg = b'`merged` argument incompatible with `clean_p1`/`clean_p2`' | msg = b'`merged` argument incompatible with `clean_p1`/`clean_p2`' | ||||
| raise error.ProgrammingError(msg) | raise error.ProgrammingError(msg) | ||||
| # note: I do not think we need to double check name clash here since we | # note: I do not think we need to double check name clash here since we | ||||
| # are in a update/merge case that should already have taken care of | # are in a update/merge case that should already have taken care of | ||||
| # this. The test agrees | # this. The test agrees | ||||
| self._dirty = True | self._dirty = True | ||||
| self._updatedfiles.add(filename) | |||||
| need_parent_file_data = ( | need_parent_file_data = ( | ||||
| not (possibly_dirty or clean_p2 or merged) | not (possibly_dirty or clean_p2 or merged) | ||||
| and wc_tracked | and wc_tracked | ||||
| and p1_tracked | and p1_tracked | ||||
| ) | ) | ||||
| # this mean we are doing call for file we do not really care about the | # this mean we are doing call for file we do not really care about the | ||||
| if self._checkcase: | if self._checkcase: | ||||
| return self._normalize(path, isknown, ignoremissing) | return self._normalize(path, isknown, ignoremissing) | ||||
| return path | return path | ||||
| def clear(self): | def clear(self): | ||||
| self._map.clear() | self._map.clear() | ||||
| self._lastnormaltime = 0 | self._lastnormaltime = 0 | ||||
| self._updatedfiles.clear() | |||||
| self._dirty = True | self._dirty = True | ||||
| def rebuild(self, parent, allfiles, changedfiles=None): | def rebuild(self, parent, allfiles, changedfiles=None): | ||||
| if changedfiles is None: | if changedfiles is None: | ||||
| # Rebuild entire dirstate | # Rebuild entire dirstate | ||||
| to_lookup = allfiles | to_lookup = allfiles | ||||
| to_drop = [] | to_drop = [] | ||||
| lastnormaltime = self._lastnormaltime | lastnormaltime = self._lastnormaltime | ||||
| self.set_tracked(f) | self.set_tracked(f) | ||||
| else: | else: | ||||
| self._map.reset_state( | self._map.reset_state( | ||||
| f, | f, | ||||
| wc_tracked=True, | wc_tracked=True, | ||||
| p1_tracked=True, | p1_tracked=True, | ||||
| possibly_dirty=True, | possibly_dirty=True, | ||||
| ) | ) | ||||
| self._updatedfiles.add(f) | |||||
| for f in to_drop: | for f in to_drop: | ||||
| self._map.reset_state(f) | self._map.reset_state(f) | ||||
| self._updatedfiles.add(f) | |||||
| self._dirty = True | self._dirty = True | ||||
| def identity(self): | def identity(self): | ||||
| """Return identity of dirstate itself to detect changing in storage | """Return identity of dirstate itself to detect changing in storage | ||||
| If identity of previous dirstate is equal to this, writing | If identity of previous dirstate is equal to this, writing | ||||
| changes based on the former dirstate out can keep consistency. | changes based on the former dirstate out can keep consistency. | ||||
| # changes out, but also for dropping ambiguous timestamp. | # changes out, but also for dropping ambiguous timestamp. | ||||
| # delayed writing re-raise "ambiguous timestamp issue". | # delayed writing re-raise "ambiguous timestamp issue". | ||||
| # See also the wiki page below for detail: | # See also the wiki page below for detail: | ||||
| # https://www.mercurial-scm.org/wiki/DirstateTransactionPlan | # https://www.mercurial-scm.org/wiki/DirstateTransactionPlan | ||||
| # record when mtime start to be ambiguous | # record when mtime start to be ambiguous | ||||
| now = _getfsnow(self._opener) | now = _getfsnow(self._opener) | ||||
| # emulate that all 'dirstate.normal' results are written out | |||||
| self._updatedfiles.clear() | |||||
| # delay writing in-memory changes out | # delay writing in-memory changes out | ||||
| tr.addfilegenerator( | tr.addfilegenerator( | ||||
| b'dirstate', | b'dirstate', | ||||
| (self._filename,), | (self._filename,), | ||||
| lambda f: self._writedirstate(tr, f, now=now), | lambda f: self._writedirstate(tr, f, now=now), | ||||
| location=b'plain', | location=b'plain', | ||||
| ) | ) | ||||
| return | return | ||||