grep: add support for log-like template keywords and functions

cat: add support for log-like template keywords and functions

bookmarks: add support for log-like template keywords and functions This is basically the same as 5d9b765dbe15 "tags: unblock log-like template keywords and functions."

fix: add progress bar for number of file revisions processed This ensures responsiveness when the configured tools are slow or numerous. Differential Revision: https://phab.mercurial-scm.org/D3848

fix: use a worker pool to parallelize running tools This is important for usability when tools are slow or numerous. Differential Revision: https://phab.mercurial-scm.org/D3846

worker: support more return types in posix worker This allows us to return things that aren't tuple(int, str) from worker functions. I wanted to use marshal instead of pickle, but it seems to read from the pipe in non-blocking mode, which means it stops before it sees the results. The windows worker already supports arbitrary return values without serialization, because it uses threads instead of subprocesses. Differential Revision: https://phab.mercurial-scm.org/D3845

debug: process --debug flag earlier This allow the verbosity level to be set correctly during extension initialization.

windows: fix incorrect detection of broken pipe when writing to pager Paging e.g. hg incoming on Windows and quitting the pager before the output is consumed will print 'abort: Invalid argument'. This is because the windows error 0xE8 (ERROR_NO_DATA) is mapped to EINVAL even though it is documented as 'The pipe is being closed'. Note that this fix assumes that Windows' last error code is still valid in the exception handler. It works correctly in all my tests. A simpler fix would be to just map EINVAL to EPIPE, like was done is flush previously, but that would be less precise. This error was not observed previously, when pager was an extension.

test: stop passing --quiet in a run dedicated to debug output The goal of the run is to display some debug output. Passing --quiet in this case is strange.

acl: add bookmarks support Originally submitted at https://www.mercurial-scm.org/pipermail/mercurial-devel/2016-March/080650.html as an RFC by timeless. .. feature:: The `acl` extension now has support for bookmarks as well as branches. Differential Revision: https://phab.mercurial-scm.org/D3750

repository: define manifest interfaces The long march towards declaring interfaces for repository primitives continues. This commit essentially defines interfaces based on the following types: * manifest.manifestdict -> imanifestdict * manifest.manifestlog -> imanifestlog * manifest.memmanifestctx -> imanifestrevisionwritable * manifest.manifestctx -> imanifestrevisionstored * manifest.memtreemanifestctx -> imanifestrevisionwritable * manifest.treemanifestctx -> imanifestrevisionstored * util.dirs -> idirs The interfaces are thoroughly documented. Their documentation is now better than the documentation in manifest.py in many cases. With the exception of util.dirs, classes have been annotated with their interfaces. (I didn't feel like util.dirs needed the proper interface treatment.) Tests have been added demonstrating that all classes and instances conform to their interfaces. This work was much easier than filelogs. That's because Durham did an excellent job formalizing the manifest API a while back. There are still some minor kludges with the interfaces that should probably be addressed. But the primary goal with interface declarations is getting something established. Once we have an interface, we can modify it later easily enough. Differential Revision: https://phab.mercurial-scm.org/D3869

narrowbundle2: when we handle a widen, mark the operation as unsafe We have to manually drive the context manager here since the logic is awkwardly split between a couple of places. Differential Revision: https://phab.mercurial-scm.org/D3719

narrow: mark the critical chunks of narrowing/widening as unsafe I'm _mostly_ sure these are the only unsafe chunks here. Differential Revision: https://phab.mercurial-scm.org/D3718

repair: mark the critical section of strip() as unsafe When our experimental nointerrupt feature is enabled, this will help prevent users from corrupting their repo during a strip. Differential Revision: https://phab.mercurial-scm.org/D3717

ui: add an uninterruptable context manager that can block SIGINT The blocking of SIGINT is not done by default, but my hope is that we will one day. This was inspired by Facebook's "nointerrupt" extension, which is a bit more heavy-handed than this (whole commands are treated as unsafe to interrupt). A future patch will enable this for varying bits of Mercurial that are performing unsafe operations. It's intentional that the KeyboardInterrupt is raised as the context manager exits: during the span of the context manager interrupting Mercurial could lead to data loss, but typically those spans are fairly narrow, so we can let the unsafe block complete and then terminate hg (which will leave the repo in a consistent state, even if it's not the user's desired state). .. api:: New context manager ``ui.uninterruptable()`` to mark portions of a command as potentially unsafe places to interrupt Mercurial with Control-C or similar. Differential Revision: https://phab.mercurial-scm.org/D3716

merge with stable

Added signature for changeset 0b63a6743010

Added tag 4.6.2 for changeset 0b63a6743010

revset: add partial support for ancestor(wdir()) It's easy, so let's make it happen. I'm not certain if 'wdir() &' should be required. ancestors(wdir()) works without it, but ancestor(wdir()) doesn't as of now. That's the issue of fullreposet.__contains__() vs __and__().

context: also accept diff option directly For now we accept both diff option and dictionary. This will let us upgrade internal users gradually before we drop the old API at the end of this series.

context: also take all other arguments than `patch.diff` accept This is needed to use `context.diff` as a full replacement of `patch.diff`

context: explicitly take diffopts in `context.diff` (API) To provide a proper replacement for the `patch.diff(…)` function, the `context.diff(…)` method needs to be able to take more parameters. To distinguish the diff options from the new other arguments, we upgrade the diff options to its own explicit argument.

rebase: check whether the rebasestate exists or not a bit early Converted the else part into `if True` because that part will soon be under a except part. Differential Revision: https://phab.mercurial-scm.org/D3876

rebase: use staeobj to check whether interrupted rebase exists This cleans up the code a bit. Differential Revision: https://phab.mercurial-scm.org/D3875

rebase: add a stateobj variable to rebaseruntime class The stateobj variable is an object of state.cmdstate() and will be used in upcoming patches to clean up the logic a bit and also use cbor format to write data to rebasestate class. Differential Revision: https://phab.mercurial-scm.org/D3874

rebase: refactor logic to read rebasestate in a separate function This will help us in plugging the use of state.cmdstate() to read rebasestate. Differential Revision: https://phab.mercurial-scm.org/D3873

revlog: reuse 'descendant' implemention in 'isancestor' The two functions do the same thing, but one takes nodes while the other takes revs. Using one to implement the other make sense. We should probably cleanup the API at some point to avoid having so many similar functions. However, we focus on an efficient implementation for now.

revlog: efficient implementation of 'descendant' Iterating over descendants is costly, because there are no "parent -> children" pointers. Walking the other way around is much more efficient, especially on large repositories, where descendant walks can cost seconds. And the other hand, common ancestors code follows links in the right direction and has a compiled implementation. In real life usage, this saved up to 80s during some pull operations, where descendant test happens in extension code.

revlog: refactor out the rev-oriented part of commonancestorheads We plan to use this in a function taking revs as argument. Round trips to nodes seem silly.

revlog: do inclusive descendant testing (API) In many other places, a revision is considered a descendant of itself. We update the behavior of `revlog.descendant()` to match this. (for example. `revlog.isancestor` does inclusive testing). No tests break, so it seems safe to do so. This will make it easier to use a more efficient implementation in a later changeset.