| indygreg | |
| marmoute |
| hg-reviewers |
Sidedata computers may want to influence the flags of the revision they touch.
For example, the computer for changelog-based copytracing can add a flag to
signify that this revision might affect copytracing, inversely removing said
flag if the information is no longer applicable.
See inline documentation in storageutil for more details.
| Automatic diff as part of commit; lint not applicable. |
| Automatic diff as part of commit; unit tests not applicable. |
| Path | Packages | |||
|---|---|---|---|---|
| M | mercurial/cext/revlog.c (9 lines) | |||
| M | mercurial/interfaces/repository.py (2 lines) | |||
| M | mercurial/localrepo.py (6 lines) | |||
| M | mercurial/metadata.py (5 lines) | |||
| M | mercurial/pure/parsers.py (7 lines) | |||
| M | mercurial/revlog.py (12 lines) | |||
| M | mercurial/utils/storageutil.py (31 lines) | |||
| M | tests/testlib/ext-sidedata-2.py (8 lines) | |||
| M | tests/testlib/ext-sidedata-3.py (15 lines) | |||
| M | tests/testlib/ext-sidedata-5.py (8 lines) |
| Py_RETURN_NONE; | Py_RETURN_NONE; | ||||
| } | } | ||||
| /* Replace an existing index entry's sidedata offset and length with new ones. | /* Replace an existing index entry's sidedata offset and length with new ones. | ||||
| This cannot be used outside of the context of sidedata rewriting, | This cannot be used outside of the context of sidedata rewriting, | ||||
| inside the transaction that creates the given revision. */ | inside the transaction that creates the given revision. */ | ||||
| static PyObject *index_replace_sidedata_info(indexObject *self, PyObject *args) | static PyObject *index_replace_sidedata_info(indexObject *self, PyObject *args) | ||||
| { | { | ||||
| uint64_t sidedata_offset; | uint64_t offset_flags, sidedata_offset; | ||||
| int rev; | int rev; | ||||
| Py_ssize_t sidedata_comp_len; | Py_ssize_t sidedata_comp_len; | ||||
| char *data; | char *data; | ||||
| #if LONG_MAX == 0x7fffffffL | #if LONG_MAX == 0x7fffffffL | ||||
| const char *const sidedata_format = PY23("nKi", "nKi"); | const char *const sidedata_format = PY23("nKiK", "nKiK"); | ||||
| #else | #else | ||||
| const char *const sidedata_format = PY23("nki", "nki"); | const char *const sidedata_format = PY23("nkik", "nkik"); | ||||
| #endif | #endif | ||||
| if (self->hdrsize == v1_hdrsize || self->inlined) { | if (self->hdrsize == v1_hdrsize || self->inlined) { | ||||
| /* | /* | ||||
| There is a bug in the transaction handling when going from an | There is a bug in the transaction handling when going from an | ||||
| inline revlog to a separate index and data file. Turn it off until | inline revlog to a separate index and data file. Turn it off until | ||||
| it's fixed, since v2 revlogs sometimes get rewritten on exchange. | it's fixed, since v2 revlogs sometimes get rewritten on exchange. | ||||
| See issue6485. | See issue6485. | ||||
| */ | */ | ||||
| raise_revlog_error(); | raise_revlog_error(); | ||||
| return NULL; | return NULL; | ||||
| } | } | ||||
| if (!PyArg_ParseTuple(args, sidedata_format, &rev, &sidedata_offset, | if (!PyArg_ParseTuple(args, sidedata_format, &rev, &sidedata_offset, | ||||
| &sidedata_comp_len)) | &sidedata_comp_len, &offset_flags)) | ||||
| return NULL; | return NULL; | ||||
| if (rev < 0 || rev >= index_length(self)) { | if (rev < 0 || rev >= index_length(self)) { | ||||
| PyErr_SetString(PyExc_IndexError, "revision outside index"); | PyErr_SetString(PyExc_IndexError, "revision outside index"); | ||||
| return NULL; | return NULL; | ||||
| } | } | ||||
| if (rev < self->length) { | if (rev < self->length) { | ||||
| PyErr_SetString( | PyErr_SetString( | ||||
| PyExc_IndexError, | PyExc_IndexError, | ||||
| "cannot rewrite entries outside of this transaction"); | "cannot rewrite entries outside of this transaction"); | ||||
| return NULL; | return NULL; | ||||
| } | } | ||||
| /* Find the newly added node, offset from the "already on-disk" length | /* Find the newly added node, offset from the "already on-disk" length | ||||
| */ | */ | ||||
| data = self->added + self->hdrsize * (rev - self->length); | data = self->added + self->hdrsize * (rev - self->length); | ||||
| putbe64(offset_flags, data); | |||||
| putbe64(sidedata_offset, data + 64); | putbe64(sidedata_offset, data + 64); | ||||
| putbe32(sidedata_comp_len, data + 72); | putbe32(sidedata_comp_len, data + 72); | ||||
| Py_RETURN_NONE; | Py_RETURN_NONE; | ||||
| } | } | ||||
| static PyObject *index_stats(indexObject *self) | static PyObject *index_stats(indexObject *self) | ||||
| { | { | ||||
| pass | pass | ||||
| def debugwireargs(one, two, three=None, four=None, five=None): | def debugwireargs(one, two, three=None, four=None, five=None): | ||||
| pass | pass | ||||
| def savecommitmessage(text): | def savecommitmessage(text): | ||||
| pass | pass | ||||
| def register_sidedata_computer(kind, category, keys, computer): | def register_sidedata_computer(kind, category, keys, computer, flags): | ||||
| pass | pass | ||||
| def register_wanted_sidedata(category): | def register_wanted_sidedata(category): | ||||
| pass | pass | ||||
| class completelocalrepository( | class completelocalrepository( | ||||
| ilocalrepositorymain, ilocalrepositoryfilestorage | ilocalrepositorymain, ilocalrepositoryfilestorage | ||||
| return self.pathto(fp.name[len(self.root) + 1 :]) | return self.pathto(fp.name[len(self.root) + 1 :]) | ||||
| def register_wanted_sidedata(self, category): | def register_wanted_sidedata(self, category): | ||||
| if requirementsmod.REVLOGV2_REQUIREMENT not in self.requirements: | if requirementsmod.REVLOGV2_REQUIREMENT not in self.requirements: | ||||
| # Only revlogv2 repos can want sidedata. | # Only revlogv2 repos can want sidedata. | ||||
| return | return | ||||
| self._wanted_sidedata.add(pycompat.bytestr(category)) | self._wanted_sidedata.add(pycompat.bytestr(category)) | ||||
| def register_sidedata_computer(self, kind, category, keys, computer): | def register_sidedata_computer(self, kind, category, keys, computer, flags): | ||||
| if kind not in revlogconst.ALL_KINDS: | if kind not in revlogconst.ALL_KINDS: | ||||
| msg = _(b"unexpected revlog kind %r.") | msg = _(b"unexpected revlog kind '%s'.") | ||||
| raise error.ProgrammingError(msg % kind) | raise error.ProgrammingError(msg % kind) | ||||
| category = pycompat.bytestr(category) | category = pycompat.bytestr(category) | ||||
| if category in self._sidedata_computers.get(kind, []): | if category in self._sidedata_computers.get(kind, []): | ||||
| msg = _( | msg = _( | ||||
| b"cannot register a sidedata computer twice for category '%s'." | b"cannot register a sidedata computer twice for category '%s'." | ||||
| ) | ) | ||||
| raise error.ProgrammingError(msg % category) | raise error.ProgrammingError(msg % category) | ||||
| self._sidedata_computers.setdefault(kind, {}) | self._sidedata_computers.setdefault(kind, {}) | ||||
| self._sidedata_computers[kind][category] = (keys, computer) | self._sidedata_computers[kind][category] = (keys, computer, flags) | ||||
| # used to avoid circular references so destructors work | # used to avoid circular references so destructors work | ||||
| def aftertrans(files): | def aftertrans(files): | ||||
| renamefiles = [tuple(t) for t in files] | renamefiles = [tuple(t) for t in files] | ||||
| def a(): | def a(): | ||||
| for vfs, src, dest in renamefiles: | for vfs, src, dest in renamefiles: | ||||
| def _getsidedata(srcrepo, rev): | def _getsidedata(srcrepo, rev): | ||||
| ctx = srcrepo[rev] | ctx = srcrepo[rev] | ||||
| files = compute_all_files_changes(ctx) | files = compute_all_files_changes(ctx) | ||||
| return encode_files_sidedata(files), files.has_copies_info | return encode_files_sidedata(files), files.has_copies_info | ||||
| def copies_sidedata_computer(repo, revlog, rev, existing_sidedata): | def copies_sidedata_computer(repo, revlog, rev, existing_sidedata): | ||||
| return _getsidedata(repo, rev)[0] | sidedata, has_copies_info = _getsidedata(repo, rev) | ||||
| flags_to_add = sidedataflag.REVIDX_HASCOPIESINFO if has_copies_info else 0 | |||||
| return sidedata, (flags_to_add, 0) | |||||
| def set_sidedata_spec_for_repo(repo): | def set_sidedata_spec_for_repo(repo): | ||||
| if requirementsmod.COPIESSDC_REQUIREMENT in repo.requirements: | if requirementsmod.COPIESSDC_REQUIREMENT in repo.requirements: | ||||
| repo.register_wanted_sidedata(sidedatamod.SD_FILES) | repo.register_wanted_sidedata(sidedatamod.SD_FILES) | ||||
| repo.register_sidedata_computer( | repo.register_sidedata_computer( | ||||
| revlogconst.KIND_CHANGELOG, | revlogconst.KIND_CHANGELOG, | ||||
| sidedatamod.SD_FILES, | sidedatamod.SD_FILES, | ||||
| (sidedatamod.SD_FILES,), | (sidedatamod.SD_FILES,), | ||||
| copies_sidedata_computer, | copies_sidedata_computer, | ||||
| sidedataflag.REVIDX_HASCOPIESINFO, | |||||
| ) | ) | ||||
| def getsidedataadder(srcrepo, destrepo): | def getsidedataadder(srcrepo, destrepo): | ||||
| use_w = srcrepo.ui.configbool(b'experimental', b'worker.repository-upgrade') | use_w = srcrepo.ui.configbool(b'experimental', b'worker.repository-upgrade') | ||||
| if pycompat.iswindows or not use_w: | if pycompat.iswindows or not use_w: | ||||
| return _get_simple_sidedata_adder(srcrepo, destrepo) | return _get_simple_sidedata_adder(srcrepo, destrepo) | ||||
| else: | else: | ||||
| cls = InlinedIndexObject2 if revlogv2 else InlinedIndexObject | cls = InlinedIndexObject2 if revlogv2 else InlinedIndexObject | ||||
| return cls(data, inline), (0, data) | return cls(data, inline), (0, data) | ||||
| class Index2Mixin(object): | class Index2Mixin(object): | ||||
| index_format = revlog_constants.INDEX_ENTRY_V2 | index_format = revlog_constants.INDEX_ENTRY_V2 | ||||
| null_item = (0, 0, 0, -1, -1, -1, -1, sha1nodeconstants.nullid, 0, 0) | null_item = (0, 0, 0, -1, -1, -1, -1, sha1nodeconstants.nullid, 0, 0) | ||||
| def replace_sidedata_info(self, i, sidedata_offset, sidedata_length): | def replace_sidedata_info( | ||||
| self, i, sidedata_offset, sidedata_length, offset_flags | |||||
| ): | |||||
| """ | """ | ||||
| Replace an existing index entry's sidedata offset and length with new | Replace an existing index entry's sidedata offset and length with new | ||||
| ones. | ones. | ||||
| This cannot be used outside of the context of sidedata rewriting, | This cannot be used outside of the context of sidedata rewriting, | ||||
| inside the transaction that creates the revision `i`. | inside the transaction that creates the revision `i`. | ||||
| """ | """ | ||||
| if i < 0: | if i < 0: | ||||
| raise KeyError | raise KeyError | ||||
| self._check_index(i) | self._check_index(i) | ||||
| sidedata_format = b">Qi" | sidedata_format = b">Qi" | ||||
| packed_size = struct.calcsize(sidedata_format) | packed_size = struct.calcsize(sidedata_format) | ||||
| if i >= self._lgt: | if i >= self._lgt: | ||||
| packed = _pack(sidedata_format, sidedata_offset, sidedata_length) | packed = _pack(sidedata_format, sidedata_offset, sidedata_length) | ||||
| old = self._extra[i - self._lgt] | old = self._extra[i - self._lgt] | ||||
| new = old[:64] + packed + old[64 + packed_size :] | offset_flags = struct.pack(b">Q", offset_flags) | ||||
| new = offset_flags + old[8:64] + packed + old[64 + packed_size :] | |||||
| self._extra[i - self._lgt] = new | self._extra[i - self._lgt] = new | ||||
| else: | else: | ||||
| msg = b"cannot rewrite entries outside of this transaction" | msg = b"cannot rewrite entries outside of this transaction" | ||||
| raise KeyError(msg) | raise KeyError(msg) | ||||
| def entry_binary(self, rev): | def entry_binary(self, rev): | ||||
| """return the raw binary string representing a revision""" | """return the raw binary string representing a revision""" | ||||
| entry = self[rev] | entry = self[rev] | ||||
| new_entries = [] | new_entries = [] | ||||
| # append the new sidedata | # append the new sidedata | ||||
| with self._datafp(b'a+') as fp: | with self._datafp(b'a+') as fp: | ||||
| # Maybe this bug still exists, see revlog._writeentry | # Maybe this bug still exists, see revlog._writeentry | ||||
| fp.seek(0, os.SEEK_END) | fp.seek(0, os.SEEK_END) | ||||
| current_offset = fp.tell() | current_offset = fp.tell() | ||||
| for rev in range(startrev, endrev + 1): | for rev in range(startrev, endrev + 1): | ||||
| entry = self.index[rev] | entry = self.index[rev] | ||||
| new_sidedata = storageutil.run_sidedata_helpers( | new_sidedata, flags = storageutil.run_sidedata_helpers( | ||||
| store=self, | store=self, | ||||
| sidedata_helpers=helpers, | sidedata_helpers=helpers, | ||||
| sidedata={}, | sidedata={}, | ||||
| rev=rev, | rev=rev, | ||||
| ) | ) | ||||
| serialized_sidedata = sidedatautil.serialize_sidedata( | serialized_sidedata = sidedatautil.serialize_sidedata( | ||||
| new_sidedata | new_sidedata | ||||
| ) | ) | ||||
| if entry[8] != 0 or entry[9] != 0: | if entry[8] != 0 or entry[9] != 0: | ||||
| # rewriting entries that already have sidedata is not | # rewriting entries that already have sidedata is not | ||||
| # supported yet, because it introduces garbage data in the | # supported yet, because it introduces garbage data in the | ||||
| # revlog. | # revlog. | ||||
| msg = b"Rewriting existing sidedata is not supported yet" | msg = b"Rewriting existing sidedata is not supported yet" | ||||
| raise error.Abort(msg) | raise error.Abort(msg) | ||||
| entry = entry[:8] | |||||
| # Apply (potential) flags to add and to remove after running | |||||
| # the sidedata helpers | |||||
| new_offset_flags = entry[0] | flags[0] & ~flags[1] | |||||
| entry = (new_offset_flags,) + entry[1:8] | |||||
| entry += (current_offset, len(serialized_sidedata)) | entry += (current_offset, len(serialized_sidedata)) | ||||
| fp.write(serialized_sidedata) | fp.write(serialized_sidedata) | ||||
| new_entries.append(entry) | new_entries.append(entry) | ||||
| current_offset += len(serialized_sidedata) | current_offset += len(serialized_sidedata) | ||||
| # rewrite the new index entries | # rewrite the new index entries | ||||
| with self._indexfp(b'w+') as fp: | with self._indexfp(b'w+') as fp: | ||||
| fp.seek(startrev * self.index.entry_size) | fp.seek(startrev * self.index.entry_size) | ||||
| for i, entry in enumerate(new_entries): | for i, e in enumerate(new_entries): | ||||
| rev = startrev + i | rev = startrev + i | ||||
| self.index.replace_sidedata_info(rev, entry[8], entry[9]) | self.index.replace_sidedata_info(rev, e[8], e[9], e[0]) | ||||
| packed = self.index.entry_binary(rev) | packed = self.index.entry_binary(rev) | ||||
| if rev == 0: | if rev == 0: | ||||
| header = self.index.pack_header(self.version) | header = self.index.pack_header(self.version) | ||||
| packed = header + packed | packed = header + packed | ||||
| fp.write(packed) | fp.write(packed) | ||||
| ``nodesorder`` | ``nodesorder`` | ||||
| ``revisiondata`` | ``revisiondata`` | ||||
| ``assumehaveparentrevisions`` | ``assumehaveparentrevisions`` | ||||
| ``sidedata_helpers`` (optional) | ``sidedata_helpers`` (optional) | ||||
| If not None, means that sidedata should be included. | If not None, means that sidedata should be included. | ||||
| A dictionary of revlog type to tuples of `(repo, computers, removers)`: | A dictionary of revlog type to tuples of `(repo, computers, removers)`: | ||||
| * `repo` is used as an argument for computers | * `repo` is used as an argument for computers | ||||
| * `computers` is a list of `(category, (keys, computer)` that | * `computers` is a list of `(category, (keys, computer, flags)` that | ||||
| compute the missing sidedata categories that were asked: | compute the missing sidedata categories that were asked: | ||||
| * `category` is the sidedata category | * `category` is the sidedata category | ||||
| * `keys` are the sidedata keys to be affected | * `keys` are the sidedata keys to be affected | ||||
| * `flags` is a bitmask (an integer) of flags to remove when | |||||
| removing the category. | |||||
| * `computer` is the function `(repo, store, rev, sidedata)` that | * `computer` is the function `(repo, store, rev, sidedata)` that | ||||
| returns a new sidedata dict. | returns a tuple of | ||||
| `(new sidedata dict, (flags to add, flags to remove))`. | |||||
| For example, it will return `({}, (0, 1 << 15))` to return no | |||||
| sidedata, with no flags to add and one flag to remove. | |||||
| * `removers` will remove the keys corresponding to the categories | * `removers` will remove the keys corresponding to the categories | ||||
| that are present, but not needed. | that are present, but not needed. | ||||
| If both `computers` and `removers` are empty, sidedata are simply not | If both `computers` and `removers` are empty, sidedata are simply not | ||||
| transformed. | transformed. | ||||
| Revlog types are `changelog`, `manifest` or `filelog`. | Revlog types are `changelog`, `manifest` or `filelog`. | ||||
| """ | """ | ||||
| fnode = store.node | fnode = store.node | ||||
| else: | else: | ||||
| delta = mdiff.textdiff( | delta = mdiff.textdiff( | ||||
| store.rawdata(baserev), store.rawdata(rev) | store.rawdata(baserev), store.rawdata(rev) | ||||
| ) | ) | ||||
| available.add(rev) | available.add(rev) | ||||
| serialized_sidedata = None | serialized_sidedata = None | ||||
| sidedata_flags = (0, 0) | |||||
| if sidedata_helpers: | if sidedata_helpers: | ||||
| sidedata = store.sidedata(rev) | old_sidedata = store.sidedata(rev) | ||||
| sidedata = run_sidedata_helpers( | sidedata, sidedata_flags = run_sidedata_helpers( | ||||
| store=store, | store=store, | ||||
| sidedata_helpers=sidedata_helpers, | sidedata_helpers=sidedata_helpers, | ||||
| sidedata=sidedata, | sidedata=old_sidedata, | ||||
| rev=rev, | rev=rev, | ||||
| ) | ) | ||||
| if sidedata: | if sidedata: | ||||
| serialized_sidedata = sidedatamod.serialize_sidedata(sidedata) | serialized_sidedata = sidedatamod.serialize_sidedata(sidedata) | ||||
| flags = flagsfn(rev) if flagsfn else 0 | flags = flagsfn(rev) if flagsfn else 0 | ||||
| protocol_flags = 0 | protocol_flags = 0 | ||||
| if serialized_sidedata: | if serialized_sidedata: | ||||
| # Advertise that sidedata exists to the other side | # Advertise that sidedata exists to the other side | ||||
| protocol_flags |= CG_FLAG_SIDEDATA | protocol_flags |= CG_FLAG_SIDEDATA | ||||
| # Computers and removers can return flags to add and/or remove | |||||
| flags = flags | sidedata_flags[0] & ~sidedata_flags[1] | |||||
| yield resultcls( | yield resultcls( | ||||
| node=node, | node=node, | ||||
| p1node=fnode(p1rev), | p1node=fnode(p1rev), | ||||
| p2node=fnode(p2rev), | p2node=fnode(p2rev), | ||||
| basenode=fnode(baserev), | basenode=fnode(baserev), | ||||
| flags=flags, | flags=flags, | ||||
| baserevisionsize=baserevisionsize, | baserevisionsize=baserevisionsize, | ||||
| - `store`: the revlog this applies to (changelog, manifest, or filelog | - `store`: the revlog this applies to (changelog, manifest, or filelog | ||||
| instance) | instance) | ||||
| - `sidedata_helpers`: see `storageutil.emitrevisions` | - `sidedata_helpers`: see `storageutil.emitrevisions` | ||||
| - `sidedata`: previous sidedata at the given rev, if any | - `sidedata`: previous sidedata at the given rev, if any | ||||
| - `rev`: affected rev of `store` | - `rev`: affected rev of `store` | ||||
| """ | """ | ||||
| repo, sd_computers, sd_removers = sidedata_helpers | repo, sd_computers, sd_removers = sidedata_helpers | ||||
| kind = store.revlog_kind | kind = store.revlog_kind | ||||
| for _keys, sd_computer in sd_computers.get(kind, []): | flags_to_add = 0 | ||||
| sidedata = sd_computer(repo, store, rev, sidedata) | flags_to_remove = 0 | ||||
| for keys, _computer in sd_removers.get(kind, []): | for _keys, sd_computer, _flags in sd_computers.get(kind, []): | ||||
| sidedata, flags = sd_computer(repo, store, rev, sidedata) | |||||
| flags_to_add |= flags[0] | |||||
| flags_to_remove |= flags[1] | |||||
| for keys, _computer, flags in sd_removers.get(kind, []): | |||||
| for key in keys: | for key in keys: | ||||
| sidedata.pop(key, None) | sidedata.pop(key, None) | ||||
| return sidedata | flags_to_remove |= flags | ||||
| return sidedata, (flags_to_add, flags_to_remove) | |||||
| def deltaiscensored(delta, baserev, baselenfn): | def deltaiscensored(delta, baserev, baselenfn): | ||||
| """Determine if a delta represents censored revision data. | """Determine if a delta represents censored revision data. | ||||
| ``baserev`` is the base revision this delta is encoded against. | ``baserev`` is the base revision this delta is encoded against. | ||||
| ``baselenfn`` is a callable receiving a revision number that resolves the | ``baselenfn`` is a callable receiving a revision number that resolves the | ||||
| length of the revision fulltext. | length of the revision fulltext. | ||||
| from __future__ import absolute_import | from __future__ import absolute_import | ||||
| import hashlib | import hashlib | ||||
| import struct | import struct | ||||
| from mercurial.revlogutils import sidedata as sidedatamod | from mercurial.revlogutils import sidedata as sidedatamod | ||||
| from mercurial.revlogutils import constants | from mercurial.revlogutils import constants | ||||
| NO_FLAGS = (0, 0) # hoot | |||||
| def compute_sidedata_1(repo, revlog, rev, sidedata, text=None): | def compute_sidedata_1(repo, revlog, rev, sidedata, text=None): | ||||
| sidedata = sidedata.copy() | sidedata = sidedata.copy() | ||||
| if text is None: | if text is None: | ||||
| text = revlog.revision(rev) | text = revlog.revision(rev) | ||||
| sidedata[sidedatamod.SD_TEST1] = struct.pack('>I', len(text)) | sidedata[sidedatamod.SD_TEST1] = struct.pack('>I', len(text)) | ||||
| return sidedata | return sidedata, NO_FLAGS | ||||
| def compute_sidedata_2(repo, revlog, rev, sidedata, text=None): | def compute_sidedata_2(repo, revlog, rev, sidedata, text=None): | ||||
| sidedata = sidedata.copy() | sidedata = sidedata.copy() | ||||
| if text is None: | if text is None: | ||||
| text = revlog.revision(rev) | text = revlog.revision(rev) | ||||
| sha256 = hashlib.sha256(text).digest() | sha256 = hashlib.sha256(text).digest() | ||||
| sidedata[sidedatamod.SD_TEST2] = struct.pack('>32s', sha256) | sidedata[sidedatamod.SD_TEST2] = struct.pack('>32s', sha256) | ||||
| return sidedata | return sidedata, NO_FLAGS | ||||
| def reposetup(ui, repo): | def reposetup(ui, repo): | ||||
| # Sidedata keys happen to be the same as the categories, easier for testing. | # Sidedata keys happen to be the same as the categories, easier for testing. | ||||
| for kind in constants.ALL_KINDS: | for kind in constants.ALL_KINDS: | ||||
| repo.register_sidedata_computer( | repo.register_sidedata_computer( | ||||
| kind, | kind, | ||||
| sidedatamod.SD_TEST1, | sidedatamod.SD_TEST1, | ||||
| (sidedatamod.SD_TEST1,), | (sidedatamod.SD_TEST1,), | ||||
| compute_sidedata_1, | compute_sidedata_1, | ||||
| 0, | |||||
| ) | ) | ||||
| repo.register_sidedata_computer( | repo.register_sidedata_computer( | ||||
| kind, | kind, | ||||
| sidedatamod.SD_TEST2, | sidedatamod.SD_TEST2, | ||||
| (sidedatamod.SD_TEST2,), | (sidedatamod.SD_TEST2,), | ||||
| compute_sidedata_2, | compute_sidedata_2, | ||||
| 0, | |||||
| ) | ) | ||||
nit: missing #hoot comment