| SimonSapin | |
| pulkit |
| hg-reviewers |
Lets start to define and use more semantic property.
| Automatic diff as part of commit; lint not applicable. |
| Automatic diff as part of commit; unit tests not applicable. |
| Path | Packages | |||
|---|---|---|---|---|
| M | mercurial/cext/parsers.c (12 lines) | |||
| M | mercurial/dirstate.py (12 lines) | |||
| M | mercurial/dirstatemap.py (2 lines) | |||
| M | mercurial/pure/parsers.py (12 lines) |
| #define PyInt_Check PyLong_Check | #define PyInt_Check PyLong_Check | ||||
| #define PyInt_FromLong PyLong_FromLong | #define PyInt_FromLong PyLong_FromLong | ||||
| #define PyInt_FromSsize_t PyLong_FromSsize_t | #define PyInt_FromSsize_t PyLong_FromSsize_t | ||||
| #define PyInt_AsLong PyLong_AsLong | #define PyInt_AsLong PyLong_AsLong | ||||
| #endif | #endif | ||||
| static const char *const versionerrortext = "Python minor version mismatch"; | static const char *const versionerrortext = "Python minor version mismatch"; | ||||
| static const int dirstate_v1_from_p2 = -2; | |||||
| static PyObject *dict_new_presized(PyObject *self, PyObject *args) | static PyObject *dict_new_presized(PyObject *self, PyObject *args) | ||||
| { | { | ||||
| Py_ssize_t expected_size; | Py_ssize_t expected_size; | ||||
| if (!PyArg_ParseTuple(args, "n:make_presized_dict", &expected_size)) { | if (!PyArg_ParseTuple(args, "n:make_presized_dict", &expected_size)) { | ||||
| return NULL; | return NULL; | ||||
| } | } | ||||
| { | { | ||||
| if (self->state == 'm') { | if (self->state == 'm') { | ||||
| Py_RETURN_TRUE; | Py_RETURN_TRUE; | ||||
| } else { | } else { | ||||
| Py_RETURN_FALSE; | Py_RETURN_FALSE; | ||||
| } | } | ||||
| }; | }; | ||||
| static PyObject *dirstatetuple_get_from_p2(dirstateTupleObject *self) | |||||
| { | |||||
| if (self->size == dirstate_v1_from_p2) { | |||||
| Py_RETURN_TRUE; | |||||
| } else { | |||||
| Py_RETURN_FALSE; | |||||
| } | |||||
| }; | |||||
| static PyGetSetDef dirstatetuple_getset[] = { | static PyGetSetDef dirstatetuple_getset[] = { | ||||
| {"state", (getter)dirstatetuple_get_state, NULL, "state", NULL}, | {"state", (getter)dirstatetuple_get_state, NULL, "state", NULL}, | ||||
| {"merged", (getter)dirstatetuple_get_merged, NULL, "merged", NULL}, | {"merged", (getter)dirstatetuple_get_merged, NULL, "merged", NULL}, | ||||
| {"from_p2", (getter)dirstatetuple_get_from_p2, NULL, "from_p2", NULL}, | |||||
| {NULL} /* Sentinel */ | {NULL} /* Sentinel */ | ||||
| }; | }; | ||||
| PyTypeObject dirstateTupleType = { | PyTypeObject dirstateTupleType = { | ||||
| PyVarObject_HEAD_INIT(NULL, 0) /* header */ | PyVarObject_HEAD_INIT(NULL, 0) /* header */ | ||||
| "dirstate_tuple", /* tp_name */ | "dirstate_tuple", /* tp_name */ | ||||
| sizeof(dirstateTupleObject), /* tp_basicsize */ | sizeof(dirstateTupleObject), /* tp_basicsize */ | ||||
| 0, /* tp_itemsize */ | 0, /* tp_itemsize */ | ||||
| # 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._map.copymap.get(f) | source = self._map.copymap.get(f) | ||||
| if source: | if source: | ||||
| copies[f] = source | copies[f] = source | ||||
| self.normallookup(f) | self.normallookup(f) | ||||
| # Also fix up otherparent markers | # Also fix up otherparent markers | ||||
| elif s.state == b'n' and s[2] == FROM_P2: | elif s.state == b'n' and 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.add(f) | self.add(f) | ||||
| return copies | return copies | ||||
| def setbranch(self, branch): | def setbranch(self, branch): | ||||
| self.__class__._branch.set(self, encoding.fromlocal(branch)) | self.__class__._branch.set(self, encoding.fromlocal(branch)) | ||||
| def normallookup(self, f): | def normallookup(self, f): | ||||
| '''Mark a file normal, but possibly dirty.''' | '''Mark a file normal, but possibly dirty.''' | ||||
| if self.in_merge: | if self.in_merge: | ||||
| # if there is a merge going on and the file was either | # if there is a merge going on and the file was either | ||||
| # "merged" or coming from other parent (-2) before | # "merged" or coming from other parent (-2) before | ||||
| # being removed, restore that state. | # being removed, restore that state. | ||||
| entry = self._map.get(f) | entry = self._map.get(f) | ||||
| if entry is not None: | if entry is not None: | ||||
| if entry.state == b'r' and entry[2] in (NONNORMAL, FROM_P2): | if entry.state == b'r' and ( | ||||
| entry[2] == NONNORMAL or entry.from_p2 | |||||
| ): | |||||
| source = self._map.copymap.get(f) | source = self._map.copymap.get(f) | ||||
| if entry[2] == NONNORMAL: | if entry[2] == NONNORMAL: | ||||
| self.merge(f) | self.merge(f) | ||||
| elif entry[2] == FROM_P2: | elif entry.from_p2: | ||||
| self.otherparent(f) | self.otherparent(f) | ||||
| if source: | if source: | ||||
| self.copy(source, f) | self.copy(source, f) | ||||
| return | return | ||||
| if entry.merged or entry.state == b'n' and entry[2] == FROM_P2: | if entry.merged or entry.state == b'n' and entry.from_p2: | ||||
| return | return | ||||
| self._addpath(f, b'n', 0, possibly_dirty=True) | self._addpath(f, b'n', 0, possibly_dirty=True) | ||||
| self._map.copymap.pop(f, None) | self._map.copymap.pop(f, None) | ||||
| def otherparent(self, f): | def otherparent(self, f): | ||||
| '''Mark as coming from the other parent, always dirty.''' | '''Mark as coming from the other parent, always dirty.''' | ||||
| if not self.in_merge: | if not self.in_merge: | ||||
| msg = _(b"setting %r to other parent only allowed in merges") % f | msg = _(b"setting %r to other parent only allowed in merges") % f | ||||
| dadd(fn) | dadd(fn) | ||||
| elif state == b'n': | elif state == b'n': | ||||
| if ( | if ( | ||||
| size >= 0 | size >= 0 | ||||
| and ( | and ( | ||||
| (size != st.st_size and size != st.st_size & _rangemask) | (size != st.st_size and size != st.st_size & _rangemask) | ||||
| or ((mode ^ st.st_mode) & 0o100 and checkexec) | or ((mode ^ st.st_mode) & 0o100 and checkexec) | ||||
| ) | ) | ||||
| or size == FROM_P2 # other parent | or t.from_p2 | ||||
| or fn in copymap | or fn in copymap | ||||
| ): | ): | ||||
| if stat.S_ISLNK(st.st_mode) and size != st.st_size: | if stat.S_ISLNK(st.st_mode) and size != st.st_size: | ||||
| # issue6456: Size returned may be longer due to | # issue6456: Size returned may be longer due to | ||||
| # encryption on EXT-4 fscrypt, undecided. | # encryption on EXT-4 fscrypt, undecided. | ||||
| ladd(fn) | ladd(fn) | ||||
| else: | else: | ||||
| madd(fn) | madd(fn) | ||||
| # XXX we should not be able to have 'm' state and 'FROM_P2' if not | # XXX we should not be able to have 'm' state and 'FROM_P2' if not | ||||
| # during a merge. So I (marmoute) am not sure we need the | # during a merge. So I (marmoute) am not sure we need the | ||||
| # conditionnal at all. Adding double checking this with assert | # conditionnal at all. Adding double checking this with assert | ||||
| # would be nice. | # would be nice. | ||||
| if entry is not None: | if entry is not None: | ||||
| # backup the previous state | # backup the previous state | ||||
| if entry.merged: # merge | if entry.merged: # merge | ||||
| size = NONNORMAL | size = NONNORMAL | ||||
| elif entry[0] == b'n' and entry[2] == FROM_P2: # other parent | elif entry[0] == b'n' and entry.from_p2: | ||||
| size = FROM_P2 | size = FROM_P2 | ||||
| self.otherparentset.add(f) | self.otherparentset.add(f) | ||||
| if size == 0: | if size == 0: | ||||
| self.copymap.pop(f, None) | self.copymap.pop(f, None) | ||||
| if entry is not None and entry[0] != b'r' and "_dirs" in self.__dict__: | if entry is not None and entry[0] != b'r' and "_dirs" in self.__dict__: | ||||
| self._dirs.delpath(f) | self._dirs.delpath(f) | ||||
| if entry is None and "_alldirs" in self.__dict__: | if entry is None and "_alldirs" in self.__dict__: | ||||
| _pack = struct.pack | _pack = struct.pack | ||||
| _unpack = struct.unpack | _unpack = struct.unpack | ||||
| _compress = zlib.compress | _compress = zlib.compress | ||||
| _decompress = zlib.decompress | _decompress = zlib.decompress | ||||
| # a special value used internally for `size` if the file come from the other parent | |||||
| FROM_P2 = -2 | |||||
| class dirstatetuple(object): | class dirstatetuple(object): | ||||
| """represent a dirstate entry | """represent a dirstate entry | ||||
| It contains: | It contains: | ||||
| - state (one of 'n', 'a', 'r', 'm') | - state (one of 'n', 'a', 'r', 'm') | ||||
| - mode, | - mode, | ||||
| - size, | - size, | ||||
| @property | @property | ||||
| def merged(self): | def merged(self): | ||||
| """True if the file has been merged | """True if the file has been merged | ||||
| Should only be set if a merge is in progress in the dirstate | Should only be set if a merge is in progress in the dirstate | ||||
| """ | """ | ||||
| return self._state == b'm' | return self._state == b'm' | ||||
| @property | |||||
| def from_p2(self): | |||||
| """True if the file have been fetched from p2 during the current merge | |||||
| Should only be set if a merge is in progress in the dirstate | |||||
| """ | |||||
| return self._size == FROM_P2 | |||||
| def v1_state(self): | def v1_state(self): | ||||
| """return a "state" suitable for v1 serialization""" | """return a "state" suitable for v1 serialization""" | ||||
| return self._state | return self._state | ||||
| def v1_mode(self): | def v1_mode(self): | ||||
| """return a "mode" suitable for v1 serialization""" | """return a "mode" suitable for v1 serialization""" | ||||
| return self._mode | return self._mode | ||||