revbranchcache: populate cache incrementally Previously the cache would populate completely the first time it was accessed. This could take over a minute on larger repos. This patch changes it to update incrementally. Only values that are read will be written, and it will only rewrite as much of the file as strictly necessary. This adds a magic value of '\0\0\0\0' to represent an empty cache entry. The probability of this matching an actual commit hash prefix is tiny, so it's ok if that's always considered a cache miss. This is also BC safe since any existing entries with '\0\0\0\0' will just be considered misses. Perf numbers: Mozilla-central: hg --time log -r 'branch(mobile)' -T. Cold Cache: 14.7s -> 15.1s (3% worse) Warm Cache: 1.6s -> 2.1s (30% worse) Mozilla-cental: hg perfbranchmap 2s -> 2.4s (20% worse) hg: hg log -r 'branch(stable) & branch(default)' Cold Cache: 3.1s -> 1.9s (40% better - because the old code missed the cache on both branch() revset iterations, so it did twice the work) Warm Cache: 0.2 -> 0.26 (30% worse) internal huge repo: hg --time log -r 'tip & branch(default)' Cold Cache: 65.4s -> 0.2s (327x better) While this change introduces minor regressions when iterating over every commit in a branch, it massively improves the cold cache time for operations which touch a single commit. I feel the better O() is worth it in this case.

revbranchcache: move entry writing to a separate function This moves the actual writing of entries to the cache to a separate function. This will allow us to use it in multiple places. Ex: in one place we will write dummy entries, and in another place we will write real data.

revbranchcache: store repo on the object Previously we would instantiate the revbranchcache with a repo object, use it briefly, then require it be passed in every time we wanted to fetch any information. This seems unnecessary since it's obviously specific to that repo (since it was constructed with it). This patch stores the repo on the revbranchcache object, and removes the repo parameter from the various functions on that class. This has the other nice benefit of removing the double-revbranchcache-read that existed before (it was read once for the branch revset, and once for the repo.revbranchcache).

revbranchcache: move out of branchmap onto localrepo Previously the revbranchcache was a field inside the branchmap. This is bad for a couple reasons: 1) There can be multiple branchmaps per repo (one for each filter level). There can only be one revbranchcache per repo. In fact, a revbranchcache could only exist on a branchmap that was for the unfiltered view, so you could have branchmaps exist for which you couldn't have a revbranchcache. It was funky. 2) The write lifecycle for the revbranchcache is going to be different from the branchmap (branchmap is greedily written early on, revbranchcache should be lazily computed and written). This patch moves the revbranchcache to live as a field on the localrepo (alongside self._branchmap). This will allow us to handle it's lifecycle differently, which will let us move it to be lazily computed in future patches.

revbranchcache: add test for when the cache is not writable The revbranchecache code already handled the case when the cache file wasn't writable, but let's add a test as well so future changes don't regress this.

patch.trydiff: add a docstring It took me a bit to figure out what this function actually does.

keyword: monkeypatch patch.diff more generically This function doesn't need access to any of the args or kwargs, so make the monkeypatching more robust. (In upcoming patches we'll introduce another argument to patch.diff, and this function would break if it weren't for this patch.)

keyword: rename kw_diff to kwdiff in keeping with Mercurial style rules In an upcoming patch we'll change this function's signature. If the name is kept the same, test-check-commit-hg.t complains.

fetch: use an abort hint where appropriate

eol: replace "working copy" with "working directory" in extension help

revset: replace "working copy" with "working directory" in function help

commands: say "working directory" in full spelling

commands: replace "working copy" with "working directory" in help/messages "working directory" is the standard term, we should use it consistently. But I didn't touch the hint, "run 'hg update' to get a working copy", because "get a working directory" sounds a bit odd.

test-commit-interactive-curses: #require 'tic' When run on Windows, this test aborts: @@ -20,7 +20,8 @@ > X > EOF $ hg commit -i -m "a" -d "0 0" - no changes to record + abort: No module named fcntl! + [255] $ hg tip changeset: -1:000000000000 tag: tip Maybe there's another way to get the screen size on Windows (it dies in crecord.gethw()), but for now, quiet the test noise by skipping it if terminal info compiler is unavailable.

check-code: enforce the usage of 'seq.py' instead of 'seq'

tests: replace uses of 'seq' with portable 'seq.py'

tests: introduce 'seq.py' as a portable replacement for 'seq' OS X 10.6.8 doesn't have it, while 10.10 does. I'm not sure when it was added. It may be missing from other platforms as well. This currently doesn't handle the string manipulation options (-f, -s and -w in MinGW anyway), since there is currently no need for it. Since xrange defaults to starting at 0 instead of 1, and treats the end as exclusive instead of inclusive, the args need to be extracted instead of doing: xrange(*[int(a) for a in sys.argv[1:]]) Therefore, the step might as well be added, even though there is no current use.

revert: add flag to make revert interactive

record: move ui.write wrapping where it should be We have to do that for the coloring to work in interactive revert

record: refactor the filtering code

record: consolidate ui.write wrapping in a function

bookmarks: reuse @number bookmark, if it refers changeset referred remotely Before this patch, "@number" suffixed bookmark may be newly created at each "hg pull" from the remote repository, if the bookmark in remote repository diverges from one in local one. This causes unexpected increase of "@number" suffixed bookmarks. This patch reuses "@number" suffixed bookmark, if it refers the changeset which is referred by the same bookmark in the remote repository.

bookmarks: check @pathalias suffix before available @number for efficiency Before this patch, available "@number" suffix is searched before "@pathalias" suffix, even though the latter has higher priority than the former if the latter exits. This patch checks "@pathalias" suffix before available "@number" for efficiency. When an URL has multiple path definitions, the first one is used for "pathalias" after this patch, even though the last one is used before this patch, because: - this choice can terminate loop immediately for efficiency - such case seems to be rare

bookmarks: prevent divergent bookmark from being updated unexpectedly Before this patch, "@99" suffixed bookmark may be updated unexpectedly by the bookmark value on the remote side at "hg pull", if all of "@1" to "@99" suffixed bookmarks exist in the local repository, because variable "n" still refers "@99" suffixed bookmark after the loop to examine "@num" suffixes, even though it already exists in the local repository. This patch prevents divergent bookmark from being updated unexpectedly, and shows warning message in such situation. This patch uses original python script "seq.py" instead of "seq" command to create sequence numbers in the test, because "seq" command may not be available: it isn't defined in recent POSIX specification (POSIX.1-2001 2013 Edition or XPG7)

manifest: include Python.h before standard headers Python.h should be included before any standard headers according to the python docs: https://docs.python.org/2/c-api/intro.html#include-files

crecord: use colwidth instead of ucolwidth

manifest: speed up matches for large sets of files If the number of files being matched is large, the bisection overhead can dominate, which caused a performance regression for revert --all and histedit. This introduces a (fairly arbitrary) cross-over from using bisections to bulk search.

perf: add methods for timing changeset file list reading

censor: add exchange tests, via local push/pull and bundle/unbundle These tests exercise the edge cases of exchanging censored commits between censor-aware Mercurial clients. These tests do not extend to cover backwards-compatible exchange; such tests require a script which builds older versions of Mercurial. For more background on the censorship feature design, see: http://mercurial.selenic.com/wiki/CensorPlan

censor: add censor command to hgext with basic client-side tests The censor command is a core extension which can replace the contents of a historical file revision with a censor "tombstone" which can be exchanged with older clients in place of the real revision data. The command rewrites the filelog by copying revision-by-revision. Care must be taken to expand the fulltext of the children of the censored revision before copying them to the new filelog; they might be stored as deltas against the uncensored revision, and those deltas will be invalidated. For more background on the censorship feature design, see: http://mercurial.selenic.com/wiki/CensorPlan

record: add comparison methods for recordhunk class

record: minor refactoring of dorecord It prepares the way for introducing the flag to reverse hunk selection

record: add tests for the curses recording interface

record: enable curses recording logic with experimental flag

record: change arguments of curses recording function This way the arguments are the same for both curses and non-curses versions.

record: change interface of the filtering function This way filtering functions accept chunks and return chunks

hgweb: replace 'ctx._repo' with 'ctx.repo()'

pvec: replace 'ctx._repo' with 'ctx.repo()'

scmutil: replace 'ctx._repo' with 'ctx.repo()'

templater: replace 'ctx._repo' with 'ctx.repo()'

largefiles: replace 'ctx._repo' with 'ctx.repo()'

obsolete: replace 'ctx._repo' with 'ctx.repo()'

fileset: replace 'ctx._repo' with 'ctx.repo()'

filectx: add a repo accessor This is similar to a07314472a80 in motivation. All contexts now have this method, so the rest of the 'ctx._repo' uses can be converted without worrying about what type of context it is.

run-tests: ignore ENOENT failures when removing old .err results When the same test runs in multiple threads and the previous run was a failure, the threads can race to delete the error output. This fixes that.

run-tests: stop storing start/stop times in a dict by test name This resolves the last breakage in run-tests that prevented me from running a single test many times in several threads in parallel. This will be useful for testing potential fixes to flaky tests.

run-tests: avoid running the same test instance concurrently There's a fair amount of mutable state stored on test case instances. That causes many weird failures if you try to do something like `run-tests.py -j16 --loop test-help.t`. The quick fix is this slightly weird test-reloading dance, which ensures that every time a test is executed it runs on a fresh instance of the TestCase subclass.

run-tests: add --runs-per-test flag This is useful when you're working with a flaky test and want to run it (for example) 500 times to see if it'll false-fail. This currently breaks if you use it with more than one thread, but I'm looking into that now.