safehasattr: pass attribute name as string instead of bytes This is a step toward replacing `util.safehasattr` usage with plain `hasattr`. The builtin function behave poorly in Python2 but this was fixed in Python3. These change are done one by one as they tend to have a small odd to trigger puzzling breackage.

safehasattr: pass attribute name as string instead of bytes This is a step toward replacing `util.safehasattr` usage with plain `hasattr`. The builtin function behave poorly in Python2 but this was fixed in Python3. These change are done one by one as they tend to have a small odd to trigger puzzling breackage.

safehasattr: pass attribute name as string instead of bytes This is a step toward replacing `util.safehasattr` usage with plain `hasattr`. The builtin function behave poorly in Python2 but this was fixed in Python3. These change are done one by one as they tend to have a small odd to trigger puzzling breackage.

safehasattr: pass attribute name as string instead of bytes This is a step toward replacing `util.safehasattr` usage with plain `hasattr`. The builtin function behave poorly in Python2 but this was fixed in Python3. These change are done one by one as they tend to have a small odd to trigger puzzling breackage.

safehasattr: pass attribute name as string instead of bytes This is a step toward replacing `util.safehasattr` usage with plain `hasattr`. The builtin function behave poorly in Python2 but this was fixed in Python3. These change are done one by one as they tend to have a small odd to trigger puzzling breackage.

safehasattr: pass attribute name as string instead of bytes This is a step toward replacing `util.safehasattr` usage with plain `hasattr`. The builtin function behave poorly in Python2 but this was fixed in Python3. These change are done one by one as they tend to have a small odd to trigger puzzling breackage.

safehasattr: pass attribute name as string instead of bytes This is a step toward replacing `util.safehasattr` usage with plain `hasattr`. The builtin function behave poorly in Python2 but this was fixed in Python3. These change are done one by one as they tend to have a small odd to trigger puzzling breackage.

safehasattr: pass attribute name as string instead of bytes This is a step toward replacing `util.safehasattr` usage with plain `hasattr`. The builtin function behave poorly in Python2 but this was fixed in Python3. These change are done one by one as they tend to have a small odd to trigger puzzling breackage.

safehasattr: pass attribute name as string instead of bytes This is a step toward replacing `util.safehasattr` usage with plain `hasattr`. The builtin function behave poorly in Python2 but this was fixed in Python3. These change are done one by one as they tend to have a small odd to trigger puzzling breackage.

safehasattr: pass attribute name as string instead of bytes This is a step toward replacing `util.safehasattr` usage with plain `hasattr`. The builtin function behave poorly in Python2 but this was fixed in Python3. These change are done one by one as they tend to have a small odd to trigger puzzling breackage.

safehasattr: pass attribute name as string instead of bytes This is a step toward replacing `util.safehasattr` usage with plain `hasattr`. The builtin function behave poorly in Python2 but this was fixed in Python3. These change are done one by one as they tend to have a small odd to trigger puzzling breackage.

safehasattr: pass attribute name as string instead of bytes This is a step toward replacing `util.safehasattr` usage with plain `hasattr`. The builtin function behave poorly in Python2 but this was fixed in Python3. These change are done one by one as they tend to have a small odd to trigger puzzling breackage.

safehasattr: pass attribute name as string instead of bytes This is a step toward replacing `util.safehasattr` usage with plain `hasattr`. The builtin function behave poorly in Python2 but this was fixed in Python3. These change are done one by one as they tend to have a small odd to trigger puzzling breackage.

safehasattr: pass attribute name as string instead of bytes This is a step toward replacing `util.safehasattr` usage with plain `hasattr`. The builtin function behave poorly in Python2 but this was fixed in Python3. These change are done one by one as they tend to have a small odd to trigger puzzling breackage.

safehasattr: pass attribute name as string instead of bytes This is a step toward replacing `util.safehasattr` usage with plain `hasattr`. The builtin function behave poorly in Python2 but this was fixed in Python3. These change are done one by one as they tend to have a small odd to trigger puzzling breackage.

safehasattr: pass attribute name as string instead of bytes This is a step toward replacing `util.safehasattr` usage with plain `hasattr`. The builtin function behave poorly in Python2 but this was fixed in Python3. These change are done one by one as they tend to have a small odd to trigger puzzling breackage.

safehasattr: pass attribute name as string instead of bytes This is a step toward replacing `util.safehasattr` usage with plain `hasattr`. The builtin function behave poorly in Python2 but this was fixed in Python3. These change are done one by one as they tend to have a small odd to trigger puzzling breackage.

safehasattr: pass attribute name as string instead of bytes This is a step toward replacing `util.safehasattr` usage with plain `hasattr`. The builtin function behave poorly in Python2 but this was fixed in Python3. These change are done one by one as they tend to have a small odd to trigger puzzling breackage.

safehasattr: pass attribute name as string instead of bytes This is a step toward replacing `util.safehasattr` usage with plain `hasattr`. The builtin function behave poorly in Python2 but this was fixed in Python3. These change are done one by one as they tend to have a small odd to trigger puzzling breackage.

safehasattr: pass attribute name as string instead of bytes This is a step toward replacing `util.safehasattr` usage with plain `hasattr`. The builtin function behave poorly in Python2 but this was fixed in Python3. These change are done one by one as they tend to have a small odd to trigger puzzling breackage.

safehasattr: pass attribute name as string instead of bytes This is a step toward replacing `util.safehasattr` usage with plain `hasattr`. The builtin function behave poorly in Python2 but this was fixed in Python3. These change are done one by one as they tend to have a small odd to trigger puzzling breackage.

debug: `isinstance(a, x) or isinstance(a, y)` is `isinstance(a, (x, y))`

debug: update usage strings of debugignore and debugnodemap Multiple files can be specified for debugignore. debugnodemap does not take a revision argument.

debug: slightly improve wording on the InputErrors from the previous patch

debug: use InputError instead of CommandError for validating arguments

clonebundle: add a `filter_bundle_url` function This function does nothing by default, but give extension the opportunity to alter the URL, typically, this could be used to inject authentication token when serving clone bundle for private repositories.

clonebundles: move the manifest reading in a dedicated function We are about to make the logic more advanced to help hosting solution, so we need to centralize it first.

rhg: support `rhg files` with `ui.relative-paths=false`

rhg: make `rhg files` work if `ui.relative-files=true` is specified

rhg: test `rhg files --config ui.relative-paths ...` Add some tests. All of these are falling back for now, will be fixed in follow-up commits.

cleanup: simplify code

dirstate: better error messages when dirstate is corrupted The current error message "Overflow in dirstate" sounds confusing because it suggests either a certain size limit that's being exceeded, or integer arithmetic overflowing. The reality is just a file being shorter than expected.

rust: remove an unused error variant DirstateMapError::EmptyPath

hg: move unreachable code to where it could be reached

stream-clone: support streamv3 on the cli [hg bundle] We add support and test for this. The support is still experimental, so the various name and identifier will eventually need to be renamed when stream-v3 gets out of experimental.

stream-clone: add the `-exp` prefix to the bundle part We forget to do so in 58adcabc295f, however this is important to prevent "current" client to send incompatible version to future client.

zstd: hack include order to ensure that our zstd.h is found If the regular Python CFLAGS include directories that already have the zstd headers available, a different and possible incompatible version can be picked up otherwise. Sadly, it seems like Python has no easy way to prefix flags before the rest.

exchange: allow passing no includes/excludes to `pull()` I would expect that `exchange.pull(includepats=[])` results in an empty list of include patterns to be passed to the remote, but it doesn't currently because we check for any truthy value instead of checking specifically for `not None`.

stabletailgraph: add test cases challenging the open merge stack This adds three more complex test cases with situations requiring tricky state update in the stack-based iteration (arriving soon).

stabletailgraph: naive version of leap computation This adds a naive reference implementation of the computation of leap and specific leap sets (described in the code documentation). The existing tests are enriched accordingly.

stabletailgraph: extract _parents util func

stabletailgraph: clarify excl part size computation

stabletailgraph: clarify naiveness of current implementation Both the naive and the actual versions of the algorithms are going to co-exist for the tests. This makes is clearer that this one is naive.

stream-clone: introduce the notion of an experimental "v3" version We introduce a new experimental "v3" stream protocol, disabled by default. In practice the "v3-exp" protocol introduced in this changeset is identical to v2, but this changeset, lay the groundwork for having a new protocol: configuration, capability exchange, test coverage, etc. The actual protocol work will starts in the coming changesets.

stream-clone: check is a compatible protocol can be found The previous code was explicitly checking if "v2" is listed in the "stream" bundle2 capability. The new code is checking is there is anything common between the versions supported client side and server side overlaps. This prepare the introduction of more stream version than "v2".

stream-clone: bail-out earlier if stream clone is not requested The `canperformstreamclone` function is bit messy. However it seems clearer to me to check if a stream-clone have been requested by the client or the server at all, before checking if a compatible protocol can be negotiated with the server. So I am doing some gratuitous movement so reorder conditional.

stream-clone: bail-out earlier if pull is partial The `canperformstreamclone` function is bit messy. However it seems clearer to me to process the very generic condition about "can we consider a stream-clone at all", before checking if a stream-clone is requested and if a compatible protocol can be negotiated with the server. So I am doing some gratuitous movement so reorder conditional.

stream-clone: bail-out earlier if destination repo is not empty The `canperformstreamclone` function is bit messy. However it seems clearer to me to process the very generic condition about "can we consider a stream-clone at all", before checking if a stream-clone is requested and if a compatible protocol can be negotiated with the server. So I am doing some gratuitous movement so reorder conditional.

stream-clone: check the version of streaming clone supported by the client Make the server refuse to produce streaming clone bundle, if the client doesn't specify the stream=v2 capability. This is in preparation to introduce stream=v3. As far as I can tell, this capability was added at the same time as support for bundle2-based streaming pulls was added, so I don't expect clients to break. (the modern client doesn't break, at any rate)

stream-clone: make sure the `stream` capability is set when bundling This is important to start narrowing protocol option in the next changesets.

stream-clone: upgrade the error message for bad stream request The new version if more compact and more consistent with the general Mercurial usage.

stream-clone: yield cache entry in `_entries_walk` too The new function now cover the same ground as _v2_walk.

stream-clone: introduce a _entries_walk That function insert itself between the store and `_v2_walk`. It only deals with StoreEntry unlike `_v2_walk` that deal with actual file. A share of the `_v2_walk` logic will be moved in this new `_entry_walk` function. Having this function will help us to implement a new "v3" version of the protocol that will be more entry centric.

store: make `walk` return an entry for obsolescence if requested so Instead of having dedicated code in the streamclone code, we should have the store deal with advertising the data it contains.

store: yield phases before changelog Creating the `changelog.i` file make the repository usable, so dealing with phase earlier seems better.

store: make `walk` return an entry for phase if requested so Instead of having dedicated code in the streamclone code, we should have the store deal with advertising the data it contains.

cli: add a test of `hg debugnodemap --manifest` this is a new option that's not tested yet

cli: fix spelling in `debugnodemap` error messages

cli: make debugnodemap capable of inspecting an arbitrary nodemap This lets us inspect the manifest nodemap and individual directory nodemaps when treemanifest is used.

rust: mostly avoid streaming zstd decompression Streaming ZStd decompression seems slightly slower, and the API we use makes it very inconvenient to re-use the decompression context. Instead of using that, use the buffer-backed version, because we can give a reasonable-ish size estimate.

rust: in zstd decompression, avoid a useless vec initialization

rust: speed up zstd decompression by re-using the decompression context Admittedly, zstd is already pretty fast, but this change makes it a bit faster yet: it saves ~5% of time it takes to read our large repo. The actual motivating use case is treemanifest: in treemanifest we end up reading *lots* of small directories, and many of them need decompression, and there the saving for [rhg files] is >10%. (which also seems unreasonable, we should probably keep things uncompressed more)

store: rename `topfiles` to `top_entries` The method is now returning StoreEntries let us rename the method for clarity.

store: rename `datafiles` to `data_entries` The method is now returning StoreEntries let us rename the method for clarity.

store: use boolean property for upgrade's matchrevlog

store: use the new boolean property in `upgrade`

store: use the new boolean property in `remotefilelogserver`

store: use the boolean property in `repair_issue6528`

store: use the new boolean property in `narrow`

store: use the boolean property in `store`

store: introduce boolean property for revlog type This will avoid exposing implementation details to more generic code.

store: issue a single entry for each revlog We now yield a single entry, with data about each files involved. This help to simplify multiple code using this and it will help to further simplify and fixes the streaming code.

store: rename `unencoded_path` to `entry_path` for StoreEntry This remove the ambiguity with StoreFile and make sure use code will be using the right API.

store: do the revlog matching on entry directly This is the last blocker to safely merge the revlog files in a single entry.

store: split the wrapping of encodedstore between _wrap and datafiles The `datafiles` method of `basicstore` is doing a lot of work that should be done on decoded filename. So we now wrap `_walk` to do the decoding, and less work in `datafiles`. This is necessary to make sure file from the same revlog can be grouped together.

store: introduce a main_file_path method for revlog This help code that need to point revlog to an index file. This is put to use in the upgrade code.

upgrade: actually use StoreEntry API to create revlog Lets make use of the semanctic of the object we are passed.

upgrade: use StoreEntry object in upgrade We will make more use of the API in the next changeset, but just moving to use entry is a significant change for the engine codebase.

upgrade: drop a quick fix that is not longer necessary We won't issue bad revlog from topfile anymore.

store: use StoreEntry API instead of parsing filename in largefile This is more explicit and more robust.

store: use StoreEntry API instead of parsing filename when listing manifestlog This is more explicit and more robust.

store: use StoreEntry API instead of parsing filename when fixing issue6528 This is more explicit and more robust. We also introduce a small output change as it make things simpler and this is a affecting a debug-command.

store: use StoreEntry API instead of parsing filename in remotefilelog This is more explicit and more robust.

store: use StoreEntry API instead of parsing filename in narrow This is more explicit and more robust.

store: add a `target_id` attribute on RevlogStoreEntry This hold the "target" (file, directory, etc) of a revlog. Having this available will help a lot of code to avoid direct file path access.

store: actually tag tree manifest revlogs as manifest revlogs It turn out we have been mislabeling these for a long while. This is now fixed.

store: also gather files per revlog in `topfiles` This conclude out revlog gathering.

store: also group files by revlog in fncache version of datafiles One more step.

store: add logic to group revlog file together For now each file get its own entry, this will help stopping this, soon™. We use such gathering in the `basicstore` code.

store: change `_walk` return to `(filename, (type, size))` If we are to group file per revlog, having the filename as the "main key" will be useful. This change will make the following changes clearer.

store: lazily get file size on demand for the fncache case We don't have the information in the first place, so we can avoid querying the file system inconditionnaly for use case we don't needs it. This change requires the StoreFile class to be passed a vfs to retrieve the file_size if needed. In the non-fncache case, we already have the information from file system walking, so we keep it and use it.

store: only access is_volatile information through the file object This make sure other code only access this information through the proper API, and it prepare for store entries to be able to agregate multiple files.

store: only access file_size information through the file object This make sure other code only access this information through the proper API, and it prepare for store entries to be able to agregate multiple files.

store: have custom init for entries class This will get useful to add special processing later in this series.

store: use specialized class for store entries We introduce two different classes for revlog and other entries. For now, we still have multiple entry for the same revlog, but we will work toward grouping the different file in a single entry in this series. Having the distinction is a step toward this goal.

store: introduce a EntryFile object to actually access file info For now a StoreEntry match a single file, but the goal is to eventually combine multiple file in a higher level Entry, so we need to introduce this distinction and use it first.

store: use a StoreEntry object instead of tuple for store files We want to make the store return more semantic information instead of a stream of file path. To achieve this, we start with adding a simple object that hold the same information as the tuple it replace, and do a simple update to the user code to fetch and use the same information. From there, we will be able to iteratively upgrade the codebase toward better objects.

store: no longer explicitly mark the splitted index as ignored Since the fncache is going to automatically recognised it as non "normal" revlog file, we don't need to explicitly make it ignored.

store: cleanup what is recognized as a revlog file The temporary file from `censor` are not relevant to the store as they are just temporary. So let `fncache` and `datafiles` forget about them.

store: only inclure revlog related file in `datafiles` This is a "reading" equivalent of the previous patches (see that patch for details).

store: do not record file that are not part of a revlog in fncache The fncache exist to list file to copy/stream when cloning a repository, it should only contains file that are relevant for a revlog in such case. For example, temporary file are not relevant. So we now skip the addiction of non-relevant file to the fn-cache in the first place.

revlog-split: expand the some test to cover the success case too It seems useful to double check the case of a transaction successfully committed before trying the one with transaction abort.

transaction: use a ".bck" extension for all backup file There are too much code in Mercurial that assume file function from extension. Keeping the original extension when doing backup is just creating confusion (for exemple, backup of revlog's confused with new version revlogs). So we change the backup name from now on to be explicilty backup file and prevent this kind of problem. (note that repository using fncache is less affected (but still affected) by this kind of problem as the backup are not listed in the fncache).

repair-issue6528: remove a now useless continue The condition for that continue have been excplicly filtered out of the `files` list a handful of line earlier.

branching: merge stable into default

stabletailgraph: clarify omission of linear parts in test sorts Those are not interesting and are collapsed using globs. Only the tagged nodes are interesting.

stabletailgraph: omit uninteresting linear parts in test log The test uses tags for the nodes of interest. There is no need to print the linear parts which exist only to force the rank.

stabletailgraph: fix typo in test

stabletailgraph: fix terminology in doc

perf: introduce a `perf::stream-locked-section` command This command benchmark the initial part of a stream clone, where the repository is locked.

transaction: tr._names are actually bytes, use byte string to join them Looks like this is never checked in the tests? But trying e.g. `print(tr)` by hand before this change would give: TypeError: sequence item 0: expected str instance, bytes found Looks like tr._names are always bytes (although this isn't actually enforced, but maybe at some point it will at least be type checked e.g. by pytype).

nix: add nix-defined package and devel env (flake) This adds a Nix Flake which defines: - package recipies to build and run Mercurial (C, C+Rust variants), - a meta package to run the test suite in an isolated sandbox, - a development environment with some tools (notably Python and the Black formatter, pinned to match the CI). Python is pinned to the recommended version. The Rust toolchain is a fairly recent one provided by the Nixpkgs channel. It is not yet pinned to the same version as the "reference" Debian package, but this does not seem to cause any issue. Example usage of local commands are provided in the `flake.nix` file. Once merged, it should also be possible to pull and run directly from the source repository directly with something like: `nix run hg+https://foss.heptapod.net/mercurial/mercurial-devel?ref=TOPIC&dir=contrib/nix' -- version`

hgignore: ignore nix result symlink

tests: add test ignore list for nix Some tests cannot run properly in the nix sandbox. This adds a list of tests to ignore when running in that context.

ui: keep the progress bar around when writing if stdout is not a tty

tests: in filterpyflakes, tolerate non-ascii file contents

comments: fix spelling

heptapod-ci: display python version it will be useful to debug in the CI

branching: merge stable into default

sha1dc: Make sure SHA1DC_BIGENDIAN is set on Darwin/PowerPC __BYTE_ORDER__ is not defined on old toolchains so sha1dc gets built in little endian mode on a big endian platform, hilarity ensues. Tested on Mac OS X Tiger 10.4.