templater: pull in functions defined in templatefilters

templater: add if/ifeq conditionals

templater: add sub() function

templater: correctly deal with r"" strings

template: add join function This allows: {join(files % "{files}", ", ") }\n to produce a properly comma-separated list

templater: factor out runtemplate method As a side-effect, this makes the output of runmap non-flattened

templating: make new-style templating features work with command line lists

formatter: improve implementation of data method This alternate syntax was proposed by Bryan O'Sullivan in a review of 772b3764d3e8. I haven't been able to measure any particular performance difference, but the new syntax is more concise and easier to read.

Merge with crew-stable

archival: add "extended-timestamp" extra block for zip archives (issue3600) Before this patch, zip archives created by "hg archive" are extracted with unexpected timestamp, if TZ is not configured as GMT. This patch adds "extended-timestamp" extra block to zip archives, and unzip will extract such archives with timestamp specified in added extra block, even though TZ is not configured as GMT. Please see documents below for detail about specification of zip file format and "extended-timestamp" extra block: http://www.pkware.com/documents/casestudies/APPNOTE.TXT http://www.opensource.apple.com/source/zip/zip-6/unzip/unzip/proginfo/extra.fld Original implementation of this patch was suggested by "Jun Omae <jun66j5@gmail.com>".

bookmarks: use "changectx.descendant()" for efficient descendant examination This patch uses "old.descendant(new)" expression instead of "new in old.descendants()" for efficiency.

context: add "descendant()" to changectx for efficient descendant examination This patch adds "descendant()", which uses "revlog.descendant()" for descendant examination, to changectx. This implementation is more efficient than "new in old.descendants()" expression, because: - "changectx.descendants()" creates temporary "changectx" objects, but "revlog.descendant()" doesn't "revlog.descendant()" checks only revision numbers of descendants. - "revlog.descendant()" stops scanning, when scanning of all revisions less than one of examination target is finished this can avoid useless scanning in "not descendant" case.

bookmarks: avoid redundant creation/assignment of "validdests" in "validdest()"

store: add a fallback _pathencode Python function which does the equivalent of parsers.pathencode, so it can be used as a default

store: move _plainhybridencode and _dothybridencode higher up in the file no functional change

test-hybridencode: use store._dothybridencode(s) and compare it with the result of store._hybridencode(s, True)

store: fix _hashencode call in _dothybridencode Fixes 7840d81a80ec

check-code: catch yield inside try/finally (with tests) This is not allowed in Python 2.4.

Merge with mpm

store: use native fncache encoding function if available This currently falls back to Python for hashed encoding.

tests: run test-hybridencode.py over both Python and C encoders This ensures that the two always give the same answers.

store: implement fncache basic path encoding in C (This is not yet enabled; it will be turned on in a followup patch.) The path encoding performed by fncache is complex and (perhaps surprisingly) slow enough to negatively affect the overall performance of Mercurial. For a short path (< 120 bytes), the Python code can be reduced to a fairly tractable state machine that either determines that nothing needs to be done in a single pass, or performs the encoding in a second pass. For longer paths, we avoid the more complicated hashed encoding scheme for now, and fall back to Python. Raw performance: I measured in a repo containing 150,000 files in its tip manifest, with a median path name length of 57 bytes, and 95th percentile of 96 bytes. In this repo, the Python code takes 3.1 seconds to encode all path names, while the hybrid C-and-Python code (called from Python) takes 0.21 seconds, for a speedup of about 14. Across several other large repositories, I've measured the speedup from the C code at between 26x and 40x. For path names above 120 bytes where we must fall back to Python for hashed encoding, the speedup is about 1.7x. Thus absolute performance will depend strongly on the characteristics of a particular repository.

rebase: ensure rebase does not revive extinct revision Here, we exclude hidden changesets from a rebase operation. If we don't, a rewritten version of the hidden changesets will be created by rebase. Those rewritten versions won't be hidden and will likely conflict with other rewriting or revive pruned changeset. Moreover, rewriting hidden revisions will surprise the user. This change would not be necessary if changelog filtering were already in core. But it's fairly cheap and helps to increase the test-suite for such filtering. Once changelog level filtering is added, hidden changes will be automatically excluded or included according to the global --hidden flags. Plain ignoring them is good enough for now.

rebase: remove useless list around repo.revs As repo.revs already returns a list.

rebase: properly handle --collapse when creating obsolescence marker In collapse mode, that content of state is not suitable to compute obsolescence markers. We explicitly pass the resulting revision instead and use it as the successors for all elements of the rebased set.

rebase: allow creation obsolescence relation instead of stripping When obsolescence feature is enabled we now create markers from the rebased set to the resulting set instead of stripping. The "state" mapping built by rebase holds all necessary data. Changesets "deleted" by the rebase are marked "succeeded" by the changeset they would be rebased one. That the best guess of "successors" we have. Getting a successors as meaningful as possible is important for automatic resolution of obsolescence troubles. In other word, emptied changeset will looks collapsed with their former parents. (see "empty changeset" section of the test if you are still confused)

rebase: extract final changesets cleanup logic in a dedicated function At the end of the rebase, rebased changesets are currently stripped. This behavior will be eventually dropped in favor of obsolescence marker creation. The main rebase function is already big and branchy enough. This changeset move the clean-up logic in a dedicated function before we make it more complex.

store: refactor hashed encoding into its own function

store: reuse direncoded path in _hybridencode For a netbeans clone on Windows 7 x64: Before: $ hg perffncacheencode ! wall 3.516000 comb 3.525623 user 3.525623 sys 0.000000 (best of 3) After: $ hg perffncacheencode ! wall 3.443000 comb 3.447622 user 3.447622 sys 0.000000 (best of 3)

store: extract functions _encodefname and _decodefname