setup.py, make: avoid problems with outdated, existing hgext/__index__.py* "make clean" already removed __index__.py[cdo], but not the __index__.py (automatically generated by "python setup.py build_hgextindex"). "setup.py build_hgextindex" did not generate a new index if file __index__.py[cdo] already existed, because if __index__.py was removed, the compiled file containing the old information was imported and used. Generate an empty file (with a new timestamp to generate a new .py[cdo]) instead and make mercurial.extensions ignore the unset docs attribute. One of the problems was a failed test-help.t, to reproduce: $ rm hgext/__index__.py* $ echo 'docs = {"mq": "dummy"}' > hgext/__index__.py $ make test-help.t With this a "make clean" or "python setup.py build_hgextindex" helps.

factotum: initialize global variables to suppress pyflakes warning

color: don't fail on error messages when no curses (issue4237) The error only occured when Python didn't have curses - such as on Windows and when Python was built without curses support. No curses can also be emulated by (re)moving .../lib/python2.7/curses/ from the Python installation. It is left as an exercise to figure out exactly what changed in Mercurial that triggered this error.

win32: backout 1a9ebc83a74c This change conflicted with TortoiseHg's use of QFileSystemWatcher. Files which were being monitored (for file-system events) were unable to be reliably updated using util.atomictempfile. Often the update would error out in the middle of the process leaving neither the old or the new file in place. My guess is that _kernel32.CreateFileA() is triggering an exception that is not handled correctly within unlink()

test-check-code-hg: use locate instead of manifest

test-check-code-hg: drop manual check of non-.py scripts

test-check-code-hg: use test-repo check

check-code: look at shebang to identify Python scripts

tests: use locate to find files for pyflakes check Based on a suggestion by Yuya Nishihara

merge with stable

Added signature for changeset 2195ac506c6a

Added tag 3.0 for changeset 2195ac506c6a

revset: directly use __contains__ instead of a lambda We get rid of lambda in a bunch of other place. This is equivalent and much faster. (no new timing as this is the same change as three other changesets)

tests: suppress spurious lchmod error from unzip (issue4088) Because lchmod doesn't exist on Linux, unzip should be built without lchmod support. A few distros get this wrong.

orderedlazyset: directly use __contains__ instead of a lambda We apply the same speedup as in spanset, getting rid of the useless lambda. (No new timing, as this is the very same change)

lazyset: directly use __contains__ instead of a lambda We apply the same speedup as in spanset, getting rid of the useless lambda. (No new timing, as this is the very same change)

merge with i18n

i18n-ja: synchronized with e9c2f76be74b

i18n-pt_BR: synchronized with e9c2f76be74b

rebase: empty revset should be a gentle no-op with exit code 1, not an error

largefiles: better handling of log from other working directory (issue4236) When invoked from another directory, the matchers m._cwd will be the absolute path. The code for calculating relative path to .hglf did not consider that and log would fail with weird errors and paths. For now, just don't do any largefile magic when invoked from other directories.

tests: add repository check for pyflakes test If this test was run from a tarball with no Mercurial repository, it would fail because 'hg manifest' didn't work.

spanset: directly use __contains__ instead of a lambda Spanset are massively used in revset. First because the initial subset itself is a repo wide spanset. We speed up the __and__ operation by getting rid of a gratuitous lambda call. A more long terms solution would be to: 1. speed up operation between spansets, 2. have a special smartset for `all` revisions. In the mean time, this is a very simple fix that buyback some of the performance regression. Below is performance benchmark for trival `and` operation between two spansets. (Run on an unspecified fairly large repository.) revset tip:0 2.9.2) wall 0.282543 comb 0.280000 user 0.260000 sys 0.020000 (best of 35) before) wall 0.819181 comb 0.820000 user 0.820000 sys 0.000000 (best of 12) after) wall 0.645358 comb 0.650000 user 0.650000 sys 0.000000 (best of 16) Proof of concept implementation of an `all` smartset brings this to 0.10 but it's too invasive for stable.

transaction: fix file descriptor leak for journal.backupfiles The journal.backupfiles descriptor wasn't being closed. This resulted in hgsubversion test runs having a bagillion descriptors open, which crashed on platforms with low open file limits (like OSX).

revset: also inline spanset._contained in __len__ For consistency with what happen in `__contains__`, we inline the range test into `__len__` too.

revset: inline spanset containment check (fix perf regression) Calling a function is super expensive in python. We inline the trivial range comparison to get back to more sensible performance on common revset operation. Benchmark result below: Revision mapping: 0) 3f83fc5cfe71 2.9.2 release 1) bcfd44abad93 current @ 2) This revision revset #0: public() 0) wall 0.010890 comb 0.010000 user 0.010000 sys 0.000000 (best of 201) 1) wall 0.012109 comb 0.010000 user 0.010000 sys 0.000000 (best of 199) 2) wall 0.012211 comb 0.020000 user 0.020000 sys 0.000000 (best of 197) revset #1: :10000 and public() 0) wall 0.007141 comb 0.010000 user 0.010000 sys 0.000000 (best of 361) 1) wall 0.014139 comb 0.010000 user 0.010000 sys 0.000000 (best of 186) 2) wall 0.008334 comb 0.010000 user 0.010000 sys 0.000000 (best of 308) revset #2: draft() 0) wall 0.009610 comb 0.010000 user 0.010000 sys 0.000000 (best of 279) 1) wall 0.010942 comb 0.010000 user 0.010000 sys 0.000000 (best of 243) 2) wall 0.011036 comb 0.010000 user 0.010000 sys 0.000000 (best of 239) revset #3: :10000 and draft() 0) wall 0.006852 comb 0.010000 user 0.010000 sys 0.000000 (best of 383) 1) wall 0.014641 comb 0.010000 user 0.010000 sys 0.000000 (best of 183) 2) wall 0.008314 comb 0.010000 user 0.010000 sys 0.000000 (best of 299) We can see this changeset gains back the regression for `and` operation on spanset. We are still a bit slowerfor the `public()` and `draft()`. Predicates not touched by this changeset.

ancestor: silence multiple ancestor warning outside of merge (issue4234) The current situation is a bit of a layering violation as merge-specific knowledge is pushed down to lower layers and leaks merge assumptions into other code paths. Here, we simply silence the warning with a hack. Both the warning and the hack will probably go away in the near future when bid merge is made the default.

revsetbenchmark: fix error raising We want to display the commands, not all arguments of the function. (The old code actually crash, failing to joining a list of lists.)

revset: fix revision filtering in spanset.contains (regression) The argument is `x` but the variable tested for filtering is `rev`. `rev` happens to be a revset methods, ... never part of the filtered revs. This method is now using `rev` for everything.

graft: do not use `.remove` on a smart set (regression) Revset calls use to return a list. Graft use to mutate that list. We cannot do this anymore leading to a crash when grafting multiple changeset with a revset. File ".../mercurial/commands.py", line 3117, in graft revs.remove(rev) AttributeError: '_addset' object has no attribute 'remove' We are late in code-freeze so we make the shortest possible fix by turning it back to a list.

help: clarify distinction among `contains`/`file`/`filelog` For a Mercurial new-comer, the distinction between `contains(x)`, `file(x)`, and `filelog(x)` in the "revsets" help page may not be obvious. This commit tries to make things more obvious (text based on an explanation from Matt in an FB group thread).

discovery: don't report all "unsynced" remote heads (issue4230) 8a9e0b523d2d made discovery more helpful - too helpful for some extreme use cases. Instead, we arbitrarily limit the list it at 4 and add 'or more'.

rebase: don't abort if we're asked to rebase an empty revset The documentation says we exit 1 if we have nothing to do, so avoid breaking that contract when we're passed an empty revset. This was changed in http://www.selenic.com/hg/rev/a259f7b488ab to improve the error message; keep the improved message, just not the abort.

largefiles: remove directories emptied after their files are moved (issue3515)

cmdserver: forcibly use L channel to read password input (issue3161) Command server is designed to use the channel protocol even if the server process is accessible to tty, whereas vanilla hg should be able to read password from tty in that case. So it isn't enough to swap sys.stdin: # works only if the server process is detached from the console sys.stdin = self.fin getpass.getpass('') sys.stdin = oldin or test isatty: # vanilla hg can't talk to tty if stdin is redirected if self._isatty(self.fin): return getpass.getpass('') else: ... Since ui.nontty flag is undocumented and command-server channels don't provide isatty(), this change won't affect the other uses of ui._isatty(). issue3161 also suggests to provide some context of messages. I think it can be implemented by using the generic templating function.

killdaemons: correct typo of _check() function caught by pyflakes

win32: add missing definition of _ERROR_NO_MORE_FILES caught by pyflakes

exchange: fix invalid reference to bundle2.UnknownPartError caught by pyflakes

match: fix NameError 'pat' on overflow of regex pattern length 'pat' was renamed to 'regex' in 9d28fd795215.

color: add missing handling of stderr capture introduced by 350dc24a553d It wouldn't raise exception without this change, but _bufferstates was wrong because of missing _bufferstates.pop() in colorui.popbuffer().

hgweb: replace excanvas.js with a newer version The current version of excanvas is unknown. Substitute it with the latest version from the excanvas website: http://code.google.com/p/explorercanvas/ Instead of using the "compiled" version, just use the readable one.

httppeer: reintroduce _abort that accidentally was removed in 167047ba3cfa Including the missing test coverage that would have caught it.

bundle2: gracefully handle hook abort We make sure any exceptions raised during the whole span of handling bundle2 processing are decorated. This let us catch exceptions raised by hooks prior to transaction commit.

bundle2: gracefully handle PushRaced error during unbundle Same drill again. We catch the PushRaced error, check if it cames from a bundle2 processing, if so we turn it into a bundle2 with a part transporting error information to be reraised client side.

bundle2: add an error message to push race error Errors with no explanations makes my uncle Bob sad.

bundle2: fix raising errors during heads checking If the heads on the server differ from the ones reported seen by the client at bundle time, we raise a PushRaced exception. However, the part raising the exception was broken. To fix it, we move the PushRaced class in the error module so it can be accessible everywhere without an import cycle. A test is also added to prevent regression.

bundle2: gracefully handle UnknownPartError during unbundle Same as for Abort error, we catch the error, encode it into a bundle2 reply (expected by the client) and stream this reply. The client processing of the error will raise the exception again.

bundle2: catch UnknownPartError during local push When doing local push, UnknownPartError from the server will be raised directly to the client. We need to catch them too.

bundle2: catch UnknownPartError during pull We narrow the exception catching while pulling.

bundle2: catch UnknownPartError during push We narrow the exception catching while unbundling the push reply.

bundle2: use a more specific UnknownPartError when no handler is found KeyError is very generic, we need something more specific for proper error handling.

bundle2: make error testing more modular We have more than Abort to test.

bundle2: gracefully handle abort during unbundle Clients expect a bundle2 reply to their bundle2 submission. So we catch the Abort error and turn it into a bundle2 containing a part transporting the exception data. The unbundling of this reply will raise the error again.

bundle2: decorate exception raised during bundle processing This is a small hack to help us do some graceful error handling in bundle2 without major refactoring. See embedded comment for details.

histedit, i18n: replace '+' with concatenation to make hggettext happy

commands: fix typo in --graph description

revset, i18n: add translator comment to "only"

merge: improve notes for listing the bids for ambiguous merges

merge: tell the user when we are using bid merge Bid merge is a new rarely used feature that the user explicitly enabled - we should tell/warn when the user actually is using it, just like we tell when we not are using it. Give a message like note: merging 3b08d01b0ab5+ and adfe50279922 using bids from ancestors 0f6b37dbe527 and 40663881a6dd

merge: fix stray character in bid merge message

tests: better test coverage for bid merge Martin Geisler's test case revealed the previous message argument error.

merge: fix wrong number of arguments for bid merge message

merge: fix test failures with new merge code on OS X The case collision checker was missing a op entry for 'k'eep.

obsolete: fix one-element tuple in module docstring

obsolete: let N denote number of obsoleted changestes in a marker The number of obsoleted changesets is referred to as N later in the docstring.

obsolete: fix language and grammar in module docstring

churn: compute padding with unicode strings Most UTF-8 aware terminals convert multibyte sequences into a single displayed characters. Because the first column is padded by counting bytes, the second column is not perfectly aligned in the presence of non ASCII characters.

Added signature for changeset 564f55b25122

Added tag 3.0-rc for changeset 564f55b25122

merge default into stable for 3.0 code freeze

bundle2: allow extensions to extend the getbundle request We want extensions to be able to request extra parts.

bundle2: add a way to add parts during a `getbundle` request We add a hook function to let extensions add parts to the bundle.

getbundle: pass arbitrary arguments all along the call chain The wireprotocol command accepts arbitrary arguments, we are now passing such arguments down the call chain.

bundle2: call a hook after the transaction is closed We call a dedicated hook right after closing the transaction. This will let people react to the transaction with all the information in hand. This hook is experimental and will not survive in future versions.

bundle2: call a hook prior to closing the transaction We call a dedicated hook right before closing the transaction. This will let people abort unbundling with all the information in hand. This hook is experimental and will not survive in future versions.

bundle2: inform transaction that we are in a bundle2 unbundle That way, hooks called during the unbundle process are aware that a bigger picture is going on.

changegroup: use tr.hookargs when calling changegroup hooks So that other parties using the transaction can put information in our hook calls.

changegroup: use tr.hookargs when calling pretxnchangegroup hooks So that other parties using the transaction can put information in our hook calls.

addchangegroup: register data in tr.hookargs We are registering data related to the process into the transaction hook data. This lets other parties using the same transaction get informed of the addchangegroup result.

transaction: add a notion of hook arguments It is now possible to register parameters to be used when invoking hooks in this transaction. This will cope with the fact that bundle2 adds multiple data types in a single transaction. Do not expect any wide and consistent usages of this in the next release. This will be used by bundle2 experiments first. It will be made better for the release after.

bundle2: allow extensions to plug into the push process Extensions are offered functions to add parts and process their results.

bundle2: require both client and server to opt in Even if the server is bundle2-enabled, the client now has to opt-in in the config too.

bundle2: move bundle2 config option to section "experimental" We highlight the fact that this is experimental by moving it to an "experimental" section, and we match the config name with the server capability name `bundle2-exp`.

bundle2: move all parts into a `bx2` namespace All currently core parts are moved to a `bx2` namespace (for "bundle 2 experimental"). This should avoid conflicts between the final stable format and the one about to be released.

bundle2: rename server capability to bundle2-exp For the same reason, we advertise this bundle2 implementation and format as experimental. This will leave room for field testing in 3.0 but won't conflict with a stable implementation in 3.1.

bundle2: use HG2X in the header The current implementation of bundle2 is still very experimental and the 3.0 freeze is yesterday. The current bundle2 format has never been field-tested, so we rename the header to HG2X. This leaves the HG20 header available for real usage as a stable format in Mercurial 3.1. We won't guarantee that future mercurial versions will keep supporting this `HG2X` format.

bundle2: transmit capabilities to getbundle during pull Bundle2 capabilities of the client are sent to the server in the bundlecaps argument of `getbundle`.

bundle2: include client capabilities in the pushed bundle The necessary data is now included in the `replycaps` part.

bundle2: advertise bundle2 caps in server capabilities We can now retrieve them from the server during push. The capabilities are encoded the same way as in `replycaps` part (with an extra layer of urlquoting to escape separators).

bundle2: add bundle2caps dict on localrepo object This dictionary will hold bundle2-related capabilities.

bundle2: capabilities encoding

bundle2: extract capabilities decoding We'll need to reuse this in more places (at least pull and push).

bundle2: protect capabilities name and values with url quoting This lift limitations of the text based encoding.

bundle2: support for capabilities with values The capabilities attributes of `bundle20` is now a dictionary and the reply caps can encode capabilities with values.

bundle2: add capabilities support in `replycaps` part This part now contains a list of supported capabilities.

bundle2: adds a capabilities attribute on bundler20 This attribute conveys the capabilities supported by the destination of the bundle. It is used to decide which parts to include in the bundle. This is currently a set but will probably be turned into a dictionary to allow capabilities with values.

bundle2: include stderr when capturing handlers output We do not discriminate between stdout and stderr yet. But this will do for now.

ui: pushbuffer can now also capture stderr We need an easy way to capture both stderr and stdout during bundle2 processing of a remote bundle. This changeset adds simple changes to the `ui` class to make this possible. I expect the interface to change in future releases as bundle2 will probably want to distinguish stdout and stderr. The current change will, however, do for now.

bundle2: capture remote stdout while unbundling When a reply is built, the bundle processing will capture the output of each handler and sends it to the client in a dedicated part. As a side effect, this add a "remote: " prefix to destination output on local push. This is considered okay for now as: 1. bundle2 is still experimental, 2. Matt said he could be okay to change output for bundle2, 3. This keeps the implementation simple. This changeset does it for stdout only. stderr will be done in a future changeset.

bundle2: introduce `replycaps` part for on-demand reply The bundle2 processing does not create a bundle2 reply by default anymore. It is only done if the client requests it with a `replycaps` part. This part is called `replycaps` as it will eventually contain data about which bundle2 capabilities are supported by the client. We have to add a flag to the test command to control whether a reply is generated or not.

bundle2: use an official iterparts method to unbundle parts Explicit is better than implicit.

merge: with merge.preferancestor=*, run an auction with bids from ancestors The basic idea is to do the merge planning with all the available ancestors, consider the resulting actions as "bids", make an "auction" and automatically pick the most favourable action for each file. This implements the basic functionality and will only consider "keep" and "get" actions. The heuristics for picking the best action can be tweaked later on. By default it will only pass ctx.ancestor as the single ancestor to calculateupdates. The code path for merging with a single ancestor is not changed.

log: changed implementation to use graphlog code Now that revsets work in a lazy way, log code can be changed to parse every option into a revset and then evaluate it lazily. Now expressions like "hg log -b default -b ." are converted into a revset using the same code as graphlog.

context: introduce merge.preferancestor for controlling which ancestor to pick Multiple revisions can be specified in merge.preferancestor, separated by whitespace. First match wins. This makes it possible to overrule the default of picking the common ancestor with the lowest hash value among the "best" (introduced in 3605d4e7e618). This can for instance help with some merges where the 'wrong' ancestor is used. There will thus be some overlap between this and the problems that can be solved with a future 'consensus merge'. Mercurial will show a note like note: using 40663881a6dd as ancestor of 3b08d01b0ab5 and adfe50279922 alternatively, use --config merge.preferancestor=0f6b37dbe527 when the option is available, listing all the alternative ancestors.

context: tell when .ancestor picks one of multiple common ancestors heads Show a message like note: using 0f6b37dbe527 as ancestor of adfe50279922 and cf89f02107e5 So far this is just a warning - there is nothing the user can do to select another ancestor.

hgweb: align entries in "changelog" and "revisions" pages of "spartan" style Before this patch, each log entries in "changelog" and "revisions" pages of "spartan" style are not aligned by column, because: - each log entries are separated "<table>" entries, and - there are no fixed "width" information for each "<th>"/"<td>" entries This patch aligns entries in "changelog" and "revisions" pages of "spartan" style by: - adding 'label' class to '<th>' for 'age' information, and - setting 'width' of '<th class="label">' with fixed size 'class="age"' is not used for this purpose, because it is also used to set "bold" font-weight "16em" seems to be wide enough to show date information fully, when web browser disables (or doesn't support) javascript.

hgweb: show revisions and hashes gotten from changelog in "comparison" page Before this patch, revision numbers and hash values in "comparison" page are gotten from not changelog but filelog. Such filelog information is useful only for hgweb debugging, and may confuse users. This patch shows revision numbers and hash values gotten from changelog in "comparison" page.

hgweb: show as same parents as "hg parents -r REV FILE" in pages for file Before this patch, "parents" in pages for file doesn't show as same parents as "hg parents -r REV FILE", when the specified file is not modified in the specified revision. For example, it is assumed that revision A, B and D change file "f". changelog (A) ---> (B) ---> (C) ---> (D) filelog "f" (x) ---> (y) ------------> (z) "/file/D/f" invokes "webutil.parents()" with filectx(z) gotten from changectx(D), and it returns changectx(B). This is as same result as "hg parents -r D f". In the other hand, "/file/C/f" invokes "webutil.parents()" with filectx(y') gotten from changectx(C), and it returns changectx(A), because filectx(y') is linked to changectx(B), and works like filectx(y) in some cases. In this case, revision B is hidden from users browsing file "f" in revision C. This patch shows as same parents as "hg parents -r REV FILE" in pages for file, by making "webutil.parents()" return: - "linkrev()"-ed revision only, if: - specified context instance is "filectx" (because "webutil.parents()" is invoked with changectx, too), and - (1) the revision from which filectx is gotten and (2) the one to which filectx is linked are different from each other - revision gotten from "ctx.parents()", otherwise

hgweb: make "comparison" get parent from not filelog but changelog Before this patch, "comparison" shows unexpected result, when the specified file is not modified in the specified revision, even though "diff" shows empty result. When REV doesn't change specified FILE, "diff" shows: "hg diff -c REV FILE" but "comparison" shows: "hg diff -c `hg parents -r REV FILE` FILE" In other words, the former gets parent from changelog, but the latter gets one from filelog. This may confuse users browsing (and switching "diff" and "comparison" of) files in the specified revision. This patch makes "comparison" get parent from not filelog but changelog, to show "hg diff -c REV FILE" in both "diff" and "comparison" pages.

hgweb: fix lack of "bookmarks" link in "/file" page of "paper" style This patch also fixes same problem of "coal" style, because it re-uses "filerevision.tmpl" of "paper" style. "gitweb" and "monoblue" styles don't have such problems. "spartan" style doesn't have "bookmarks" page definition itself.

hgweb: adding article link to rss feed

hgweb: adding branch names from inbranch template to rss feed

hgweb: adding branch names from inbranch template to atom feed

dirstate: report bad subdirectories as match.bad, not just a warning (BC) This seems simpler and more correct. The only test coverage for this is test-permissions.t when it says: dir: Permission denied

dirstate: improve documentation and readability of match and ignore in the walker

context: remove redundant handling of match.bad return value The 'bad' function is for reporting - it never returns anything.

match: remove last traces of unused .missing callback

match: _globre doctests

match: improve documentation - docstrings and more descriptive variable naming No real changes. pattern: 'kind:pat' as specified on the command line patterns, pats: list of patterns kind: 'path', 'glob' or 're' or ... pat: string in the corresponding 'kind' format kindpats: list of (kind, pat) tuples

largefiles: changed overridelog to work with graphlog Log for largefiles was failing for graph log since it was overriding match instead of matchandpats. [Mads Kiilerich modified this patch to address his review comments and ended up rewriting/removing most of it.]

largefiles: added test coverage for graph log [Mads Kiilerich placed this patch before the patch that makes graphlog actually work correctly for largefiles. As it is introduced here it just adds test coverage and the actual bugfix patch will show the actual change.]

cmdutil: changed _makegraphlogrevset to _makelogrevset This method will now be used to build both graphlog and log revset after this series of patches.

revlog: backout 514d32de6646 - commonancestors

localrepo: use commonancestorsheads for checking linear heritage in file commit If two revisions are linearly related, there will only be one ancestor, and commonancestors and commonancestorsheads would give the same result. commonancestorsheads is however slightly simpler, faster and more correct.

backout: use commonancestorsheads for checking linear heritage If two revisions are linearly related, there will only be one ancestor, and commonancestors and commonancestorsheads would give the same result. commonancestorsheads is however slightly simpler, faster and more correct.

revlog: introduce commonancestorsheads method Very similar to commonancestors but giving all the common ancestors heads.

parsers: remove unnecessary gca variable in index_commonancestorsheads

parsers: introduce index_commonancestorsheads This is an exact copy of index_ancestors but without the final "deepest" pruning.

ancestors: extract candidates function as commonancestorsheads

filemerge: better handling of failing remove of temporary files We have seen some failures on Windows that could seem like the unlinks of temporary files were failing. That could perhaps be because the merge tool somehow still held the files open. Instead of the bare bone os.unlink, use our util.unlink with special rename/retry handling on Windows.

contrib: remove mergetools.hgrc premerge=False for Beyond Compare and Araxis There can be good reasons to disable premerge no matter which merge tool is used. Most tools will do just fine without premerge and handle the simple merges more or less automatic and silent. We _could_ thus disable premerge for most tools. But without premerge, the merge tool will be launched for each file - that makes it a slow and expensive process to perform big simple merges. It is thus better to consistently stick to the default premerge=True. The mergetools.hgrc configuration for most tools implicitly use the default premerge=True but Araxis and the Linux entry for Beyond Compare had premerge=False. These lines has been removed. These settings were introduced by 6b354a763617 without further explanation of why they should be good. (We have seen some crashes on Windows with Araxis where a merge failed after a lot of Araxis flashing. I haven't been able to reproduce it and do not know exactly what happened. Enabling premerge avoids the problems.)

obsolete: add '%' specifier to the format string to avoid TypeError at runtime Mapping operation on the format string not including any '%' specifiers causes TypeError at runtime.

check-code: detect "% inside _()" when there are leading whitespaces Before this patch, "contrib/check-code.py" can't detect "% inside _()" correctly, when there are leading whitespaces before the format string, like below: _( "format string %s" % v) This patch adds regexp pattern "[ \t\n]*" before the pattern matching against the format string. "[\s\n]" can't be used in this purpose, because "\s" is automatically replaced with "[ \t]" by "_preparepats()" and "\s" in "[]" causes nested "[]" unexpectedly.

i18n: fix "% inside _()" problem

largefiles: revert override, install matchfn outside the try/except restoring it

largefiles: simplify revert - use getstandinsstate like other commands do

largefiles: remove dummy assignments for creating an already existing closure

largefiles: remove silent handling of incorrect invocation of restorematchfn It is better to get a crash than to continue without noticing errors.

largefiles: copy override, install matchfn outside the try/except restoring it

largefiles: clarify installmatchfn documentation

largefiles: use more reasonable locking for update

largefiles: full debugdirstate functionality for largefiles - just reusing the original command with a mockup repo. This makes it possible to see dates in the lfdirstate and gives less code duplication.

largefiles: make cat on standins do something cat of a standin would silently fail. The use of standins is mostly an implementation detail, but it is already a bit leaking. Being able to see the content of standins might be convenient for debugging.

largefiles: remove confusing handling of .bad return value - it is void

largefiles: fix profile of unused largefilesdirstate._ignore

largefiles: import whole modules instead of importing parts of them Be more friendly to demandimport.

largefiles: update should only create a .orig backup of a largefile once A .orig of a standin after the update do that a .orig of the actual largefile is created. The .orig standin was however never removed again and the largefile .orig was thus overwritten again and again. The fix: remove the standin .orig when it is used.

merge: let manifestmerge emit 'keep' actions when keeping wd version Such a 'keep' action will later be the preferred (non)action when there is multiple ancestors. It is thus very convenient to have it explicitly. The extra actions will only be emitted in the case where the local file has changed since the ancestor but the other hasn't. That is the symmetrical operation to a 'get' action. This will create more action tuples that not really serve a purpose. The number of actions will however have the number of changed files as upper bound and it should thus not increase the memory/cpu use significantly.

merge: pass merge ancestor to calculateupdates as a list The list will so far always have one element.

merge: move ancestor selection tweaking from manifestmerge to update function - passing it through calculateupdates. This will make sure manifestmerge actually use the ancestor it is given.

match: make it more clear what _roots do and that it ends up in match()._files

cat: explicitly document the supported formatter rules The previous documentation pointed to the export command, but even if the user recognized that instead of only reading the cat specific list of rules, not all of the export rules applied anyway (specifically %N, %n and %m). The new items are a copy/paste from export's list. These rules have existed since at least version 0.5. Note that %m gets substituted with 'None' because the commit message isn't passed to cmdutil.makefilename(). %R and %r are currently effectively the same, since no revwidth is passed, however they both work. There aren't any existing tests for these rules, so they are added to prevent future regression.

convert: backout 81cf597dafa9 and a3545c3104aa -closemap Closemap solves a very specific use case. It would be better to have a more generic solution than to have to maintain this forever. Closemap has not been released yet and removing it now will not break any backward compatibility contract. There is no test coverage for closemap but it seems like the same can be achieved with a simple and much more powerful custom extension: import hgext.convert.hg class source(hgext.convert.hg.mercurial_source): def getcommit(self, rev): c = super(source, self).getcommit(rev) if rev in [''' d643f67092ff123f6a192d52f12e7d123dae229f 9117c6561b0bd7792fa13b50d28239d51b78e51f f368a1c302d5b87506f7edb13769e591e063d7ea ''']: c.extra = c.extra.copy() c.extra['close'] = '1' return c hgext.convert.hg.mercurial_source = source

convert: backout b75a04502ced and 9616b03113ce - tagmap Tagmap solves a very specific use case. It would be better to have a more generic solution than to have to maintain this forever. Tagmap has not been released yet and removing it now will not break any backward compatibility contract. There is no test coverage for tagmap but it seems like the same can be achieved with a (relatively) simple and much more powerful custom extension: import hgext.convert.hg def f(tag): return tag.replace('some', 'other') class source(hgext.convert.hg.mercurial_source): def gettags(self): return dict((f(tag), node) for tag, node in in super(source, self).gettags().items()) def getfile(self, name, rev): data, flags = super(source, self).getfile(name, rev) if name == '.hgtags': data = ''.join(l[:41] + f(l[41:]) + '\n' for l in data.splitlines()) return data, flags hgext.convert.hg.mercurial_source = source

bundle2: support for push over the wire We use the new method defined in the past changeset to send a bundle2 stream and receive one in reply. The http version is missing remote output support. This will be done later using a bundle part.

httppeer: support for _calltwowaystream This new method is now supported by http too.

sshpeer: add implementation of _calltwowaystream This implements the call needed by bundle2. The error handling is a bit flaky right now, but bundle2 error handling in general is still flaky anyway. Bundle2 is still disabled by default, I do not expect this to be a problem.

wireproto: add a _calltwowaystream method on wirepeer This method will be used by bundle2 pushes. It calls a command, feeds it with a stream and receives another stream in reply. Actual implementation for ssh and http will be done in later changesets.

bundle2: return a bundle20 object from exchanges.unbundle When a bundle2 is pushed we return a bundle instead of an integer. We use to return a binary stream. We now return a `bundle20` bundler to make the life of wireprotocol implementation simpler.

bundle2: feed a binary stream to `peer.unbundle` This input will have to travel over the wire anyway, so we feed the peer method with a simple binary stream and rely on the server side to use `readbundle` to create the python object. The test output changes because the bundle is created marginally sooner and the debug output interleaves in a different way.

bundle2: allow bundle2 for pulling over the wire This changeset makes `wireprotocol` peers advertise bundle2 capability and comply with bundle2 `getbundle` requests. Note that advertising bundle2 could make a client try to use it for push. Such pushes would fail. However, I do not expect any human being to have enabled bundle2 on their server yet.

bundle2: return a stream from exchange.getbundle For friendliness with the wire protocol implementation, the `exchange.getbundle` now returns a binary stream when asked for a bundle2. We detect a bundle2 request and upgrade the binary stream to an unbundler object. In the future the unbundler may gain feature to look like a binary stream, but we are not quite there yet.

bundle2: let readbundle return unbundle20 The `readbundle` function can now recognize a bundle2 stream and return the appropriate unbundler. This is required for proper bundle2 support over the wire.

bundle2: make header reading optional The `readbundle` function will consume the 4 first bytes to dispatch between various unbundler. We introduce a way to inform `unbundle20` that the header has been read and it can be trusted.

bundle2: prepare readbundle to return more that one type of bundle We first read 4 bytes to get the `HG10` bytes then we read the compression scheme if this is `HG10`. This prepares the code for the arrival of `HG20` handling.

bundle2: add a ui argument to readbundle The bundle2 unbundler needs a ui argument. We are now passing this information to `readbundle`.

bundle2: move `readbundle` into the `exchange` module The `readbundle` function is going to understand the bundle2 header. We move the function to a more suitable place before making any other changes.

bundle2: use headerless HG10UN stream in changegroup Using `readbundle` in the part handlers creates a circular import hell. We are now using a simple `HG10UN` stream with no header. Some parameters may later be introduced on the part to change parameter. Producers are updated as well.

bundle2: allow using bundle2 for push We now support bundle2 for local push. The unbundle function has to detect which version of the bundle to use since the return type is different. Note that push error handling is currently nonexistent. This is one of the reasons why bundle2 is still disabled by default.

bundle2: add a "check:heads" handler This part is intended to hold the same role as the `heads` argument of the unbundle function. The client fill it with the known heads at bundle time and the server will abort if its heads changed.

repoview: make the conversion from node to rev explicit while computing hidden You cannot use `repo[...]` lookup here. 1. It is slow 2. It is very likely to trigger a hidden computation itself, entering an infinite loop.

repoview: drop duplicated lookup We are already looking for local tags on the line above. We can safely drop this extra lookup.

hgweb: adding branch, tags, bookmarks, user, and file list to rss feed entries

hgweb: adding branch, tags, bookmarks, user, and file list to atom feed entries

patchbomb: warn when emailing a dirty working directory parent

tests: coverage of convert and filemap include and the default of include all

largefiles: remove no more referred "getoutgoinglfiles()"

largefiles: use "outgoinghooks" to avoid redundant outgoing check Before this patch, "hg outgoing" invokes "findcommonoutgoing()" not only in "commands.outgoing()" but also in "overrides.overrideoutgoing()" (via "getoutgoinglfiles()"), when largefiles is enabled. The latter is redundant. This patch uses "outgoinghooks" to avoid redundant outgoing check. Newly introduced function "overrides.outgoinghook()" is registered into "outgoinghooks" to get the result of outgoing check in "commands.outgoing()". It invokes "lfutil.getlfilestoupload()" directly with the result of outgoing check to avoid redundant outgoing check in "getoutgoinglfiles()": "sort()" is needed, because "lfutil.getlfilestoupload()" doesn't sort the result of it. This patch also omits "if toupload is None" ("No remote repo") case, because failure of looking remote repository up should raise exception in "commands.outgoing()" before invocation of "outgoinghooks". Newly added "hg outgoing --large --graph" tests examine "outgoinghooks" invocations in "hg outgoing --graph" code path.

outgoing: introduce "outgoinghooks" to avoid redundant outgoing check This patch introduces "outgoinghooks" to avoid redundant outgoing check for "hg outgoing" in other than "commands.outgoing" (or utility functions used by it).

hg: make "_outgoing()" return peer object for remote repository This patch makes "_outgoing()" return peer object for remote repository, to avoid re-execution "expandpath()", "parseurl()", and "peer()" on caller side for specified URL.

hg: make "_outgoing()" return empty list instead of "None" This patch makes "_outgoing()" return empty list instead of "None", if there are no outgoing changesets, because: - returning "None" requires callers to examine whether returned value is "None" or not explicitly, if callers want to execute loop on returned value, but - there are no explicit needs to return "None"

largefiles: use "summaryremotehooks" to avoid redundant outgoing check Before this patch, "hg summary --remote --large" invokes "findcommonoutgoing()" not only in "commands.summary()" but also in "overrides.overridesummary()" (via "getoutgoinglfiles()"). The latter is redundant. This patch uses "summaryremotehooks" to avoid redundant outgoing check. Newly introduced function "overrides.summaryremotehook()" is registered into "summaryremotehooks" to get the result of outgoing check in "commands.summary()". It invokes "lfutil.getlfilestoupload()" directly with the result of outgoing check to avoid redundant outgoing check in "getoutgoinglfiles()".

summary: introduce "summaryremotehooks" to avoid redundant incoming/outgoing check This patch introduces "summaryremotehooks" to avoid redundant incoming/outgoing check for "hg summary" in other than "commands.summary". Only if "--remote" is not specified for "hg summary", hooks registered in "summaryremotehooks" are invoked with "None" as "changes" argument at first, and they should return tuple of two booleans meaning "whether incomings are needed" and "whether outgoings are needed". If no hooks return tuple containing "True", "hg summary" does nothing any more, because incoming/outgoing check is not needed. Otherwise, hooks are invoked again: at this time, "changes" argument refers the result of incoming/outgoing check. This patch also prevents RepoError from being raised if "--remote" is not specified for "hg summary", because of backward compatibility for "hg summary --large" without "--remote".

util: enable "hooks" to return list of the values returned from each hooks

summary: separate checking incoming/outgoing and showing remote summary This patch separates checking incoming/outgoing and showing remote summary, as a preparation for refactoring in succeeding patches, because: - checking incoming/outgoing may be needed, even if "--remote" is not specified for "hg summary" - checking incoming/outgoing may not be needed simultaneously "hg summary --large" without "--remote" is typical case for these.

largefiles: reuse "findcommonoutgoing()" result at "hg push" Before this patch, "hg push" invokes "findcommonoutgoing()" not only in "exchange.push()" but also in "lfilesrepo.push()", when largefiles is enabled. The latter is redundant. This patch registers own "prepushoutgoinghook" function into "prepushoutgoinghooks" of "localrepository" to reuse "findcommonoutgoing()" result. "prepushoutgoinghook" omits "changelog.nodesbetween()" invocation, because "findcommonoutgoing()" invocation in "exchange.push()" takes "onlyheads" argument and it considers "nodesbetween()".

localrepo: introduce "prepushoutgoinghooks" to extend outgoing check easily This patch introduces "prepushoutgoinghooks" to extend outgoing check before pushing changesets to remote easily. This chooses the function returning "util.hooks" instead of the one to be overridden. The latter may cause problems silently, if one of overriders forgets (or fails) to execute a kind of "super(xxx, self).overridden(...)". In the other hand, the former can ensure that all registered functions are invoked, unless one of them raises an exception.

largefiles: centralize the logic to get outgoing largefiles Before this patch, "overrides.getoutgoinglfiles()" (called by "overrideoutgoing()" and "overridesummary()") and "lfilesrepo.push()" implement similar logic to get outgoing largefiles separately. This patch centralizes the logic to get outgoing largefiles in "lfutil.getlfilestoupload()". "lfutil.getlfilestoupload()" takes "addfunc" argument, because each callers need different information (and it is useful for enhancement in the future). - "overrides.getoutgoinglfiles()" needs only filenames - "lfilesrepo.push()" needs only hashes of largefiles

cat: support cat with explicit paths in subrepos The cat command with an explicit path into a subrepo is now handled by invoking cat on the file, from that subrepo. The previous behavior was to complain that the file didn't exist in the revision (of the top most repo). Now when the file is actually missing, the revision of the subrepo is named instead (though it is probably desirable to continue naming the top level repo). The documented output formatters %d and %p reflect the path from the top level repo, since the purpose of this is to give the illusion of a unified repository. Support for the undocumented (for cat) formatters %H, %R, %h, %m and %r was added long ago (I tested back as far as 0.5), but unfortunately these will reflect the subrepo node instead of the parent context. The previous implementation was a bit loose with the return value, i.e. it would return 0 if _any_ file requested was cat'd successfully. This maintains that behavior.

cat: move most of the implementation into cmdutils.cat() This will allow access to the reusable parts from subrepos, similar to add(), forget(), etc.

tests: mark test in tests/test-help.t as contingent on gettext being available

setup.py: fix C extension compilation issue with OS X 10.9 and Xcode 5.1