tests: move mock blackbox extension into own file Having all blackbox log testing in test-blackbox.t isn't scalable. Move the mock blackbox extension into its own file so we can start to move blackbox logging into other tests.

shelve: acquire lock in the right order Text book says that 'wlock' should be acquired before 'lock'. Caught through developer warning.

check-commit: be more picky about detection of wrong bug tag The check-commit script search for "bug" withing bracket and ask people to use (issueXXXX) instead. The test was too wide and matching any "(+b+u+g"sequence.

discovery: don't compute allfuturecommon when it won't be used In repos with many changesets, the computation of allfuturecommon can take a significant amount of time. Since it's only used if there's an obsstore, don't compute it otherwise.

treemanifest: separate flags for trees in memory and trees on disk When we start writing tree manifests with one manifest revlog per directory, it will still be nice to be able to run tests using tree manifests in memory but writing to a flat manifest to a single revlog. Let's break the current '_usetreemanifest' flag on the revlog into '_treeinmem' and '_treeondisk'. Both are populated from the same config, but after this change, one can temporarily hard-code _treeinmem=True to see that tests still pass.

manifestdict: drop empty-string argument when creating empty manifest manifestdict() creates an empty manifestdict, so let's consistently use that instead of explicitly parsing an empty string (which does result in an empty manifest).

lazymanifest: fix memory leak in lmiter_iterentriesnext() after 3d485727e45e

revert: do not requires '--all' if '--interative' is present The '--all' option have been introduced in 890e285c52a1 (August 2006), most probably to prevent user shooting themselves in the foot. As the record process will let you, view and select the set of files and change you want to revert, I feel like the '--all' flag is superfluous in the '--interactive' case.

bundle2: drop the experimental hooks The series at e9ede9b4c2f8::8e13cc0825f1 introduced generic transaction level hooking. This makes the experimental bundle2 specific hooks redundant, we drop them.

bundle2: advertise bundle2 by default That way, any new server will be ready to accept bundle2 payload. The decision for the client to use it is still off by default so this is not turning bundle2 everywhere. We introduce a new kill switch for this in case stuff goes wrong.

subrepo: convert the os.path references in git to vfs There are a handful of os.path references in the free functions at the top of the module that will be trickier to remove.

subrepo: use vfs.removedirs instead of os.removedirs This patch also removes useless composing absolute path by "repo.wjoin()".

vfs: add removedirs

util: add removedirs as platform depending function According to fa901423ac23 introducing "windows._removedirs()": If a hg repository including working directory is a reparse point (directory symlinked or a junction point), then using os.removedirs will remove the reparse point erroneously. "windows._removedirs()" should be used instead of "os.removedirs()" on Windows. This patch adds "removedirs" as platform depending function to replace "os.removedirs()" invocations for portability and safety

subrepo: use vfs.unlink instead of os.remove This patch also removes useless composing absolute path by "os.path.join()".

subrepo: use vfs.rmtree instead of shutil.rmtree This patch also removes useless "shutil" import.

vfs: add rmtree This duplicates "onerror()" function from "svnsubrepo.remove()" for equivalence of replacing in subsequent patch. This "onerror()" function for "shutil.rmtree()" was introduced by 92b0d669637f, which avoids failure of removing svn repository on Windows.

subrepo: use vfs.readdir instead of os.listdir to avoid expensive stat calls "kind" information given from "vfs.readdir()" makes expensive stat calls "os.path.isdir()" and "os.path.islink()" useless.

editor: prefer 'intermediate-source' extra to use for HGREVISION environment variable Revision 51930a7180bd ('graft: record intermediate grafts in extras') introduced 'intermediate-source' extra which refers to the closest graft source. As 'intermediate-source' extra provides more detailed information about the source changeset than 'source' one, it is better to prefer the first one to use as a value of HGREVISION environment variable for an editor.

bundle2: rename format, parts and config to final names It is finally time to freeze the bundle2 format! To do so we: - rename HG2Y to HG20, - drop "b2x:" prefix from all part names, - rename capability to "bundle2-exp" to "bundle2" - rename the hook flag from 'bundle2-exp' to 'bundle2'

manifestdict: extract condition for _intersectfiles() and use for walk() The condition on which manifestdict.matches() and manifestdict.walk() take the fast path of iterating over files instead of the manifest, is slightly different. Specifically, walk() does not take the fast path for exact matchers and it does not avoid taking the fast path when there are more than 100 files. Let's extract the condition so we don't have to maintain it in two places and so walk() can gain these two missing pieces of the condition (although there seems to be no current caller of walk() with an exact matcher).

manifestdict.walk: remove now-redundant check for match.files() When checking whether we can take the fast path of iterating over matcher files instead of manifest files, we check whether match.files() is non-empty. However, now that return early for match.always(), it can only be empty when there are only include/exclude patterns, but in that case anypats() will be True, so it's already covered. This makes manifestdict.walk() more similar to manifestdict.matches().

manifest.walk: special-case match.always() for speed This cuts down the run time of hg files -r . > /dev/null from ~0.850s to ~0.780s on the Firefox repo. Note that manifest.matches() already has the corresponding optimization.

manifest.walk: use return instead of StopIteration in generator Using "return" within a generator is supposedly more Pythonic than raising StopIteration.

archive: look for first visible revision to build repo identity (issue4591) No test for the case where all revisions are hidden because "archive" command aborts if the target revision is null.

largefiles: use common function to build content of .hg_archival.txt This fixes the missing "changessincelatesttag" field introduced by 242d11819c6c.

test-largefiles: verify content of .hg_archival.txt

archive: extract metadata() closure to module-level function This function will be reused in largefiles.

archive: use ctx object consistently to build meta data

templatekw: have {manifest} use ctx.manifestnode() for consistency changeset_printer was updated at f57640bf10d4 to not access changeset by index.

subrepo: use vfs.reljoin instead of os.path.join

subrepo: inline reporelpath into abstractsubrepo._relpath to centralize logic "reporelpath()" is referred only from "abstractsubrepo._relpath()".

subrepo: add _relpath field to centralize subrelpath logic This patch adds propertycache-ed "_relpath" field to "abstractsubrepo", to centralize "subrelpath" logic into it. Now, "subrelpath()" can always return "_relpath" field of the specified subrepo object, because it is ensured that subrepo object has it. To reduce changes in this patch, "subrelpath()" itself is still kept, even though it seems to be redundant. This is also a part of eliminating "os.path.*" API invocations for "Windows UTF-8 Plan".

subrepo: add wvfs field to access the working directory via vfs This patch doesn't create vfs object in "abstractsubrepo.__init__()" but adds propertycache-ed "wvfs" field, because the latter can: - delay vfs instantiation until it is actually needed - allow to use "hgsubrepo._repo.wvfs" as "wvfs" "hgsubrepo._repo" is initialized after "abstractsubrepo.__init__()" invocation, and passing "hgsubrepo._repo.wvfs" to "abstractsubrepo.__init__()" is difficult.

subrepo: change arguments of abstractsubrepo.__init__ (API) This patch passes "ctx" and "path" instead of "ui" to "abstractsubrepo.__init__()" and stores them as "_ctx" and "_path" to use them in subsequent patches. This also removes redundant field initializations in the constructor of classes derived from "abstractsubrepo".

treemanifest: optimize treemanifest._walk() to skip directories This makes treemanifest.walk() not visit submanifests that are known not to have any matching files. It does this by calling match.visitdir() on submanifests as it walks. This change also updates largefiles to be able to work with this new behavior in treemanifests. It overrides match.visitdir(), the function that dictates how walk() and matches() skip over directories. The greatest speed improvements are seen with narrower scopes. For example, this commit speeds up the following command on the Mozilla repo from 1.14s to 1.02s: hg files -r . dom/apps/ Whereas with a wider scope, dom/, the speed only improves from 1.21s to 1.13s. As with similar a similar optimization to treemanifest.matches(), this change will bring out even bigger performance improvements once treemanifests are loaded lazily. Once that happens, we won't just skip over looking at submanifests, but we'll skip even loading them.

import-checker: force 'fcntl', 'grp', 'pwd', and 'termios' to stdlib modules These are Unix only, and caused these additional warnings on Windows if they aren't hardcoded as stdlib: mercurial/posix.py mixed imports stdlib: errno, getpass, os, socket, stat, sys, tempfile relative: grp, pwd, unicodedata mercurial/posix.py mixed imports stdlib: re relative: fcntl mercurial/posix.py mixed imports stdlib: array relative: termios Additionally, this was missing on Windows: mercurial/crecord.py mixed imports stdlib: fcntl, termios relative: curses https://docs.python.org/2/library/fcntl.html https://docs.python.org/2/library/grp.html https://docs.python.org/2/library/pwd.html https://docs.python.org/2/library/termios.html

import-checker: allow *.pyd based stdlib modules These are Windows dlls, and eliminate the following import check diffs that are not on Unix: mercurial/changegroup.py mixed imports stdlib: os, struct, tempfile, zlib relative: bz2 mercurial/encoding.py mixed imports stdlib: locale, os relative: unicodedata

manifest.walk: join nested if-conditions This makes it more closely match the similar condition in manifestdict.matches().

manifestdict: inline _intersectfiles() The _intersectfiles() method is only called from one place, it's pretty short, and its caller has to be aware when it's appropriate to call it (when the number of files in the matcher is not too large), so let's inline it.

manifestdict._intersectfiles: avoid one level of property indirection We have already bothered to extract "lm = self._lm", so let's use "lm" where possible.

manifestdict.matches: avoid name 'lm' for a not-lazymanifest

commands: add ui.statuscopies config knob statuscopies enables viewing of copies and moves in 'hg status' by default.

changelog: inline revlog.__contains__ in case it is used in hot loop Currently __contains__ is called only by "rev()" revset, but "x in cl" is a function that is likely to be used in hot loop. revlog.__contains__ is simple enough to duplicate to changelog, so just inline it.

bookmarks: show detailed status about outgoing bookmarks Before this patch, "hg outgoing -B" shows only difference of bookmarks between two repositories, and it isn't user friendly. This patch shows detailed status about outgoing bookmarks at "hg outgoing -B". To avoid breaking backward compatibility with other tool chains, this patch shows status, only if --verbose is specified,

bookmarks: show detailed status about incoming bookmarks Before this patch, "hg incoming -B" shows only difference of bookmarks between two repositories, and it isn't user friendly. This patch shows detailed status about incoming bookmarks at "hg incoming -B". To avoid breaking backward compatibility with other tool chains, this patch shows status, only if --verbose is specified,

bookmarks: enhance test of showing detail about incoming/outgoing bookmarks

bookmarks: show outgoing bookmarks more exactly Before this patch, "hg outgoing -B" shows only bookmarks added locally. Then, users can't know about bookmarks below before "hg push" execution. - deleted locally (even though it may be added remotely from "hg pull" view) - advanced locally - diverged - changed (= remote revision is unknown for local) This patch shows such bookmarks, too.

bookmarks: show incoming bookmarks more exactly Before this patch, "hg incoming -B" shows only bookmarks added remotely. Then, users can't know about bookmarks below before "hg pull" execution. - advanced remotely - diverged - changed (remote revision is unknown for local) This patch shows such bookmarks, too.

test-manifest: add some test coverage for treemanifest Similar to the testmanifest test case, testtreemanifest extends the base test case but uses treemanifests instead of manifestdicts. Adding this test provides some basic test coverage of treemanifest within the standard test suite.

test-manifest: make manifesttest a base class that is extended The implementation of the testmanifest test case is moved to a new base class, which is then extended to make the testmanifest. And instead of testmanifest, the subclass is named testmanifestdict because, well, that's what it's testing. This refactoring makes it possible to create alternate versions of what was formerly testmanifest, improving test coverage of different manifestdict implementations.

test-manifest: move parsemanifest() to be a testmanifest class method This refactoring lets testmanifest subclasses override this method to return different manifestdict implementations, such as treemanifest. It is useful for later commits where the testmanifest class is moved into a base class, and test cases that extend the base class can provide their own parsemanifest() implementation.

windows: allow readpipe() to actually read data out of the pipe It appears that the read() in readpipe() never actually ran before (in test-ssh.t anyway). A print of the size returned from os.fstat() is 0 for every single print output in test-ssh.t, so the data in the pipe ends up being read later instead of when it is available. This is the same problem as Linux, as mentioned in 331cbf088c4c. There are several places in the Windows SSH tests where the order of local output vs remote output differ from the other platforms. This only fixes one of those cases (and interstingly, not the one added in order to test 331cbf088c4c), so there is more investigation needed. However, without this patch, test-ssh.t also has this diff: --- c:/Users/Matt/Projects/hg/tests/test-ssh.t +++ c:/Users/Matt/Projects/hg/tests/test-ssh.t.err @@ -397,11 +397,11 @@ $ hg push --ssh "sh ../ssh.sh" pushing to ssh://user@dummy/*/remote (glob) searching for changes - remote: Permission denied - remote: abort: prechangegroup.hg-ssh hook failed - remote: Permission denied - remote: pushkey-abort: prepushkey.hg-ssh hook failed updating 6c0482d977a3 to public failed! + remote: Permission denied + remote: abort: prechangegroup.hg-ssh hook failed + remote: Permission denied + remote: pushkey-abort: prepushkey.hg-ssh hook failed [1] $ cd .. Output with this change was stable over 600+ runs of test-ssh.t. I initially tried a background thread to read the pipe[1], but this was simpler and the test results were exactly the same. I also tried SetNamedPipeHandleState(), but the PIPE_NOWAIT is for compatibility with LANMAN 2.0, not for async I/O (the results were identical though). [1] http://eyalarubas.com/python-subproc-nonblock.html

win32: add a method to fetch the available pipe data size This will be used in the next patch to do nonblocking reads from the child process, like on posix platforms. See that for why os.fstat() is insufficient.

dirs._addpath: reinstate use of Py_CLEAR I changed this to an explicit Py_DECREF + set to null in 6f0e6fa9fdd7. This was a silly misunderstanding on my part -- for some reason I thought Py_CLEAR set its argument to null only if its refcount reached 0. Turns out that's not actually the case -- Py_CLEAR is just Py_DECREF + set to null with some additional precautions around destructors that aren't relevant here. The real bug that 6f0e6fa9fdd7 fixed was the fact that we were mutating the string after setting it in the Python dictionary.

exchange: introduce a '_canusebundle2' function This function refactors the logic that decides to use 'bundle2' during an exchange (pull/push). This will help being consistent while transitioning from the experimental protocol to the final frozen version. I do not expect this function to survive on the long run when using 'bundle2' will become a simple capability check. This is also necessary to allow HG2Y support in an extension to ease transition of companies using the experimental protocol in production (yeah...). Such extension will be able to wrap this function to use the experimental protocol in some case.

bundle2: detect bundle2 stream/request on /HG2./ instead of /HG2Y/ To support more bundle2 formats, we need a wider detection of bundle2-family streams. The various places what were explicitly detecting the full magic string are now matching on the first three characters of it.

unbundle20: allow generic dispatch between unbundlers We now take full advantage of the 'getunbundler' function by using a '{version -> unbundler-class}' mapping. This map currently contains a single entry but will make it easy to support more versions from an extension/the future. At some point, this map will probably contain bundler-class information too, in the same fashion the packer map does. However, this is not critically required right now so it will happen by itself when needed. The main target is to allow HG2Y support in an extension to ease transition of companies using the experimental protocol in production (yeah...) But I've no doubt this will be useful when playing with a future HG21.

treemanifest: refactor treemanifest.walk() This refactor is a preparation for an optimization in the next commit. This introduces a recursive element that recurses each submanifest. By using a recursive function, the next commit can avoid walking over some subdirectories altogether.

manifest: move changectx.walk() to manifests The logic of walking a manifest to yield files matching a match object is currently being done by context, not the manifest itself. This moves the walk() function to both manifestdict and treemanifest. This separate implementation will also permit differing, optimized implementations for each manifest.

subrepo: precisely identify the missing subrepo spec file It isn't obvious which file is the problem with deep subrepos, so provide the path. Since the parsing is done with a ctx and not a subrepo object, it isn't possible to display a path from the root subrepo. Therefore, the path shown is relative to cwd. There's no test coverage for the first abort, and I couldn't figure out how to trigger it, but it is changed for consistency.

graft: record intermediate grafts in extras Previously the extra field for a graft only contained the original commit hash. This made it impossible to use graft to copy a commit more than once, because the extras fields did not change after the second graft. The fix is to add an extra.intermediate-source field that records the immediate predecessor to graft. This changes hashes for commits that have been grafted twice, which is why the test was affected.

graft: allow creating sibling grafts Previously it was impossible to graft a commit onto it's own parent (i.e. create a copy of the commit). This is useful when wanting to create a backup of the commit before continuing to amend it. This patch enables that behavior. The change to the histedit test is because histedit uses graft to apply commits. The test in question moves a commit backwards onto an ancestor. Since the graft logic now more explicitly supports this, it knows to simply accept the incoming changes (since they are more recent), instead of prompting.

unbundle20: move header parsing into the 'getunbundler' function The dispatching will be based on the header content, so we need to move this logic into the factory function.

unbundle20: retrieve unbundler instances through a factory function To support multiple bundle2 formats, we will need a function returning the proper unbundler according to the header. We introduce such aa function and change the usage in the code base. The function will get smarter in later changesets. This is somewhat similar to the dispatching we do for 'HG10' and 'HG11'. The main target is to allow HG2Y support in an extension to ease transition of companies using the experimental protocol in production (yeah...) But I've no doubt this will be useful when playing with a future HG21.

bundle20: move magic string into the class This makes it easy to create a new bundler class that inherits from the core one. This matches the way 'changegroup' packers work. The main target is to allow HG2Y support in an extension to ease transition of companies using the experimental protocol in production (yeah...) But I've no doubt this will be useful when playing with a future HG21.

localrepo.getbundle: drop unused 'format' argument The 'format' argument was not used even when it was added in 60ad2ea5b106 (getbundle: pass arbitrary arguments all along the call chain, 2014-04-17). Note that by removing the argument, if any caller did pass a named 'format' argument, we will now pass that along to exchange.getbundle() via the kwargs. If the idea was to remove such a key, that should have been done explicitly.

exchange: remove check for 'format' key When the 'kwargs' variable was added in 12f161f08d74 (bundle2: allow pulling changegroups using bundle2, 2014-04-01), it could contain only 'bundlecaps', 'common' and 'heads', so the check for 'format' would always be false. Since then, _pullbundle2extraprepare() has been added for hooks, but it seems unlikely that they would a 'format' key.

templates-default: do not show description or summary if empty changeset_printer shows description only if ctx.description().strip() is not empty. The default template should do the same way.

treemanifest: further optimize treemanifest.matches() The matches function was previously traversing all submanifests to look for matching files, even though it was possible to know if a submanifest won't contain any matches. This change adds a visitdir function on the match object to decide quickly if a directory should be visited when traversing. The function also decides if _all_ subdirectories should be traversed. Adding this logic as methods on the match object also makes the logic modifiable by extensions, such as largefiles. An example of a command this speeds up is running hg status --rev .^ python/ on the Mozilla repo with the treemanifest experiment enabled. It goes from 2.03s to 1.85s. More improvements to speed from this change will happen when treemanifests are lazily loaded. Because a flat manifest is still loaded and then converted into treemanifests, speed improvements are limited. This change has no negative effect on speed. For a worst-case example, this command is not negatively impacted: hg status --rev .^ 'relglob:*.js' on the Mozilla repo. It goes from 2.83s to 2.82s.

util: move dirs() and finddirs() from scmutil to util An upcoming commit requires that match.py be able to call scmutil.dirs(), but when match.py imports scmutil, a dependency cycle is created. This commit avoids the cycle by moving dirs() and its related finddirs() function from scmutil to util, which match.py already depends on.

parsers: remove unused dependency on util Parsers.py had a reference to util.sha1 which was unused. This commit removes this reference as well as the unused import of util to simplify the dependency graph. This is important for the next commit which actually relocates part of a module to eliminate a cycle.

changectx.walk: drop unnecessary call to match function If all the files in match.files() are in the context/manifest, we already know that the matcher will match each file.

merge with stable

largefiles: use the share source as the primary local store (issue4471) The benefit of retargeting the local store to the share source is that all shares will always have access to the largefiles any one of them commit, even if the user cache is deleted (which is documented to be OK to do). Further, any push into the source (and now any shares), will likewise make the largefile(s) visible to all related repositories. In order to maintain compatibility with existing repos, where the largefiles would be cached only in the local share, fallback to searching the local share if it isn't found at the share source. The unshare command should probably be taught to copy the source store into the store for the repo being unshared to complete the loop. This patch changes the test like this: @@ -159,6 +159,5 @@ $ hg share -q src share_dst --config extensions.share= $ hg -R share_dst update -r0 getting changed largefiles - large: largefile $HASH not available from file:///$TESTTMP\share_dst - 0 largefiles updated, 0 removed + 1 largefiles updated, 0 removed 1 files updated, 0 files merged, 0 files removed, 0 files unresolved The issue writeup mentions pushing a largefile from a remote repo to the main local repo, and the largefile is then not available in any shares. Since the push doesn't cache the largefile in $USERCACHE, the trashed $USERCACHE in this test is equivalent.

largefiles: use lfutil.findstorepath() when verifying a local repo

largefiles: introduce lfutil.findstorepath() The handful of direct uses of lfutil.storepath() merely need a single path to read from or write to the largefile, whether or not it exists. Most callers that care about the file existing call lfutil.findfile(), in order to fallback from the store to the user cache. localstore._verify() doesn't call lfutil.findfile(). This prevents redirecting the store to the share source because the largefiles for existing repos may not be in the source's store, so verification may fail. It can't be changed to call findfile(), because findfile() links the file from the usercache to the local store[1], and because it returns None instead of a path if the file doesn't exist. For now, this method is just a cover for lfutil.storepath(), but it will be filled out in an upcoming patch. [1] Maybe we shouldn't care? But on a filesystem that doesn't support hardlinks, then verify will take a lot longer, and start to consume disk space.

vfs: make it possible to pass multiple path elements to join os.path.join(), localrepo.join() and localrepo.wjoin() allow passing multiple path elements; vfs.join() should be as convenient.

largefiles: drop os.path reference in lfutil.storepath() localrepo.join() can concatenate multiple parts on its own.

histedit: fix preventing strips during histedit We were trying to prevent strips of important nodes during histedit, but the check was actually comparing the short hashes in the rules to the exact value the user typed in, so it only ever worked if the user typed a 12 character hash.

copies: pass changectx instead of manifest to _computenonoverlap The _computenonoverlap function takes two manifests to allow extensions to hook in and read the manifest nodes produced by the function. The remotefilelog extension actually needs the entire changectx instead (which includes the manifest) so it can prefetch the subset of files necessary for a sparse checkout (and the sparse checkout depends on which commit is being accessed, hence the need for the changectx). I have tests in the remotefilelog extension that cover this.

dirs._addpath: don't mutate Python strings after exposing them (issue4589) One of the rules of Python strings is that they're immutable. dirs._addpath breaks this assumption for performance, which is fine as long as it is done safely -- once a string is no longer internal-only it shouldn't be mutated. Unfortunately, we weren't being safe here -- we were mutating 'key' even after adding it to a dictionary. This only really affects other C code that reads strings, so it's somewhat hard to write a test for this without poking into the internal representation of the string via ctypes or similar. There is currently no C code that reads the output of the string, but there will likely be some soon as the bug indicates. There's no significant difference in performance.

parsers: check for memory allocation overflows more carefully

parsers.c: avoid implicit conversion loses integer precision warning This warning is raised by Apple LLVM version 6.0 (clang-600.0.57) (based on LLVM 3.5svn) and was introduced in 670aaee7931c

dirstate.walk: don't report same file stat multiple times dirstate.walk() generates pairs of filename and a stat-like object. After "hg mv foo Foo", it generates one pair for "foo" and one for "Foo", as it should. However, on case-insensitive file systems, when it tries to stat to get the disk state as well, it gets the same stat result for both names. This confuses at least scmutil._interestingfiles(), making it think that "foo" was forgotten rather than removed. That, in turn, makes "hg addremove" add "foo" back, resulting in both cases in the dirstate, as reported in issue4590. This change only takes care of the "if unknown" branch. A similar fix should perhaps be applied to the other branch.

repoview: avoid processing the same rev twice in _getstatichidden If a rev had multiple children, it would be added to the heap multiple times. We now ensure it is added only once.

repoview: skip public parent earlier in _getstatichidden Public changeset have nothing to offer regarding hidden changeset. Lets not add them to the heap at all.

repoview: directly skip public head in _getstatichidden Public heads have nothing to offer regarding hidden stuff, let's skip them.

repoview: simplify process in _getstatichidden Since all children are processed before their parents, we can apply the following algorithm: For each rev (descending order): * If I'm still hidden, no children will block me, * If I'm not hidden, I must remove my parent from the hidden set, This allows us to dynamically change the set of 'hidden' revisions, dropping the need for the 'actuallyhidden' dictionary and the 'blocked' boolean in the queue. As before, we start iterating from all heads and stop at the first public changesets. This ensures the hidden computation is 'O(not public())' instead of 'O(len(min(not public()):))'.

repoview: use a heap in _getstatichidden Since we want to process all non-public changesets from top to bottom, a heap seems more appropriate. This will ensure any revision is processed after all its children, opening the way to code simplification.

repoview: update documentation of _getstatichidden In 2f7cb6e6acdd, the function name, role and return was changed. But the documentation was not. This fixes it.

ssl: resolve symlink before checking for Apple python executable (issue4588) test-https.t was broken at 07fafcd4bc74 if /usr/bin/pythonX.Y is used on Mac OS X. If python executable is not named as "python", run-tests.py creates a symlink and hghave uses it. On the other hand, the installed hg executable knows the real path to the system Python. Therefore, there was an inconsistency that hghave said it was not an Apple python but hg knew it was.

test-subrepo-recursion: fix output on non-hardlink systems There's a slight bug present where a topic doesn't get closed when it should. This isn't a regression, so I've made a note in the test file.

test-subrepo-recursion: set progress.changedelay really high This avoids subtopics from showing up, which were introduced by my recent change that added progress bars to hardlink clones in some cases.

test-clone: fix test expectations on systems without hardlinks

dirstate: use parsers.make_file_foldmap when available This is a significant performance win on large repositories. perffilefoldmap: On Linux/gcc, on a test repo with over 500,000 files: before: wall 0.605021 comb 0.600000 user 0.560000 sys 0.040000 (best of 17) after: wall 0.280530 comb 0.280000 user 0.250000 sys 0.030000 (best of 35) On Mac OS X/clang, on a real-world repo with over 200,000 files: before: wall 0.281103 comb 0.280000 user 0.260000 sys 0.020000 (best of 34) after: wall 0.133622 comb 0.140000 user 0.120000 sys 0.020000 (best of 65) This visibly impacts status times on case-insensitive file systems. On the Mac OS X repo, status goes from 3.64 seconds to 3.50. With the third-party hgwatchman extension [1], 'hg status' on the same repo goes from 0.80 seconds to 0.65. [1] https://bitbucket.org/facebook/hgwatchman

parsers: add a C function to create a file foldmap This is a hot path on case-insensitive filesystems -- it's guaranteed to be called every time 'hg status' is run. This is significantly faster than the equivalent Python code: see the following patch for numbers.

util.h: define an enum for normcase specs These will be used in upcoming patches to efficiently create a dirstate foldmap.

perf: make measuring foldmap perf work again Rev 25c1d3ca5ff6 split the foldmap into two, but I forgot to update perf for the changes.

parsers._asciitransform: also accept a fallback function This function will be used in upcoming patches to provide a C implementation of the function to generate the foldmap.

util: add normcase spec and fallback These will be used in upcoming patches to efficiently create a dirstate foldmap.

hgk: display committer name when set by hg-git

jsonchangeset: set manifest node to "null" for workingctx Unlike changeset_printer, it does not hide the manifest field because JSON output will be parsed by machine where explicit "null" will be more useful than nothing.

jsonchangeset: set rev and node to "null" for workingctx

templater: tell hggettext to collect help of template functions

treemanifest: disable readdelta optimization When tree manifests are stored with one revlog per directory and loaded lazily, it's unclear how much readdelta will help. If only a few files change, then only a small part of the full manifest will be loaded, and the delta chains should also be shorter for tree manifests. Therefore, let's disable readdelta for tree manifests for now.

phases: make two functions private for phase computation

windows: define normcase spec and fallback These will be used in upcoming patches to efficiently create a dirstate foldmap.

encoding.upper: factor out fallback code This will be used as the fallback function on Windows.

cygwin: define normcase spec and fallback These will be used in upcoming patches to efficiently create a dirstate foldmap. The Cygwin normcase behavior is more complicated than just a simple lowercasing or uppercasing. That's why we specify 'other'.

darwin: define normcase spec and fallback These will be used in upcoming patches to efficiently create a dirstate foldmap.

posix: define normcase spec and fallback These will be used in upcoming patches to efficiently create a dirstate foldmap.

encoding: define an enum that specifies what normcase does to ASCII strings For C code we don't want to pay the cost of calling into a Python function for the common case of ASCII filenames. However, while on most POSIX platforms we normalize filenames by lowercasing them, on Windows we uppercase them. We define an enum here indicating the direction that filenames should be normalized as. Some platforms (notably Cygwin) have more complicated normalization behavior -- we add a case for that too. In upcoming patches we'll also define a fallback function that is called if the string has non-ASCII bytes. This enum will be replicated in the C code to make foldmaps. There's unfortunately no nice way to avoid that -- we can't have encoding import parsers because of import cycles. One way might be to have parsers import encoding, but accessing Python modules from C code is just awkward. The name 'normcasespecs' was chosen to indicate that this is merely an integer that specifies a behavior, not a function. The name was pluralized since in upcoming patches we'll introduce 'normcasespec' which will be one of these values.

merge with stable

json: implement {help} template We should consider add HTML rendering of the RST into the response as a follow-up. I attempted to do this, but there was an empty array returned by the rstdoc() template function. Not sure what's going on. Will deal with it later.

json: implement {helptopics} template

json: implement {manifest} template Property naming was borrowed from `hg files -Tjson`. We omit branch because, again, representation of branches in this template is wonky.

json: implement {shortlog} and {changelog} templates These are the same dispatch function under the hood. The only difference is the default number of entries to render and the template to use. So it makes sense to use a shared template. Format for {changelistentry} is similar to {changeset}. However, there are differences to argument names and their values preventing us from (easily) using the same template. (Perhaps there is room to consolidate the templates as a follow-up.) We're currently not recording some data in {changelistentry} that exists in {changeset}. This includes the branch name. This should be added in a follow-up. For now, something is better than nothing.

help: populate template functions via docstrings We do this for revsets, template keywrods, and template filters. Now we do it for template functions as well.

templater: add consistent docstrings to functions The content of "hg help templating" is largely derived from docstrings on functions providing functionality. Template functions are the long holdout. Prepare for generating them dynamically by defining docstrings for all template functions. There are numerous ways these docs could be improved. Right now, the help output simply shows function names and arguments. So literally any accurate data is better than what is there now.