localrepo: always set the variable r in status method This is a small patch to help streamline keeping tracking of the list of files for status in a variable already called 'r' ('s' is for subrepos in this method). We now move the setting of it out of an 'if' block so that we can later refactor more code into the context objects.

run-tests: execute tests via unittest Now that unittest mode is functionally equivalent to the default mode, we switch the default execution mode to unittest and remove the choice of different execution modes.

run-tests: implement Test.__str__ unittest sometimes does a str(test) and the default implementation doesn't do the right thing. So we override it.

run-tests: make failure reporting in unittest mode equivalent to default Unlike unittest's defaults, our result formatter does not print stack traces. Here, we change TestResult.addFailure() to be compatible with the existing/default execution mode.

run-tests: ignore failures from rmtree rmtree() may fail under certain conditions. We ignore failures at the individual test level because they can interfere with test execution. Furthermore, we'll reattempt deletion in the high-level test runner after all tests have finished. Note that this patch is not a code refactor like most of the patches before it. This change logically makes sense given the execution behavior of the tests.

run-tests: abort tests after first failure in unittest mode There is an execution mode on run-tests.py that stops after the first failure. unittest mode was previously not obeying this option. This patch fixes that.

run-tests: print compatible output from TextTestRunner Our unittest TextTestRunner now prints output similar to the output from the default execution mode - the output people expect from run-tests.py.

run-tests: don't print results in unittest mode A subsequent patch will have unittest print tests for us. Don't perform old-style printing when in unittest mode.

run-tests: move errpath deletion to setUp()

run-tests: kill daemons during tearDown()

run-tests: move err file writing to tearDown()

run-tests: refactor testtmp testtmp is now a member variable of our test class. It's value is computed during instance creation and the directory is managed via the lifetime of the test object.

run-tests: store skipped state on Test As code is being moved between functions, we need a member variable to hold skipped state.

run-tests: move some functionality to Test.tearDown()

run-tests: store last result in Test._result Subsequent patches move post-test actions into tearDown(). This requires tearDown() to have access to the last result.

run-tests: report test duration in Test.tearDown()

run-tests: store test return code and output in Test instance A subsequent patch that will introduce tearDown() requires test execution state be stored in the instance.

run-tests: keep track of test start and stop in MercurialTest.run() This brings run() more compatible with unittest.TestCase.run()

run-tests: keep track of test execution state in Test This patch starts a mini series of moving functionality into the newly-established setUp() and tearDown() methods.

run-tests: support setUp() and tearDown() in TestCase wrapper unittest.TestCase.run() calls setUp() and tearDown() during run(). We emulate that implementation.

run-tests: fail tests by raising an exception When in unittest mode, Test.run() will now raise for all non-success cases. This makes it behave like TestCase.run().

run-tests: record warnings by raising WarnTest We continue the conversion of recording test results by raising exceptions.

run-tests: record ignored tests by raising IgnoreTest

run-tests: record skips by raising SkipTest The unittest way of recording a skipped test is to raise an exception (at least with modern unittest implementation). We change Test to raise a SkipTest when operating in unittest mode. This does prevent some "tear down" activities from running in unittest mode. This will be fixed in subsequent patches. Since unittest mode is experimental, this should be OK.

run-tests: implement TestCase.run() Simply wrapping TestCase.run() is not sufficient for robust results reporting because unittest in Python 2.4 does not know about things like skipped tests and reports them as success or failures instead of skips. We will reimplement TestCase.run() with knowledge and semantics present in modern Python releases.

run-tests: don't print progress from Test when in unittest mode unittest does its own printing of progress indicators as part of TestResult. So, there is no need to print them when running in unittest mode. This will fix the double output of progress indicators that had been occurring in unittest mode.

run-tests: define a custom TestSuite that uses _executetests() We now have a custom unittest.TestSuite implementation that uses _executetests() and thus knows how to execute tests concurrently. Running tests in --unittest mode will use this TestSuite. Since the TestSuite handles concurrency, the warnings around --jobs and --loop have been removed.

run-tests: pass an optional TestResult into _executetests() If the result is passed, we execute tests in the unittest way. A subsequent patch will actually do this.

run-tests: pass Test instances into TestRunner._executetests() Test instances (not paths) are passed into _executetests(). This means the logic for instantiating Test instances has been moved outside of _executetests(). This was done because an upcoming patch will reuse the logic in _executetests(). As part of this change, test counts are no longer managed by _executetests().

run-tests: define cleanup() on unittest class We need a cleanup() on our unittest TestCase class to conform with the execution API. This will eventually be replaced by tearDown().

run-tests: rename Test._test to Test.name A lot of the attributes in Test could probably be renamed. This one is needed for an upcoming patch.

run-tests: teach Test instances whether they are in unittest mode Tests executing in unittest mode behave a little differently. For example, they report their results to a TestResult rather than just printing. This patch paves the way for better integration of Test into the unittest framework.

run-tests: teach unittest about warned results

run-tests: document how success code is handled

run-tests: teach unittest about ignored tests

run-tests: teach unittest about skipped tests

run-tests: define custom result and runner classes for unittest We need to teach unittest about some custom result types. This will require some custom classes. This patch creates a skeleton for them.

run-tests: start to report test results against TestResult Previously, our unittest wrapper didn't report results properly. We now properly report failures. We had to rename the local variable to prevent "t" from being overwritten in the local scope.

run-tests: give unittest wrapper a short description This will make the output contain something useful rather than the default repr() for the class.

run-tests: initial support for running tests with unittest The unittest package in Python's standard library provides an almost universal mechanism for defining and running tests. This patch starts the process of making run-tests.py talk to it. The main benefit of speaking unittest is that this will enable Mercurial's tests to be more easily consumed by other testing tools, like nose. This is useful for 3rd party extensions having their own test infrastructure, for example. Running tests in unittest mode will not result in completely sane behavior until the unittest mode is made the default execution mode. Expect things like double printing of output until support stabilizes.

localrepo: reverse contexts in status This is a slight tweak to how localrepo.status calculates what files have changed. By forcing a changectx to be first operator and anything not a changectx to be the second operator, we can later exploit this to allow refactoring the status operation as a method of a context object. Furthermore, this change will speed up 'hg diff --reverse' when used with the working directory because the code will now hit a fast path without needing to calculate an unneeded second manifest.

test: split test-largefile.t in multiple file The `test-largefiles.t` unified test is significantly longer (about 30%) than any other tests in the mercurial test suite. As a result, its is alway the last test my test runner is waiting for at the end of a run. In practice, this means that `test-largefile.t` is wasting half a minute of my life every times I'm running the mercurial test suites. This probably mean more a few cumulated day by now. I've finally decided to split it up in multiple smaller tests to bring it back in reasonable length. This changeset extracts independent test cases in two files. One dedicated to wire protocole testing, and another one dedicated to all other tests that could be independently extracted. No test case were haltered in the making of this changeset. Various timing available below. All timing have been done on a with 90 jobs on a 64 cores machine. Similar result are shown on firefly (20 jobs on 12 core). General timing of the whole run -------------------------------- We see a 25% real time improvement for no significant cpu time impact. Before split: real 2m1.149s user 58m4.662s sys 11m28.563s After split: real 1m31.977s user 57m45.993s sys 11m33.634s Last test to finish (using run-test.py --time) ---------------------------------------------- test-largefile.t is now finishing at the same time than other slow tests. Before split: Time Test 119.280 test-largefiles.t 93.995 test-mq.t 89.897 test-subrepo.t 86.920 test-glog.t 85.508 test-rename-merge2.t 83.594 test-revset.t 79.824 test-keyword.t 78.077 test-mq-header-date.t After split: Time Test 90.414 test-mq.t 88.594 test-largefiles.t 85.363 test-subrepo.t 81.059 test-glog.t 78.927 test-rename-merge2.t 78.021 test-revset.t 77.777 test-command-template.t Timing of largefile test themself ----------------------------------- Running only tests prefixed with "test-largefiles". No significant change in cumulated time. Before: Time Test 58.673 test-largefiles.t 2.931 test-largefiles-cache.t 0.583 test-largefiles-small-disk.t After: Time Test 31.754 test-largefiles.t 17.460 test-largefiles-misc.t 8.888 test-largefiles-wireproto.t 2.864 test-largefiles-cache.t 0.580 test-largefiles-small-disk.t

mq: use the editor gotten by "getcommiteditor()" instead of "ui.edit()" (qrefresh/qfold) This patch also replaces "editor = False" by "editor = cmdutil.getcommiteditor()", because: - it allows to hook commit message determination easily, even in the case without "--edit" - it avoids regression (or additional care) around saving "last-message.txt", even if MQ's "newcommit()" changes its implementation logic from "localrepository.commit" to "localrepository.commitctx" with "memctx" in the future to save commit message into "last-messge.txt" with "memctx", "editor" should be valid function.

mq: fold the code paths to invoke editor into specific logic (qrefresh/qfold) This factoring simplifies the succeeding patch to switch from "ui.edit()" to "getcommiteditor()" for qrefresh/qfold.

mq: use the editor gotten by "getcommiteditor()" instead of "ui.edit()" (qnew) This patch also replaces "editor = False" by "editor = cmdutil.getcommiteditor()", because: - the latter allows to hook commit message determination easily, even in the case without "--edit" - the latter can avoid regression (or additional care) around saving "last-message.txt", even if MQ's "newcommit()" changes its implementation logic from "localrepository.commit" to "localrepository.commitctx" with "memctx" in the future to save commit message into "last-messge.txt" with "memctx", "editor" should be valid function.

mq: fold the code path to invoke editor into specific logic (qnew) This factoring simplifies the succeeding patch to switch from "ui.edit()" to "getcommiteditor()" for qnew.

cmdutil: enhance "getcommiteditor()" for specific usages in MQ This patch introduces "finishdesc" and "extramsg" arguments into "getcommiteditor()" for specific usages in MQ. "finishdesc" will be used to treat the commit message as "[mq]; patch-file-name" (default MQ commit message), if it is left as empty, instead of aborting commit process. "extramsg" will be used to show the line below: HG: Leave message empty to use default message instead of: HG: Leave message empty to abort commit

tag: use the editor gotten by "getcommiteditor()" instead of "ui.edit()" This patch also enhances "test-tag.t", because "hg tag" hasn't been explicitly tested around editor invocation and "--edit" option.

import: use "getcommiteditor()" instead of explicit editor choice This patch also enhances "test-import-bypass.t" and "test-import.t", because "hg import" hasn't been explicitly tested around editor invocation and "--edit" option. This patch explicitly tests below: - with "--bypass" (regardless of "--edit"): - not invoked, if the patch contains the commit message - not invoked, if the commit message is explicitly specified - invoked, otherwise (just adding comment) - without "--bypass": - with "--edit": - not invoked, if "--no-commit" is not specified - invoked, otherwise - without "--edit": - not invoked, if the patch contains the commit message - not invoked, if "--message" or "--logfile" is specified (just adding comment) - invoked, otherwise

graft: use "getcommiteditor()" instead of explicit editor choice This patch also enhances "test-graft.t", because "hg graft" hasn't been explicitly tested around editor invocation and "--edit" option.

amend: use "getcommiteditor()" instead of explicit editor choice This patch doesn't change any tests like as preceding patches, because editor invocation is already tested in "test-commit-amend.t".

commit: use "getcommiteditor()" instead of explicit editor choice This patch also eliminates "forceeditor" no more referred. This patch doesn't change any tests like as preceding patches, because editor invocation is already tested well.

backout: use "getcommiteditor()" instead of explicit editor choice This patch also enhances "test-backout.t", because "hg backout" hasn't been explicitly tested around editor invocation and '--edit' option.

backout: avoid redundant message examination Before this patch, "hg backout" examines "--message" and "--logfile" options explicitly. But this examination is redundant, because "commitfunc()" can receive the result of same examination by "cmdutil.logmessage()" in "cmdutil.commit()" through "message" argument. This patch avoids redundant message examination by "message" examination in "commitfunc()".

transplant: use "getcommiteditor()" instead of explicit editor choice This patch also enhances "test-transplant.t", because "hg transplant" hasn't been explicitly tested around editor invocation and "--edit" option.

rebase: use "getcommiteditor()" instead of explicit editor choice This patch also enhances "test-rebase-scenario-global.t", because "hg rebase" hasn't been explicitly tested around editor invocation and "--edit" option. In the other hand, this patch doesn't enhance tests in "hg rebase --collapse" case, because it is already tested in "test-rebase-collapse.t".

histedit: use "getcommiteditor()" instead of explicit editor choice for "--continue" This omits (redundant) adding "\n' to "message", because: - empty line is inserted by "commitforceeditor", if editor is invoked - tail white-spaces are stripped at storing into chaneglog, otherwise This patch also enhances "test-histedit-edit.t", because "hg histedit" hasn't been explicitly tested around editor invocation and "--continue" option.

histedit: use "getcommiteditor()" instead of explicit editor choice for "fold" This patch doesn't change any tests like as preceding patches, because editor invocation is already tested in "test-histedit-fold.t".

histedit: use the editor gotten by "getcommiteditor()" for "message" Before this patch, "hg histedit" for "message" uses "ui.edit()" for commit message editing. It shows original commit message, but not detail about the target revision: status of each modified/added/removed files, for example. This patch uses the editor gotten by "getcommiteditor()" instead of "ui.edit()" for "message" In "test-histedit-edit.t", this patch omits "fixbundle" invocation, because it prevents from confirming the "HG: added f" line in commit message by filtering " added " lines. Omiting "fixbundle" invocation causes that the exit code of "hg histedit" appears as one of command line: in this case, "hg histedit" is aborted by (expected) exception raising.

fetch: use "getcommiteditor()" instead of explicit editor choice This patch also enhances "test-fetch.t", because "hg fetch" hasn't been explicitly tested around editor invocation and '--edit' option.

cmdutil: introduce "getcommiteditor()" to simplify code paths to choose editor "getcommiteditor()" can simplify code paths to choose commit editor according to '--edit' option as below: before: editor = cmdutil.commiteditor # or editor = None/False if opts.get('edit'): editor = cmdutil.commitforceeditor after: editor = cmdutil.getcommiteditor(**opts) "getcommiteditor()" accepts option arguments not in "opts" style but in "**opts" style, because some code paths want to invoke it with just explicit "edit=True" argument (building dictionary is redundant).

update: when deactivating a bookmark, print a message This helps prevent user confusion when innocent-seeming commands like 'hg update -C .' are run.

doc: improves merge-tools example with an overwrite of existing config We highlight the fact that a user hgrc can overwrite the system wide preconfiguration. As other benefit we show priority value other than 1 and shows vimdiff configuration is usually directly available. This is valuable as vimdiff is (surprisingly) a common request from user.

help: add additional information in the merge-tools section of config help The merge tool configuration in general has always been a confusing topic for user. We add mention of: - possible pre-existing configuration, - way to look at it, - the more detailed help topic about how merge-tools configuration works. This should help users find they way.

subrepo: use subrepo shortid method to generate subrepo diverged promptchoice We were always using only the first 12 characters of the subrepo revision id when generating the "subrepo diverged" promptchoice. This is not necessarily correct for non mercurial subrepos.

subrepo: add shortid() method to subrepo classes This method takes an "id" (e.g. a revision id) and returns a "short" version (e.g. a short revision id). This will be used on the next revision to fix a small bug in the way that the text on the promptchoice shown when a subrepo diverges is generated.

localrepo: call _dirstatestatus instead of duplicating logic

workingctx: call _dirstatestatus in status Rip out the call from workingctx.status to localrepo.status.

context: add private _dirstatestatus method This patch is a step forward in getting rid of needing to check 'parentworking' throughout the status method. Eventually, we will use the power of inheritance to do the correct thing when comparing the working directory with its parent. This method is mostly a copy from localrepo.status. The custom status method of workingctx will eventually be absorbed by the refactoring of localrepo.status to context.status but unfortunately we can't do it in one step.

committablectx: move status to workingctx This method was accidentally placed into the committablectx class. It contains logic for querying the dirstate so we move it to the correct class.

localrepo: factor out parentworking logic for comparing files We will temporarily call a private method of the context class while we are in the process of removing the need of having localrepo.status.

localrepo: improve dirstate.normal lookup by cacheing the function

localrepo: move symlink logic to workingctx

merge: separate worker functions for batch remove and batch get The old code had one function that could do 2 different things. First, is was called a bunch of times to do one thing. Next, it was called a bunch of times to do the other thing. That gave unnecessary complexity and a dispatch overhead. Having separate functions is "obviously" better than having a function that can do two things, depending on its parameters. It also prepares the code for the next refactorings.

merge: change debug logging - test output changes but no real changes Preparing for action list split-up, making sure the final change don't have any test changes. The patch moves debug statements around without really changing anything. Arguably, it temporarily makes the code worse. The only justification is that it makes it easier to review the test changes ... and in the end the big change will not change test output at all. The changes to test output are due to changes in the ordering of debug output. That is mainly because we now do the debug logging for files when we actually process them. Files are also processed in a slightly different but still correct order. It is now primarily ordered by action type, secondarily by filename. The patch introduces some redundancy. Some of it will be removed again, some of it will in the end help code readability and efficiency. It is possible that we later on could introduce a "process this action list and do some logging and progress reporting and apply this function". The "preserving X for resolve" debug statements will only have single space indentation. It will no longer have a leading single space indented "f: msg -> m" message. Having this message double indented would thus no longer make sense. The bid actions will temporarily be sorted using a custom sort key that happens to match the sort order the simplified code will have in the end.

merge: move constant assignments a bit and use them more

merge: change priority / ordering of merge actions The ordering of actions matters. Normal file system semantics is that files have to be removed before a directory with the same name can be created. Before the first ordering key was to have 'r' and 'f' actions come first, secondary key was the filename. Because of future refactorings we want to consistently have all action types (with a sensible priority) as separate first keys. Grouped by action type, we sort by filename. Not processing in strict filename order could give worse performance, especially on spinning disks. That is however primarily an issue in the cases where "all" actions are of the same kind and will be grouped together anyway.

run-tests: fix --interactive option ``TTest._testpath`` never existed. This must be the remain of some contributors side refactoring.

run-test: fix AttributeError in the --interactive prompt One must choose between ``"y yes".split()`` and ``('y', 'yes')``. I choose the later. The feature still crash when you answer "yes" to use it. But at least, the prompt itself works.

run-test: restore the -i prompt by write .err before checking if it exists The `--interactive` flag workis by overwriting the original test file by its `.err` version. So we need to write it before calling `self.fail`. Otherwise the `.err` file does not exists and `--interactive` is ignored. We can move that block code around because it is dedicated to write changed output and we moves it in the try-except dedicated to handling changed output. Note that the flog is still badly broken after this change. But at least it crash instead of being ignored.

run-tests: move _gethgpath() into TestRunner

run-tests: move string escaping to TTest With this patch, TTest is almost fully self-contained and extractable. Only logging functions remain outside of its class.

run-tests: add some docstrings

run-tests: move createhgrc into Test

run-tests: move SKIPPED_PREFIX and FAILED_PREFIX into TTest

run-tests: move SKIPPED_STATUS into Test class

run-tests: move parsehghaveoutput() into TTest This patch starts a sequence of patches that will try to isolate everything related to t tests into the TTest class.

run-tests: make some methods of TestRunner internal

run-tests: eliminate main()

run-tests: move option parser logic to TestRunner.run()

run-tests: move umask into TestRunner.run() We now properly restore the umask as well, since run() tries to clean up after itself.

run-tests: move checktools into TestRunner.run()

run-tests: move test discovery into TestRunner.run()

run-tests: move test shuffling and sorting into TestRunner

run-tests: assign testdir in TestRunner

run-tests: move hash seed logic to TestRunner

run-tests: move tmpdir calculations into TestRunner

run-tests: move more path calculations into TestRunner

run-tests: move pypath manipulation into TestRunner

run-tests: establish TestRunner.run() (amended by mpm to remove environ cleanup - unrelated change that breaks on Solaris)

run-tests: move program searching into TestRunner

run-tests: allow TestRunner to be passed into main() This allows 3rd parties to specify a custom TestRunner. This is useful for providing your own test discovery mechanism, for example.

run-tests: move test discovery logic into a function The new function is easily monkeypatchable. This facilitates more advanced test discovery by 3rd parties such as extensions.

run-tests: move scheduletests() into TestRunner

run-tests: move abort global to TestRunner

run-tests: move runtests() into TestRunner

run-tests: move results global into TestRunner

run-tests: move times global into TestRunner

run-tests: move gettest() into TestRunner

run-tests: move outputcoverage() into TestRunner

run-tests: move outputtimes() into TestRunner

run-tests: move checkhglib into TestRunner

run-tests: move installhg() into TestRunner

run-tests: move createdfiles out of a global and into TestRunner

run-tests: move usecorrectpython() into TestRunner

run-tests: move cleanup() into TestRunner

run-tests: add options to runner

run-tests: add options to runner

run-tests: move COVERAGE_FILE out of a global

run-tests: move PYTHONDIR out of a global

run-tests: move TMPBINDIR out of a global

run-tests: move BINDIR out of a global

run-tests: move INST out of a global

run-tests: move HGTMP out of a global

run-tests: move TESTDIR out of a global This patch starts the process of removing global variables from run-tests.py. The goal of this is to make it easier to run tests differently without having to concern yourself with global state.

run-tests: establish a class to hold testing state

run-tests: refactor runone() into gettest() and scheduletests() runone() has been removed. Replacing it are gettest() (which returns a Test instance) and a small amount of boilerplate in scheduletests().

run-tests: move computation of test paths into Test.__init__

run-tests: move logging of test start into Test.run()

run-tests: remove remaining uses of TestResult

run-tests: move output writing to Test.run()

run-tests: move err file saving to Test.run()

run-tests: emit exception failure result from Test.run()

run-tests: move test name filter to Test.run()

run-tests: move keyword processing into Test.run()

run-tests: move retesting result to Test.run()

run-tests: move blacklist skipping to Test.run()

run-tests: check for test file existence in Test.run() We delay this a little bit. But it shouldn't really matter when the check is performed.

run-tests: move remaining result processing to Test.run()

run-tests: move output difference processing to Test.run()

run-tests: generate timeout result in Test.run()

run-tests: add skip processing to Test

run-tests: move fail() into Test The code was changed slightly as part of the migration to make use of appropriate variables and modern Python conventions.

run-tests: move success() into Test

run-tests: move err path handling to Test

run-tests: handle interrupted in Test.run()

run-tests: kill daemons during Test.cleanup() As a safety precaution, we kill daemons in Test.cleanup(). This is necessary for a subsequent patch that will reraise KeyboardInterrupt before killdaemons() runs as part of run().

run-tests: capture reference output in Test.__init__ Reference output should be constant and doesn't need to be computed at test execution time. We calculate it earlier. This patch is the first in a mini series that will change how the TestResult object works.

run-tests: make globmatch a static method of TTest

run-tests: make rematch a static method of TTest

run-tests: make linematch a static method of TTest linematch only applies to t tests. It makes sense to move everything t test related to the TTest class.

run-tests: finish moving tsttest() into TTest

run-tests: move t test execution from tsttest() to TTest.run() After this patch, tsttest() only contains output/result processing.

run-tests: move t test parsing into its own function Test parsing is somewhat complicated. This patch extracts it into its own function. The impetus of this patch is folding tsttest() into the TTest class. Subsequent patches will continue this work until tsttest() no longer exists.

run-tests: roll pytest() into PythonTest._run() Python was the old runner function. It no longer needs to exist since the PythonTest class took its job.

run-tests: remove threadtmp in Test.cleanup() threadtmp is an implementation detail. We move the cleanup of this directory to Test.cleanup() and make the variable internal. The cleanup function will eventually disappear into unittest machinery.

run-tests: allow Test.run() to run multiple times Test.run() can now be executed multiple times on the same Test instance. This feature is currently unused and there are no plans to implement it. The main reason for this work was to refactor testtmp, replacements, and env to be run-time specific as opposed to Test instance specific.

run-tests: capture reference output in TestResult class

run-tests: give TestResult a skipped attribute

run-tests: pass TestResult into run()

run-tests: capture execution results in a TestResult class Some implementation details of test execution still live outside of Test. These include determining what a result means and cleaning up after the test. To move to the world where more of this logic can live inside Test or a derived object, the logic for test execution needs to be refactored. Specifically, exception trapping and opportunities for result processing need to be moved into Test. This patch starts the process by establishing a TestResult class for holding the results of a test execution. In order to actually use this class, exception trapping and execution time recording needed to be moved into Test.run().

run-tests: clean up temp directory variables testtmp is an implementation detail. It didn't need to be exposed to the world. threadtmp is derived from count. It is now created as part of the constructor and mostly hidden from the outside world.

run-tests: move env into Test Environment variables are an implementation detail of how tests are executed. This patch moves environment variable logic into Test and completely hides it from the outside. With this patch, a Test can be executed with two lines: init + run(). Tests are still single-use and take a more arguments to the constructor than likely necessary. These will get addressed in subsequent patches.

run-tests: move killdaemons into Test.run() killdaemons() was the only part of runone() looking at env variables. We move killdaemons() into Test.run() to enable us to fully move env into Test.

run-tests: move replacements and port management into Test replacements and ports are really implementation details of a Test. They have been moved to instance variables.

run-tests: move createhgrc() call into Test.run() createhgrc() is an implementation detail of how tests are run. It makes sense to move it into Test.run(). Note that this will cause the test execution time to include the creation of hgrc. The author does not believe this is a significant change worth worrying about.

run-tests: move createenv() into Test createenv() is consulting lots of test-specific variables. It makes sense to attach it to the Test class.

run-tests: move replacements generation into Test The API is a bit funky. Things will look better once all state is captured in Test.

run-tests: move testtmp into Test class This patch starts the process of moving test-specific variables into the Test class. The ultimate goal is to be able to instantiate a Test with minimal arguments and to call run() on it without too much thinking. This will make it much easier to run tests from other contexts. It will also enable things like running a test multiple times.

run-tests: create classes for representing tests Currently, the state for an individual test is scattered across a number of functions and variables. This patch begins a process of isolating a single test's state into instances of a class. It does this by establishing a new Test base class and child classes for Python tests and T tests. The class currently has a run() API that proxies into the existing "runner" functions. Upcoming patches will move the logic for each test type into the class.

revsetbenchmark: add `author(mpm) or author(lmoscovicz)` to the canonical list This matters as `author(mpm)` have a lot of matches evenly split in the repo, while `author(lmoscoviz)` have less match (and later). This changes the execution path of the "or" operator a lot.

filterpyflakes: filter WindowsError unconditionally

filterpyflakes: make memoryview filtering unconditional

py3kcompat: drop unused export

py3kcompat: don't convert os.environ to bytes os.environ accepts str not bytes. Assigning bytes will result in a run-time error.

demandimport: pass proper level to __import__ in Python 3 demandimport was failing in Python 3 with a ValueError because __import__'s level=-1 has gone away (-1 means to try both relative and absolute imports and relative imports don't exist in Python 3). With this patch, demandimport still doesn't work in Python 3 (it fails when importing a non-package module).

help: suggest keyword search when no topic is found When `hg help foobar` fails, it now suggests using `hg help --keyword foobar` instead of printing a full page of basic commands. This should greatly increases discoverability of the `hg help --keyword` argument.

help: provide a more helpful message when no keyword are matched Before this changeset, when no topic were matching the provided keyword ( in command such as `hg help --keyword babar`) the output was empty. This is confusing and unhelpful for new users seeking assistance in the help. We now display: $ hg help --keyword babar abort: no matches (try "hg help" for a list of topics) This send users in a new direction where they may find what they are looking for.

revsetbenchmark: use optparse to retrieve argument We need more flexibility. For example we'll want to run the benchmark on other repository.

revsetbenchmark: add a usage message when no arguments are passed This increase the odd someone who didn't wrote will it find out how to use this script.

revsetbenchmark: add `::tip and draft()` to the canonical list The want to test element on different side of the iterators.

revset: cosmetic changes in spanset range comparison We use the python syntax for range comparison: `a < x < c`. This is shorter, more readable and less error prone. This comparison escaped the cleanup make in e2031c8ca4f8

revset: drop spanset._contained All its users inlined it for performance reasons. (See 1d7a2771aa36 and e2031c8ca4f8)

patchbomb: includes series information in the header We includes information about the series being patch bombed in all email. Two new headers are added: * X-Mercurial-Series-Index: index of the patches in the series (starts at 1) * X-Mercurial-Series-Total: The total number of patches in the series This information is available in the email subject line, but having them formalized in the header will helps automated tools to process patches send with modern mercurial.

pager: add attend-<command> option This lets users override attend settings locally on a command granularity.

pager: variable reorder

pager: break auto out of command check loop

pager: break always out of command check loop

pager: break pager invocation out of command check loop

tests: fix test failure on vfat It can't handle filenames with spaces. We don't have a good hghave test for this, so we wrap it with unix-permissions.

largefiles: include largefiles when doing log on a directory (issue4241) The matchers _files had to include both the real root and the standin version of the root.

journal: set Abort hint when failing due to an abandoned transaction

merge: define conflict marker labels in filemerge() Moves the conflict marker definition up to filemerge, so it gets applied to all merge strategies, and so in a future patch we can manipulate the markers.

merge: prevent simplemerge from mutating label list simplemerge was using list.pop() to remove items from the labels list. This mutated the list and made it unusable by other calls (for instance, it might be used in both the premerge and actual merge stages).

tests: ignore "undefined name 'memoryview'" pyflakes error on earlier Python Before this patch, "test-check-pyflakes.t" shows unexpected "undefined name 'memoryview'" error for "mercurial/util.py" on Python 2.6.x or earlier, because they don't define symbol 'memoryview'. This patch introduces excluding patterns into "filterpyflakes.py" to ignore "undefined name 'memoryview'" pyflakes error on Python 2.6.x or earlier

mq: eliminate unused variable for test-check-pyflakes.t "user" in "fold()" has become useless since 49148d7868df.

merge: make debug output slightly more helpful by including message for action Make recently introduced messages more useful. Instead of: f1: g f2: m say: f1: remote is newer -> g f2: versions differ -> m

merge: simplify mergestate iter

resolve: simplify "finished" message The recently introduced message was: no unresolved files; you may continue your unfinished operation This had three problems: - looks a bit like an error message because it's not saying "we've just resolved the last file" - refers to "unfinished operation", which won't be the case with "update" or "merge" - introduces semicolons to error messages, which is stylistically questionable I've simplified this to: no more unresolved files In the future, if we want to prompt someone to continue a particular operation, we should use a hint style: no more unresolved files (use 'hg graft --continue' to finish grafting)

resolve: print message when no unresolved files remain (issue4214) When using resolve, users often have to consult with the output of |hg resolve -l| to see if any unresolved files remain. This step is tedious and adds overhead to resolving. This patch will notify a user if there are no unresolved files remaining after executing |hg resolve|:: no unresolved files; you may continue your unfinished operation The patch stops short of telling the user exactly what command should be executed to continue the unfinished operation. That is because this information is not currently captured anywhere. This would make a compelling follow-up feature.

resolve: print warning when no work performed (issue4208) Previously, if the paths specified as arguments to |hg resolve| were invalid, they were silently ignored and a no-op would ensue. This patch fixes that in some scenarios. If none of the paths specified to |hg resolve| match a path that is in mergestate, a warning will be emitted. Ideally, a warning would be emitted for every path/pattern specified that doesn't match anything. To achieve this would require significant refactoring of the matching subsystem. That work is beyond the scope of this patch series. Something is better than nothing and this patch gets us something.

resolve: abort when not applicable (BC) The resolve command is only relevant when mergestate is present. This patch will make resolve abort when no mergestate is present. This change will let people know when they are using resolve when they shouldn't be. This change will let people know when their use of resolve doesn't do anything. Previously, |hg resolve -m| would allow mergestate to be created. This patch now forbids that. Strictly speaking, this is backwards incompatible. The author of this patch believes creating mergestate via resolve doesn't make much sense and this side-effect was unintended.

resolve: split test Part of test-resolve.t is split into multiple tests to create an injection point for new tests that will be added in subsequent patches.

resolve: use early continue and deindent

mergestate: consistently set variables to None Some code branches and exceptional circumstances such as empty mergestate files could result in mergestate._local and mergestate._other not being defined or reset to None. These variables are now correctly set to None when they should be.

changegroup: refactor outgoing logic into a function Extensions that add to bundle2 will want to know which commits are outgoing so they can bundle data that is appropriate to those commits. This moves the logic for figuring that out to a separate function so extensions can do the same computation.

bundle2: fix bundle2 pulling all revs on empty pulls When bundle2 was enabled, if hg pull had no commits to pull, it would print 'no changes found' and then download the entire repository from the server. This was caused by heads and common being set to None, which gets treated as heads=cl.heads() and common=[nullid], which means download the entire repo. Pulling bundles without a changegroup is a valid use case (like if we're just updating bookmarks), so this modifes the bundle code to allow not adding changegroups.

exchange: fix bad indentation Those two lines where double indented for no good reasons.

exchange: propagate arguments to the _getbundleextrapart function The arguments was wrongly propagated (again).

bundle2: fix configuration name mismatch During pulls bundle2 was checking server.bundle2, but during pushes it was checking experimental.bundle2. This makes them both experimental.bundle2.

build: initial support for in-tree autobuilding recipes

tests: declare commands using decorator

share: declare commands using decorator

relink: declare command using decorator

record: declare commands using decorator

hgk: declare commands using decorator

color: declare command using decorator

children: declare command using decorator

fetch: declare command using decorator

extdiff: declare command using decorator

churn: declare command using decorator

convert: declare commands using decorator

debugshell: declare command using decorator

largefiles: declare commands using decorator

cmdutil: omit redundant "savecommitmessage()" in "tryimportone()" The preceding patch causes that "makememctx()" with "editor" argument saves (manually edited) commit message into ".hg/last-message.txt": saving itself is executed indirectly in "memctx.__init__()". This makes it redundant to invoke "savecommitmessage()" on caller side of "makememctx()". This patch omits such redundant "savecommitmessage()" invocation in "tryimportone()". "tryimportone()" uses one of "commiteditor" or "commitforceeditor" as "editor" argument, and this causes saving commit message always.

amend: use "editor" argument for "memctx.__init__" to save commit message This patch uses "editor" argument of "memctx.__init__" to save commit message, instead of explicit editor invocation and saving commit message by "localrepository.savecommitmessage()". By passing one of "commiteditor" or "commitforceeditor" as "editor", "memctx.__init__" saves commit message, even when editor invocation is not needed.

histedit: pass "editor" argument to "memctx.__init__()" for "collapse" command The preceding patch causes that "memctx.__init__()" with "editor" argument invokes editor and saves edited commit message into ".hg/last-message.txt". This patch passes "editor" argument to "memctx.__init__()" instead of explicit invocations of "commitforceeditor()" and "savecommitmessage()" for "collapse" command.

context: move editor invocation from "makememctx()" to "memctx.__init__()" This patch introduces "editor" argument to "memctx.__init__()", and moves editor invocation from "makememctx()" to "memctx.__init__()", to centralize editor invocation into "memctx" object creation. This relocation is needed, because "makememctx()" requires the "store" object providing "getfile()" to create "memfilectx" object, and this prevents some code paths from using "makememctx()" instead of "memctx.__init__()". This patch also invokes "localrepository.savecommitmessage()", when "editor" is specified explicitly, to centralize saving commit message into "memctx" object creation: passing "cmdutil.commiteditor" as "editor" can achieve both suppressing editor invocation and saving into ".hg/last-message.txt" for non empty commit messages.

localrepo: add "editor" argument to "tag()" Before this patch, "localrepository.tag()" doesn't take "editor" argument, and this prevents callers from passing "editor" argument to "localrepository.commit()" invoked internally. This patch adds "editor" argument to "localrepository.tag()" (and "_tag()", too), and makes "commands.tag()" invoke it with "editor" argument. This patch also omits explicit "localrepository.savecommitmesssage()" invocation, because "localrepository.commit()" will invoke specified "editor" and save edited commit message into ".hg/last-message.txt" automatically.

qrefresh: use "editor" argument of "commit()" instead of explicit "ui.edit()" Before this patch, "hg qrefresh" and "hg qfold" invoke "ui.edit()" explicitly to get commit message edited manually. This requires explicit "localrepository.savecommitmessage()" invocation to save edited commit message into ".hg/last-message.txt", because unexpected exception raising may abort command execution before saving it in "localrepository.commit()". This patch uses "editor" argument of "localrepository.commit()" instead of explicit "ui.edit()" invocation for "hg qnew" and "hg qfold" "localrepository.commit()" will invoke "desceditor()" function newly added by this patch, and save edited commit message into ".hg/last-message.txt" automatically. This patch passes not "editor" but "desceditor" to "commit()", because "hg qnew" and "hg qfold" require editor function to return edited message (and invoke "patchheader.setmessage()" with it) if not empty, or default message otherwise. This patch also avoids "not q.applied" check at "hg qrefresh --edit", because it is also checked in "queue.refresh()", and it is not needed to get commit message from patch header before "queue.refresh()".

qrefresh: relocate message/patch-header handling to delay message determination Before this patch, commit message for refreshed MQ changeset is determined, and written into refreshed patch file before "localrepository.commit()" invocation. This makes refactoring to use "editor" argument of "commit()" instead of explicit "ui.edit()" invocation in succeeding patch difficult. This patch relocates message/patch-header handling to delay message determination.

qnew: use "editor" argument of "commit()" instead of explicit "ui.edit()" Before this patch, "hg qnew" invokes "ui.edit()" explicitly to get commit message edited manually. This requires explicit "localrepository.savecommitmessage()" invocation to save edited commit message into ".hg/last-message.txt", because unexpected exception raising may abort command execution before saving it in "localrepository.commit()". This patch uses "editor" argument of "localrepository.commit()" instead of explicit "ui.edit()" invocation for "hg qnew". "localrepository.commit()" will invoke "desceditor()" function newly added by this patch, and save edited commit message into ".hg/last-message.txt" automatically. This patch passes not "editor" but "desceditor" to "commit()", because "hg qnew" requires editor function to return edited message if not empty, or default message otherwise. This patch applies "rstrip()" on "defaultmsg" at comparison between "nctx.description()" and "defaultmsg", because the former should be stripped by "changelog.stripdesc()" and the latter may have tail white spaces inherited from "patchfn".

histedit: use "editor" argument of "commit()" instead of explicit "ui.edit()" Before this patch, "message" action of "hg histedit" uses "ui.edit()" explicitly to get commit message edited manually. This requires explicit "localrepository.savecommitmessage()" invocation to save edited commit message into ".hg/last-message.txt", because unexpected exception raising may abort command execution before saving it in "localrepository.commit()". This patch uses "editor" argument of "localrepository.commit()" instead of explicit "ui.edit()" invocation for "message" action of "hg histedit" "localrepository.commit()" will invoke "editor()" function newly added in this patch, and save edited commit message into ".hg/last-message.txt" automatically.

test-pyflakes: detect undefined name error It should be able to catch the following mistakes at 2606e7f227f6: mercurial/exchange.py:590: undefined name 'UnknownPartError' mercurial/match.py:346: undefined name 'pat' mercurial/win32.py:365: undefined name '_ERROR_NO_MORE_FILES' tests/killdaemons.py:46: undefined name 'check'

run-tests: initialize global variables to suppress pyflakes warning

merge with stable

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

color: add effect to the template symbol table Previously, words like 'red' had to be protected by quotes before passing to the label template function. Now, we add color effects to the symbol table so that commands like, $ hg log -r . -T "{label(red, node|short)}\n" can work without the need for quoting.

amend: invoke editor forcibly when "--edit" option is specified 422981492ace introduces "--edit" option into "hg commit", but it doesn't work for "hg commit --amend", because 422981492ace prepares for editor invocation only around "commitfunc()" internal function, which is used only for temporary amend commit by "cmdutil.amend()". Actual commit message editing is executed in "cmdutil.amend()". This patch invokes editor forcibly when "--edit" option is specified for "hg commit --amend", even if commit message is specified explicitly by "--message" or "--logfile". This patch also removes useless handling for commit message and editor invocation around "commitfunc()" internal function.

commit: abolish useless "--force-editor" internal option for "hg commit" "--force-editor" option for "hg commit" has been useless since 12721a20ed30, which makes "commands.tag()" invoke "cmdutil.commit()" directly instead of "commands.commit()" with "--force-editor" internal option. This patch abolishes useless "--force-editor" internal option for "hg commit".

subrepo: return non-zero exit code when a subrepo push doesn't succeed

debugrevlog: use unfiltered view for changelog

debugrevlog: format columns (more) nicely when dumping index data

branchmap: log events related to branch cache The blackblox log will now contain log events when the branch caches are updated and written.

tags: log events related to tags cache We now log when .hg/cache/tags data is built from scratch by reading manifests and when the file is written.

merge with stable

histedit: save manually edited commit message into ".hg/last-message.txt" Before this patch, manually edited commit message for "message" command in histedit-ing is not saved into ".hg/last-message.txt" until it is saved by "localrepository.savecommitmessage()" in "localrepository.commit()". This may lose such commit message, if unexpected exception is raised. This patch saves manually edited commit message for "message" comand in histedit-ing into ".hg/last-message.txt" just after user editing. This is the simplest implementation to fix on stable. Editing and saving commit message should be centralized into the framework of "localrepository.commit()" with "editor" argument in the future. This patch uses repository wrapping class for exception raising before saving commit message in "localrepository.commit()" easily and certainly, because such exception requires corner case condition.

rebase: tell when reopening a closed branch head Give same 'reopening closed branch head X' message as commit gives.

dirstate: inline local finish function Having it as a local function adds no value.

demandimport: make it possible to disable by setting HGDEMANDIMPORT=disable Convenient for debugging weird problems that are caused by demandimport or obfuscated by it. This is an undocumented developer feature.

spelling: fixes from spell checker

tests: warn on invalid #if directive

run-tests: test result shows when a failed test could not start a server Failing to start a server happens regularly, at least on windows buildbot. Such a failure often has nothing to do with the test, but with the environment. But half the test output can change because some data is missing. Therefore this is worth an extended error message. Detect the server failure in the diff output because it is most reliable there. Checking the output only does not show if the server failure was expected. Old failure message when server start failed: Failed test-serve.t: output changed New message: Failed test-serve.t: serve failed and output changed

commit: --edit/-e to force edit of otherwise-supplied commit message The --edit/-e option for the 'commit' command forces editor, even when a commit message has been provided already by other means, such as by the -m or -l options.

bundle2: directly feed part to readbundle Now that part payload can be read like a stream, we can directly use it to feed the unbundle10 process.

bundle2: lazy unbundle of part payload The `unbundle` part gains a `read` method to retrieve payload content. This method behaves as a python file-like read method. The bundle-processing code is updated to make sure a part is fully consumed before another one is extracted. Test output changes because the debug output is even more interleaved now.

util: support None size in chunkbuffer.read() When no size is provided, read the whole buffer. This aligns with the usual behavior of `read()` in python.

bundle2: lazily iterate over bundle parts in the test We used to create a list to know the number of parts in the bundle. This prevents any lazy reading as planned for real usage. The list creation is dropped. Some test output changed as debug output is now interleaved with command output.

bundle2: move unpackheader closure into the class With the same argument as the other one, we move this closure into the `unbundlepart` class.

bundle2: move the fromheader closure into the class itself The class is now directly related to this header data. We can sanely move it on the class. I do not like closures very much...

bundle2: add an unbundle part responsible from unbundling part We have a new unbundle class and it is now responsible from extracting its own data. The top level bundler only extracts the header (to detect an end of stream marker) then leaves everything else to the `unbundlepart` class. The ultimate goal is to have `unbundlepart` responsible for lazily extracting its payload. This is mostly code movement.

bundle2: extract stream/unpack logic in an unpackermixin The coming `unbundlepart` will need the same kind of method than `unbundle20` for unpacking data from the stream. We extract them into a mixin class before the creation of `unbundlepart`.

exchange: restore truncated comment The old version of this comment appeared to have been trunca

grep: highlight all matched words "hg grep" highlights first matched word only. This behavior is different from GNU grep. This patch makes highlight all matched words.

phase: add a passing test for (issue3575) Apparently this issue was fixed along the way (If it ever existed at all…)

run-tests: allow test paths in other directories Previously, test paths were assumed to be in the same directory and wouldn't have a directory component. If a path with a directory component was specified, it would be filtered out. This change allow paths to contain directories. This in turn allows tests from other directories to be executed. Executing tests in other directories may break assumptions elsewhere in the testing code. However, on initial glance, things appear to "just work." This approach of running tests from other directories is successfully being used at https://hg.mozilla.org/hgcustom/version-control-tools/file/7085790ff3af/run-mercurial-tests.py

run-tests: allow option parser to be extended This patch moves the OptionParser population into its own function so consumers may modify the OptionParser before arguments are evaluated. This will allow consumers to add custom options, set different defaults, etc.

run-tests: use return values instead of sys.exit

run-tests: Pass arguments into argument parser Before, arguments were not passed into the optparse.OptionParser instance and were coming from sys.argv. This patch enables consumers to define the list of arguments to parse without having to adjust sys.argv.

bundle2: rename part to bundlepart We are going to introduce an `unbundlepart` dedicated to reading bundle. So we need to rename the one used to create bundle. Even if dedicated to creation, this is still used for unbundling until we get the new class.

bundle2: comment to clarify why the handler call is where it is The reason why it is here is not obvious. I'm the one who wrote it there in the first place and almost moved it 2 weeks later.

bundle2: use chunkbuffer for exchange.getbundle We can use `util.chunkbuffer` instead.

bundle2: lazily generate the changegroup part in exchange.getbundle Now that we have lazy generation of parts, let's use it.

bundle2: support chunk iterator as part data When the `part.data` attribute is an iterator, we assume it is an iterator of chunks and use it. We use a chunkbuffer to yield chunks of 4096 bytes. The tests are updated to use this feature.

bundle2: extract a _payloadchunks method for part We are preparing streaming capability for part. So the generation of payload chunk will becomes more complex. We extract this part in its own function before any changes.

changegroup: move chunk extraction into a getchunks method of unbundle10 This code used to be in `writebundle` only. We needs to make it more broadly available for bundle2. The "changegroup" bundle2 part has to retrieve the binary content of changegroup stream. We moved the chunks retrieving code into the `unbundle10` object directly and the `writebundle` code is now using that. This split is useful for bundle2 purpose, we want to be able to easily stream changegroup content in a part. To keep thing simples, we kept compression out of the new methods. If it make more sense in the future, compression may get included in this function too.

bundle2: use reply part to return result of addchangegroup We now have an official way to return the result of addchangegroup. The tests are updated to check that the return bundle is properly created. It will be used when push is bundle2 enabled.

bundle2: produce a bundle2 reply We do not know yet what kind of data future features and extensions will need to exchange. To handle that, bundle2 allows to send arbitrary content to the server. As a consequence, we need to be able to reply arbitrary content to the client. And, we can use bundle2 to transmit those arbitrary data. When a client will push a bundle2 to the server, the server will reply with a bundle2 itself. This changeset installs the first stone of this logic and test it.

bundle2: add reply awareness to unbundlerecords We need an efficient way to handle bundle replies. The unbundle records class is extended to carry such data.

bundle2: add an integer id to part For sending response to a pushed bundle, we need to link reply parts to request part. We introduce a part id for this purpose. This is a 32 bit unique integer stored in the header.

largefiles: don't prompt when one side of merge was changed but didn't change This can happen after backout or grafts or criss cross merges. We already do the same (but slightly different) thing in manifestmerge and filemerge.

color: fallback and test label as an effect With this changeset, we can now send a color name directly to the label function, e.g. $ hg log -r . -T "{label('red', node|short)}\n"

color: extract method for determining a valid effect This patch is just setup work so that we can reduce code duplication and have one place to define a valid effect.

revlog: use context ancestor instead of changelog ancestor We want to move in this direction.

copies: guard debug section with ui.debugflag

copies: remove _checkcopies wrapper - it does no good mergecopies might be doomed but it is not dead yet ...

transplant: use context ancestor instead of changelog ancestor We want to move in this direction. ctx.ancestor is in a better position for handling a situation with multiple ancestors.

commit: use revlog.commonancestors instead of .ancestor This do probably not make any real difference but is slightly more correct and we would like to get rid of flog.ancestor.

backout: don't limit heritage check to a single ancestor This do probably not make any real difference but is slightly more correct and we would like to get rid of changelog.ancestor.

ancestor: remove unused genericancestor

context: remove unused filectx.ancestor

shelve: add "writebundle()" to invoke "writebundle()" with relative path and vfs

shelve: add "applybundle()" to invoke "readbundle()" with relative path and vfs "applybundle()" also includes "addchangegroup()" invocation to encapsulate "vfs.join()" inside it.

bundlerepo: treat temporarily extracted bundle file via vfs

vfs: add "mkstemp()"

repair: make "strip()" treat bundle files via vfs This patch makes "repair.strip()" treat bundle files via vfs. This patch also avoids applying "vfs.join()" on the value returned by "changegroup.writebundle()", to get relative path from "_bundle()".

changegroup: add "vfs" argument to "readbundle()" to pass relative filename

repair: make paths in "_bundle()" relative to ".hg" This patch makes paths below in "_bundle()" relative to ".hg": - backup directory ("strip-backup"), and - bundle file under backup directory "vfs" is passed to "changegroup.writebundle()" to use relative path directly. This patch applies "vfs.join()" on the value returned by "_bundle()", because the caller expect it to return absolute path. This will be changed by succeeding patch changing the caller side.

changegroup: add "vfs" argument to "writebundle()" for relative access via vfs Before this patch, filename specified to "changegroup.writebundle()" should be absolute one. In some cases, they should be relative to repository root, store and so on (backup before strip, for example). This patch adds "vfs" argument to "writebundle()", and makes "writebundle()" open (and unlink) "filename" via vfs for relative access, if both filename and vfs are specified.

localrepo: make "undofiles()" return list of tuples "(vfs, relative filename)" Before this patch, "localrepository.undofiles()" returns list of absolute filename of undo files. This patch makes it return list of tuples "(vfs, relative filename)" to access undo files via vfs. This patch also changes "repair.strip()", which is the only user of "localrepository.undofiles()".

exchange: fix pyflakes import complaint

hgweb: override the charset attribute in the http request The default http request character set is UTF-8. If the message is not encoded in UTF-8, such as big5, it cannot be shown correctly. The 'charset' is overridden by the root document's, such that the user can select the proper encoding in the browser.

diff: use second filename for --stat reporting on git patches (issue4221)

exchange: drop useless line break

subrepo: check return code for git push (issue4223)

localrepo: add unbundle support Localrepo now supports the unbundle method of pushing changegroups. We plan to use the unbundle call for bundle2 so it is important that all peers supports it. The `peer.unbundle` and `peer.addchangegroup` code path have small difference so cause some test output changes. None of those changes seems problematic.

unbundle: extract the core logic in another function The `exchange` module now contains an `unbundle` function that holds the core unbundle logic. The wire protocol keeps its own unbundle function. It enforces wireprotocol-specific logic and then calls the extracted function. This aims at implementing unbundle for localrepo.

unbundle: extract checkheads in its own function We are going to refactor the unbundle function to have it working on a local repository too. Having this function extracted will ease the process. In the case of non-matching heads, the function now directly raises an exception. The top level of the function is catching it.

phase: apply publishing enforcement for "serve" source When a changegroup is added by a push on a publishing server, we ensure they are added as public. This is used to enforce publishing on server when the client is not aware of phases. It also prevents race conditions where a reader could see the changesets as draft before they get turned public by the client. Finally, this save rounds trip as the client does not need additional request to turn them public. However, this logic was only enforced when the changegroup was from a "push" source. And "push" is used for local pushes only. Wireprotocol push uses "serve" as source since Mercurial 1.9. We now enforce this logic for both "push" and "serve" sources. One could note that this logic was mainly useful during wireprotocol exchanges. So this code is finally put into good use, 9 versions after its introduction.

merge with stable

http: reuse authentication info after the first failed request (issue3567) [This was applied in 181108726ea5 but backed out again in af02783dea65 because of Python 2.4 issues. This edition and test-http.t works with Python 2.4.] Context: mercurial access to repository server with http access, and this server is protected by basic auth. Before patch: * mercurial try an anonymous access to server, server return 401 response and mercurial resend request with login / password information After patch: * mercurial try an anonymous access to server, server return 401 response. For all next requests, mercurial keep in memory this information (this server need basic auth information). This patch reduce the number of http access against mercurial server. Example, before patch: 10.10.168.170 - - [25/Oct/2013:15:44:51 +0200] "GET /hg/testagt?cmd=capabilities HTTP/1.1" 401 260 "-" "mercurial/proto-1.0" 10.10.168.170 - - [25/Oct/2013:15:44:52 +0200] "GET /hg/testagt?cmd=capabilities HTTP/1.1" 200 147 "-" "mercurial/proto-1.0" 10.10.168.170 - - [25/Oct/2013:15:45:00 +0200] "GET /hg/testagt?cmd=capabilities HTTP/1.1" 401 260 "-" "mercurial/proto-1.0" 10.10.168.170 - - [25/Oct/2013:15:45:01 +0200] "GET /hg/testagt?cmd=capabilities HTTP/1.1" 200 147 "-" "mercurial/proto-1.0" 10.10.168.170 - - [25/Oct/2013:15:45:03 +0200] "GET /hg/testagt?cmd=batch HTTP/1.1" 401 260 "-" "mercurial/proto-1.0" 10.10.168.170 - - [25/Oct/2013:15:45:04 +0200] "GET /hg/testagt?cmd=batch HTTP/1.1" 200 42 "-" "mercurial/proto-1.0" 10.10.168.170 - - [25/Oct/2013:15:45:06 +0200] "GET /hg/testagt?cmd=getbundle HTTP/1.1" 401 260 "-" "mercurial/proto-1.0" 10.10.168.170 - - [25/Oct/2013:15:45:07 +0200] "GET /hg/testagt?cmd=getbundle HTTP/1.1" 200 61184 "-" "mercurial/proto-1.0" 10.10.168.170 - - [25/Oct/2013:15:45:09 +0200] "GET /hg/testagt?cmd=listkeys HTTP/1.1" 401 260 "-" "mercurial/proto-1.0" 10.10.168.170 - - [25/Oct/2013:15:45:10 +0200] "GET /hg/testagt?cmd=listkeys HTTP/1.1" 200 15 "-" "mercurial/proto-1.0" 10.10.168.170 - - [25/Oct/2013:15:45:12 +0200] "GET /hg/testagt?cmd=listkeys HTTP/1.1" 401 260 "-" "mercurial/proto-1.0" 10.10.168.170 - - [25/Oct/2013:15:45:12 +0200] "GET /hg/testagt?cmd=listkeys HTTP/1.1" 200 - "-" "mercurial/proto-1.0" Example after patch: 10.10.168.170 - - [28/Oct/2013:11:49:14 +0100] "GET /hg/testagt?cmd=capabilities HTTP/1.1" 401 260 "-" "mercurial/proto-1.0" 10.10.168.170 - - [28/Oct/2013:11:49:15 +0100] "GET /hg/testagt?cmd=capabilities HTTP/1.1" 200 147 "-" "mercurial/proto-1.0" 10.10.168.170 - - [28/Oct/2013:11:49:17 +0100] "GET /hg/testagt?cmd=batch HTTP/1.1" 200 42 "-" "mercurial/proto-1.0" 10.10.168.170 - - [28/Oct/2013:11:49:19 +0100] "GET /hg/testagt?cmd=getbundle HTTP/1.1" 200 61184 "-" "mercurial/proto-1.0" 10.10.168.170 - - [28/Oct/2013:11:49:22 +0100] "GET /hg/testagt?cmd=listkeys HTTP/1.1" 200 15 "-" "mercurial/proto-1.0" 10.10.168.170 - - [28/Oct/2013:11:49:24 +0100] "GET /hg/testagt?cmd=listkeys HTTP/1.1" 200 - "-" "mercurial/proto-1.0" In this last example, you can see only one 401 response.

bundle2: use discard to remove bundle2 cap caps.remove('bundle2') was throwing an exception if bundle2 wasn't present in the capabilities. This was causing test-static-http.t to hang. Let's just use discard, so we don't get an exception.

statichttp: respect localrepo _restrictcapabilities The static http repository was doing his own filtering of capability ignoring the filtering done in the local repo main class. This led to static http using the current draft of bundle2. We now apply both.

tests: make unshelve tests more tricky - don't depend on size change One reason shelve and largefiles doesn't work could be rapidly changing standin files. Prove that shelve in general doesn't have problems with that.

shelve: introduce secret option for using fixed date for temporary commit Using a fixed date makes hashes stable and makes debugging simpler. The date and hashes of this changeset are normally not exposed.

mq: repo['.'] is not a wctx, repo[None] is The parameters passed to subrepo.submerge are confusing anyway.

shelve: repo['.'] is not a wctx but a pctx Don't confuse hackers!

revlog: deal with chunk ranges over 2G on Windows (issue4215) Python uses a C long (32 bits on Windows 64) rather than an ssize_t in read(), and thus has a 2G size limit. Work around this by falling back to reading one chunk at a time on overflow. This approximately doubles our headroom until we run back into the size limit on single reads.

exchange: pass bundlecaps through to changegroup The bundlecaps passed to exchange.getbundle were being dropped completely. We should pass them on through to the changegroup. This affected the remotefilelog extension, since it relies on those bundlecaps.

bundle2: allow pulling changegroups using bundle2 This changeset refactors the pull code to use a bundle2 when available. We keep bundle2 disabled by default. The current code is not ready for prime time. Ultimately we'll want to unify the API of `bunde10` and `bundle20` to have less different code. But for now, testing the bundle2 exchange flow is an higher priority.

bundle2: add an exchange.getbundle function This function can return a `HG10` or `HG20` bundle. It uses the `bundlecaps` parameters to decides which one to return. This is a distinct function from `changegroup.getbundle` for two reasons. First the APIs of `bundle10` and `bundle20` are not compatible yet. The two functions may be reunited in the future. Second `exchange.getbundle` will grow parameters for all kinds of data (phases, obsmarkers, ...) so it's better to keep the changegroup generation in its own function for now. This function will be used it in the next changesets.

localpeer: propagate bundlecaps in getbundle call Best arguments are the ones in use...

bundle2: make it possible have a global transaction for the unbundling We use the `gettransaction` method approach already used for pull. We need this because we do not know beforehand if the bundle needs a transaction to be created. And (1) we do not want to create a transaction for nothing. (2) Some bundle2 bundles may be read-only and do not require any lock or transaction to be held.

tests: fix test output typo

bundle2: first crude version of bundling changeset with bundle2 The current changegroup format is put in a "changegroup" part and processed by an appropriate handlers. This is not production ready code, but let us start smoke testing.

bundle2: record processing results in the bundleoperation object Part handlers can now add records to the `bundleoperation` object. This can be used to help other parts or to let the caller of the unbundling process react to the results.

bundle2: introduce a bundleoperation object This object will hold all data and state gathered through the processing of a bundle. This will allow: - each handler to be aware of the things unbundled so far - the caller to retrieve data about the execution - bear useful object and logic (like repo, transaction) - bear possible bundle2 reply triggered by the unbundling. For now the object is very simple but it will grow at the same time as the bundle2 implementation.

bundle2: feed a unbundle20 to the `processbundle` function The unbundle can comes from multiple sources. (on disk file, peer, etc) and (ultimately) of multiple type (bundle10, bundle20). The `processbundle` is no longer in charge of creating the bundle.

bundle2: lock the repo during unbundle test We forgot the lock the repo. It's not too bad during tests, but the lock also still carry some transaction logic. (yes we need to get rid of this)

merge: keep destination filename as key in filemerge actions Gives more readable debug output and makes it possible to compare/merge actions later.

merge: keep destination filename as key in actions for merge with dir rename Avoids None: local renamed directory to b/c -> d updating:None 1/1 files (100.00%) and makes it possible to compare/merge actions later.

merge: include ancestor node in merge actions

merge with stable

repoview: use _gethiddenblockers in computehidden No functionality has changed, since we've only extracted the code into its own function. Now extensions can wrap _gethiddenblockers to provide their own blocker without polluting bookmarks or local tags.

repoview: add _gethiddenblockers method This is a standalone function that will provide the ability for extensions to wrap.

repoview: improve performance for computehidden (issue4206) For repos with a large number of heads (including hidden heads), a stale tag cache would cause computehidden to be drastically slower because of a the call to repo.tags() (which would build the tag cache). We actually don't need the tag cache for computehidden because we filter out global tags. This patch replaces the call to repo.tags with readlocaltags so as to avoid the tag cache.

tests: remove unused variables from test-pathencode.py caught by pyflakes

shelve: remove unused variable caught by pyflakes

changegroup: remove unused variable caught by pyflakes

hgk: use hg export to write commits Instead of calling internal command, use hg export to produce changeset diffs compatible with hg import directly.

hgk: add .diff extension when exporting commits Append the .diff extension automatically.

localrepo: move the addchangegroup method in changegroup module This is a gratuitous code move aimed at reducing the localrepo bloatness. The method had few callers, not enough to be kept in local repo.

localrepo: move the addchangegroupfiles method in changegroup module This is a gratuitous code move aimed at reducing the localrepo bloatness. The method had a single caller, far too few for being kept in local repo.

localrepo: move the changegroup method in changegroup module This is a gratuitous code move aimed at reducing the localrepo bloatness. The method had few callers, not enough to be kept in local repo. The peer API stay unchanged.

localrepo: move the getbundle method in changegroup module This is a gratuitous code move aimed at reducing the localrepo bloatness. The method had few callers, not enough to be kept in local repo. The peer API remains unchanged.

store: drop unused existing list

localrepo: move the getlocalbundle method in changegroup module This is a gratuitous code move aimed at reducing the localrepo bloatness. The method had 3 callers total, far too few for being kept in local repo.

localrepo: move the changegroupsubset method in changegroup module This is a gratuitous code move aimed at reducing the localrepo bloatness. The method had few callers, not enough to be kept in local repo. The peer API remains unchanged.

localrepo: move the changegroupinfo method in changegroup module This is a gratuitous code move aimed at reducing the localrepo bloatness. The method had a single caller... already in this changegroup module.

localrepo: move the _changegroupsubset method in changegroup module This is a gratuitous code move aimed at reducing the localrepo bloatness. The method had 3 callers total, far too few for being kept in local repo.

push: pass a `pushoperation` object to localrepo.checkpush The `pushoperation` object contains strictly more data the arguments currently passed to `localrepo.checkpush` we pass the new object instead. This function is used by MQ to abort push that includes MQ changesets. Note: extension that may use this function will have to align.

wireproto: use decorator for the ubundle command

wireproto: use decorator for the stream command

wireproto: use decorator for the pushkey command

wireproto: use decorator for the lookup command

wireproto: use decorator for the listkeys command

wireproto: use decorator for the known command

wireproto: use decorator for the hello command

wireproto: use decorator for the heads command

wireproto: use decorator for the getbundle command

wireproto: use decorator for the debugwireargs command

wireproto: use decorator for the changegroupsubset command

wireproto: use decorator for the changegroup command

wireproto: use decorator for the capabilities command

wireproto: use decorator for the branches command

wireproto: use decorator for the branchmap command

wireproto: use decorator for the between command

wireproto: use decorator for the batch command

wireproto: add decorator for wire protocol command Move move in the same direction we took for command line commands. each wire protocol function will be decorated with its name and arguments. Beside beside easier to read, this open the road to easily adding more metadata (like security level or return type)

wireproto: drop the _decompress method in favor a new call type We already have multiple call function for multiple return type. The `_decompress` function is only used for http and seems like a layer violation. We drop it in favor of a new call type dedicated to "stream that may be useful to compress".

wireproto: document protocol specific function of wirepeer Those function are explicitly declared and documented now.

wireproto: introduce an abstractserverproto class sshserver and webproto now inherit from an abstractserverproto class. This class is introduced for documentation purpose.

wireproto: document possible return type The wireprotocole command use a small set of class as return value. We document the meaning of each of them. AS my knowledge of wire protocol is fairly shallow, the documentation can probably use improvement. But this is a better than nothing.

pull: add a set of steps that remain to be done during the pull With bundle2 we'll slowly move current steps into a single bundle2 building and call (changegroup, phases, obsmarkers, bookmarks). But we need to keep the old methods around for servers that do not support bundle2. So we introduce this set of steps that remains to be done.

pull: put discovery step in its own function The discovery is a full step that will grow to contain more than changesets. We set it in its own function like all other steps.

pull: move the cgresult logic in _pullchangeset Logical follow up of the previous changeset. The `_pullchangeset` is now responsible of setting the `pullop.cgresult`.

pull: move return code in the pull operation object With bundle2 we'll have multiple code path susceptible to be responsible for adding changeset during the pull. We move it to the pull operation to simplify this the coming logic. The one doing the adding the changegroup will set the value.

merge: use ancestor filename from planning phase instead of filectx ancestor test-merge-types.t changes a bit in flag merging. It relied on the implementation detail that 100% identical revlog entries are reused. The revlog reuse did that fctx.ancestor() saw an ancestor where there really not was one.

tests: prevent test-hup from hanging forever if the transaction does not start If the transaction fails to start because of some programing errors, the test would stay stuck in this while loop forever. We now added a basic safeguard that abort the loop if nothing happen in 10 seconds. 10 seconds sounds enough to let the server catch up and open a transaction.

revset: improve roots revset performance Previously we would iterate over every item in the subset, checking if it was in the provided args. This often meant iterating over every rev in the repo. Now we iterate over the args provided, checking if they exist in the subset. On a large repo this brings setting phase boundaries (which use this revset roots(X:: - X::Y)) down from 0.8 seconds to 0.4 seconds. The "roots((tip~100::) - (tip~100::tip))" revset in revsetbenchmarks shows it going from 0.12s to 0.10s, so we should be able to catch regressions here in the future. This actually introduces a regression in 'roots(all())' (0.2s to 0.26s) since we're now using spansets, which are slightly slower to do containment checks on. I believe this trade off is worth it, since it makes the revset O(number of args) instead of O(size of repo).

revset: improve _descendants performance Previously revset._descendants would iterate over the entire subset (which is often the entire repo) and test if each rev was in the descendants list. This is really slow on large repos (3+ seconds). Now we iterate over the descendants and test if they're in the subset. This affects advancing and retracting the phase boundary (3.5 seconds down to 0.8 seconds, which is even faster than it was in 2.9). Also affects commands that move the phase boundary (commit and rebase, presumably). The new revsetbenchmark indicates an improvement from 0.2 to 0.12 seconds. So future revset changes should be able to notice regressions. I removed a bad test. It was recently added and tested '1:: and reverse(all())', which has an amibiguous output direction. Previously it printed in reverse order, because we iterated over the subset (the reverse part). Now it prints in normal order because we iterate over the 1:: . Since the revset itself doesn't imply an order, I removed the test.

revsetbenchmark: remove python 2.7 dependency revsetbenchmark.py used check_output which only exists in python 2.7. This fixes it.

bundle2: read the whole bundle from stream on abort When the bundle processing abort on unknown mandatory parts, we now makes sure all the bundle content is read. This avoid leaving the communication channel in an unrecoverable state.

bundle2: add some distinction between mandatory and advisory part Mandatory part cannot be ignored when unknown. We raise a simple KeyError exception when this happen. This is very early version of this logic, see inline comment for future improvement lead.

bundle2: introduce a `parthandler` decorator Simple syntax sugar to register an handler for a new part type.

bundle2: first version of a bundle processing We now have a function that interpret part content. This is a version early version of this function. It'll see major changes in scope and API in future development. As for previous I'm just focussing on getting minimal logic setup. Refining will happen with real world usage.

bundle2: rename unbundle2 test command to statbundle2 We will introduce object to actually process the bundle, we need to keep the simplistic unbundle around for the test.

bundle2: safely read unpack data from part header We use the same approach that the other unpack, as function is given the struct format and his both responsible for reading the right amount of data from the header and unpack the struct. This give use flexibility if we decide to change the size of something in the format before the release.

transaction: drop extra import caught by pyflakes

fncache: clean up fncache during strips Previously the fncache was cleaned up at read time by noticing when it was out of sync. This caused writes to happen outside the scope of transactions and could have caused race conditions. With this change, we'll keep the fncache up-to-date as we go by removing old entries during repair.strip.

caches: invalidate store caches when lock is taken The fncache was not being properly invalidated each time the lock was taken, so in theory it could contain old data from prior to the caller having the lock. This changes it to be invalidated as soon as the lock is taken (same as all our other caches).

fncache: move fncache writing to be in a transaction Previously the fncache was written at lock.release time. This meant it was not tracked by a transaction, and if an error occurred during the fncache write it would fail to update the fncache, but would not rollback the transaction, resulting in an fncache that was not in sync with the files on disk (which causes verify to fail, and causes streaming clones to not copy all the revlogs). This uses the new transaction backup mechanism to make the fncache transacted. It also moves the fncache from being written at lock.release time, to being written at transaction.close time.

transaction: add support for non-append files This adds support for normal, non-append-only files in transactions. For example, .hg/store/fncache and .hg/store/phaseroots should be written as part of the transaction, but are not append only files. This adds a journal.backupfiles along side the normal journal. This tracks which files have been backed up as part of the transaction. transaction.addbackup() creates a backup of the file (using a hardlink), which is later used to recover in the event of the transaction failing. Using a seperate journal allows the repository to still be used by older versions of Mercurial. A future patch will use this functionality and add tests for it.

transaction: add onclose/onabort hook for pre-close logic Adds an optional onclose parameter to transactions that gets called just before the transaction is committed. This allows things that build up data over the course of the transaction (like the fncache) to commit their data. Also adds onabort. It's not used, but will allow extensions to hook into onclose and onabort to provide transaction support.

clone: put streaming clones in a transaction Streaming clones were writing to files outside of a transaction. Soon the fncache will be written at transaction close time, so we need streaming clones to be in a transaction.

fncache: remove the rewriting logic The fncache could rewrite itself during a read operation if it noticed any entries that were no longer on disk. This was problematic because it caused Mercurial to perform write operations outside the scope of a lock or transaction, which could interefere with any other pending writes. This will be replaced in a future patch by logic that cleans up the fncache as files are deleted during strips.

pull: prevent duplicated entry in `op.pulledsubset` In the bare pull case we could add the same node multiple time to the `pulloperation.pulledsubset`. Beside being a bit wrong this confused the new revset implementation of `revset._revancestor` into giving bad result. This changeset fix the pull operation part. The fix for the revset itself will come in another changeset.

bundle2: part params

bundle2: support for bundling and unbundling payload We add the ability to bundle and unbundle a payload in parts. The payload is the actual binary data of the part. It is used to convey all the applicative data. For now we stick to very simple implementation with all the data fit in single chunk. This open the door to some bundle2 testing usage. This will be improved before bundle2 get used for real. We need to be able to stream the payload in multiple part to exchange any changegroup efficiently. This simple version will do for now. Bundling and unbundling are done in the same changeset because the test for parts is less modular. However, the result is not too complex.

merge with stable

Added signature for changeset 3f83fc5cfe71

Added tag 2.9.2 for changeset 3f83fc5cfe71

backout: correct commit status of no changes made (BC) (issue4190) If backout generated no changes to commit, it showed wrong status, "changeset <target> backs out changeset <target>", and raised TypeError with -v option. This changes the return code to 1, which is the same as "hg commit" and "hg rebase".

backout: document return code of merge conflict

merge with stable

i18n: fix "% inside _()" problems Before this patch, "contrib/check-code.py" can't detect these problems, because the regexp pattern to detect "% inside _()" doesn't suppose the case that format string consists of multiple string components concatenated implicitly or explicitly, This patch does below for that regexp pattern to detect "% inside _()" problems in such case. - put "+" into separator part ("[ \t\n]") for explicit concatenation ("...." + "...." style) - enclose "component and separator" part by "(?:....)+" for concatenation itself ("...." "...." or "...." + "....")

i18n: fix "% inside _()" problems Before this patch, "contrib/check-code.py" can't detect these problems, because the regexp pattern to detect "% inside _()" doesn't suppose the case that the format string and "%" aren't placed in the same line. This patch replaces "\s" in that regexp pattern with "[ \t\n]" to detect "% inside _()" problems in such case. "[\s\n]" can't be used in this purpose, because "\s" is automatically replaced with "[ \t]" by "_preparepats()" and "\s" in "[]" causes nested "[]" unexpectedly.

merge: fix lack of "%s" in format string causing TypeError at runtime

i18n-pt_BR: synchronized with c57c9cece645

i18n-ja: synchronized with e259d4c462b5

bundle2: support unbundling empty part We augment the unbundler to make it able to unbundle the empty part we are now able to bundle.

revset: raise ValueError when calling min or max on empty smartset min([]) raise a ValueError, we do the same thing in smartset.min() and smartset.max() for the sake of consistency. The min/amax test are greatly improved in the process to prevent this familly of regression

revpair: smartset compatibility Since recent revset changes, revrange now return a smartset. This smart set probably does not support indexing (_addset does not). This led to crash. Instead when the smartset is ordered we use the `min` and `max` method of smart set. Otherwise we turn is into a list and use indexing on it. The tests have been updated to catch such regression.

revsetbenchmark: add entry for ::rev:: Revsets of the form ::rev:: were identified as the source behind the regressions in issue 4201. Ensure we have explicit coverage of that revset.

merge with stable This should correct an earlier couple of bad merges (5433856b2558 and 596960a4ad0d, now pruned) that accidentally brought in a change that had been marked obsolete (244ac996a821).

tests: use TESTTMP instead of TESTDIR In 57d0c8c3b947, f042d4b263f4, 1e686e55780c, and 5d22cadd1938, new tests were added that used TESTDIR instead of TESTTMP thereby leading to polluting the working directory with these temporary files. Now, we use TESTTMP so that they will be cleaned up properly.

hg: introduce "wirepeersetupfuncs" to setup wire peer by extensions (issue4109) Since changeset 6f72e7d28b35, "reposetup()" of each extensions is invoked only on repositories enabling corresponded extensions. This causes that largefiles specific interactions between the repository enabling largefiles locally and remote (wire) peer fail, because there is no way to know whether largefiles is enabled on the remote repository behind the wire peer, and largefiles specific "wireproto functions" are not given to any wire peers. To avoid this problem, largefiles should be enabled in wider scope than each repositories (e.g. user-wide "${HOME}/.hgrc"). This patch introduces "wirepeersetupfuncs" to setup wire peer by extensions already enabled. Functions registered into "wirepeersetupfuncs" are invoked for all wire peers. This patch uses plain list instead of "util.hooks" for "wirepeersetupfuncs", because the former allows to control order of function invocation by order of extension enabling: it may be useful for workaround of problems with combination of enabled extensions

templater: raise error for unknown func Previously, if a template '{foo()}' was given, the buildfunc would not be able to match it and hit a code path that would not return so it would error out later in the templater stating that NoneType was not iterable. This patch makes sure that a proper error is raised so that the user can be informed. Tests have been updated.

bundle2: support bundling of empty part (with a type) Here start the work on bundle2 parts. Our first step is to be able to bundle a simplistic part that just have a type, no parameters, empty payload.

revsetbenchmark: add a summary at the end of execution The summary list timing per revset making it much more easier to compare revision to each other.

revsetbenchmark: retrieve the benchmark value in python We retrieve the output of the perf extension and print it ourself. This open the door to processing of this data in the script.

revsetbenchmark: get revision to benchmark in a function And move it to proper subprocess call.

revsetbenchmark: convert revision display to proper subprocesscall

revsetbenchmark: convert performance call to proper subprocess call

revsetbenchmark: convert update to proper subprocess call

revsetbenchmark: fix semicolon

revsetbenchmark: simplify and convert the script to python The script is now in python. That translation is very raw, more improvement to comes: The "current code" and "base" entry have been dropped. This is trivial to get same result using a tagged revision or "." in the list of benchmarked revision.

revsetbenchmapi: fix template The revision description missed an \n

perf: unroll the result in perfrevset With the new lazy revset implementation, we need to actually read all elements to trigger all the computations. Otherwise a no-op if of course much faster than the full work.

_addset: add a __len__ method Back in the time where repo.revs(...) returned a list, calling `len(...)` on the result was quite common. We reinstall this on _addset. There is absolutely no easy way to test this from the command line. The commands using this in the evolve extension will eventually land into core.

bundle2: implement the mandatory/advisory logic for parameter Parameter starting with an upper case are mandatory, the one starting with a lower case are advisory and may be ignored.

bundle2: print debug information during unbundling The unbundler class is now feed with an ui object and use it to transmit data about the unbundling process.

bundle2: print debug information during bundling The bundler class is now feed with an ui object and use it to transmit data about the bundling process.

bundle2: add ability to write to a file to the test Next changesets are about improving debug output during bundling. We won't be able to simply bundle to stdin in this case. The bundle2 stream would be interleaved with debug output.

subrepo: factor out Git version check to add doctests Followup to 6a2acb0d9352::e5641536e4d5.

contrib: add "hgperf" command to measure performance of commands easily Newly added "hgperf" command repeats "dispatch.runcommand()" for specified Mercurial command and measure performance of it in the same manner of "contrib/perf.py" extension. Users (mainly developers) can examine performance of the target command easily, without adding new entry for it to "contrib/perf.py" extension.

grep: exit loop immediately, if matching is found in the file for "hg grep -l" Before this patch, internal function "display()" of "hg grep" is not efficient for "-l"/"--files-with-matches", because loop is continued, even after the first matching is found in the specified file. This patch exits loop immediately, if matching is found for "--files-with-matches". In this case, "before is None" is equal to "opts.get('files_with_matches')".

grep: use "found" instead of "filerevmatches" examination for efficiency Before this patch, internal function "display()" of "hg grep" stores whether matching is already found or not into the dictionary "filerevmatches" by "(fn, rev)" tuple as the key. But this is redundant, because: - "filerevmatches" is local variable of "display()", so each "display()" invocations don't affect others - both "fn" and "rev" (gotten from "ctx" argument) are never changed in each "display()" invocations Then, "filerevmatches" should have only one entry at most, and "(fn, rev) in filerevmatches" should be equal to "found". This patch uses "found" instead of "filerevmatches" examination for efficiency.

grep: reuse the first "util.binary()" result for efficiency Before this patch, to check whether the file in the specified revision is binary or not, "util.binary()" is invoked via internal function "binary()" of "hg grep" once per a line of "hg grep" output, even though binary-ness is not changed in the same file. This patch reuses the first "util.binary()" invocation result by annotating internal function "binary()" with "@util.cachefunc". Performance improvement measured by "hgperf grep -r 88d8e568add1 vfs mercurial/scmutil.py": before this patch: ! wall 0.024000 comb 0.015600 user 0.015600 sys 0.000000 (best of 118) after this patch: ! wall 0.023000 comb 0.015600 user 0.015600 sys 0.000000 (best of 123) Status of recent(88d8e568add1) "mercurial/scmutil.py": # of lines: 919 (may affect cost of search) # of bytes: 29633 (may affect cost of "util.binary()") # of matches: 22 (may affect frequency of "util.binary()")

util: add the code path to "cachefunc()" for the function taking no arguments Before this patch, "util.cachefunc()" caches the value returned by the specified function into dictionary "cache", even if the specified function takes no arguments. In such case, "cache" has at most one entry, and distinction between entries in "cache" is meaningless. This patch adds the code path to "cachefunc()" for the function taking no arguments for efficiency: to store only one cached value, using list "cache" is a little faster than using dictionary "cache".

help: add examples to incoming

revset: fix generatorset race condition If two things were iterating over a generatorset at the same time, they could miss out on the things the other was generating, resulting in incomplete results. This fixes it by making it possible for two things to iterate at once, by always checking the _genlist at the beginning of each iteration. I was only able to repro it with pending changes from my other commits, but they aren't ready yet. So I'm unable to add a test for now.

tests: don't hardcode path to bash interpreter Use the env binary to figure out the correct bash to use. Certain systems ships with an ancient version of bash, but the user might have installed a newer one that is earlier in $PATH. For example the current version of Mac OS X ships version 3.2.51 of bash, which does not understand new fancy builtins such as readarray. A user might install a newer version of bash, use that as their shell and add that path before bin.

contrib: don't hardcode path to bash interpreter Use the env binary to figure out the correct bash to use. Certain systems ships with an ancient version of bash, but the user might have installed a newer one that is earlier in $PATH. For example the current version of Mac OS X ships version 3.2.51 of bash, which does not understand new fancy builtins such as readarray. A user might install a newer version of bash, use that as their shell and add that path before bin.

contrib: explicitly enable perf extension for revset tests If a developer doesn't have the perf extension enabled the revset benchmarking will fail. This patch explicitly enables the perf extension when running the tests.

merge with stable

revset: improve performance of _generatorset.__contains__ (issue 4201) _generatorset.__contains__ and __contains__ from child classes were calling into __iter__ to look for values. Since all previously-encountered values from the generator were cached and checked in __contains__ before this iteration, __contains__ was effectively performing iteration busy work which could lead to an explosion of redundant work. This patch changes __contains__ to be more intelligent. Instead of looking at all values via __iter__, __contains__ will instead go straight to "new" values from the underlying generator. On a clone of the Firefox repository with around 200,000 changesets, this patch decreases the execution time of the revset '::(200067)::' from ~100s to ~4s on the author's machine. Rebase operations (which use the aforementioned revset), speed up accordingly.

localrepo: omit ".hgsubstate" also from "added" files Before this patch, "localrepository.commit()" omits ".hgsubstate" from "modified" (changes[0]) and "removed" (changes[2]) file list before checking subrepositories, but leaves one in "added" (changes[1]) as it is. Then, "localrepository.commit()" adds ".hgsubstate" into "modified" or "removed" list forcibly, according to subrepository statuses. If "added" contains ".hgsubstate", the committed context will contain two ".hgsubstate" in its "files": one from "added" (not omitted one), and another from "modified" or "removed" (newly added one). How many times ".hgsubstate" appears in "files" changes node hash, even though revision content is same, because node hash calculation uses the specified "files" directly (without duplication check or so). This means that node hash of committed revision changes according to existence of ".hgsubstate" in "added" at "localrepository.commit()". ".hgsubstate" is treated as "added", not only in accidental cases, but also in the case of "qpush" for the patch adding ".hgsubstate". This patch omits ".hgsubstate" also from "added" files before checking subrepositories. This patch also omits ".hgsubstate" exclusion in "qnew"/"qrefresh" introduced by changeset d666da075b91, because this patch makes them meaningless. "hg parents --template '{files}\n'" newly added to "test-mq-subrepo.t" enhances checking unexpected multiple appearances of ".hgsubstate" in "files" of created/refreshed MQ revisions.

dispatch: only do __import__(debugger) when a debugger is requested When having ui.debugger=somedebugger in one's ~/.hgrc, this then somedebugger would be imported for every hg command. With this patch, this import only happens if the --debugger parameter is passed.

hg: use "os.path.join()" to join path components which may be empty (issue4203) Changset 2d0ab571b822 rewriting "hg.copystore()" with vfs uses 'dstbase + "/lock"' instead of "os.path.join()", because target files given from "store.copyfiles()" already uses "/" as path separator But in the repository using revlog format 0, "dstbase" becomes empty ("data" directory is located under ".hg" directly), and 'dstbase + "/lock"' is treated as "/lock": in almost all cases, write access to "/lock" causes "permission denied". This patch uses "os.path.join()" to join path components which may be empty in "hg.copystore()".

revset: document the regular expression support for tag(name) This has been supported since 20f55613fb2a, in 2.3.

help: allow -k to find debug commands

help: let 'hg help debug' show the list of secret debug commands The names of the debug commands are not easy to remember and they are not easy to find.

tests: add run-tests --changed option for running tests changed in revisions Convenient when polishing patches and changing details of how they change test output. This will probably break in weird ways for revsets with special quoting ... but it is good enough for run-tests. Usage example: yes | ./run-tests.py -li --changed qparent

repo: rephrase the "missing requirement" error message Unknown requirements will now be reported as: abort: repository requires features unknown to this Mercurial: largefiles! (see http://mercurial.selenic.com/wiki/MissingRequirement for more information) Some features of this phrasing: * avoid double ':' in abort message * make it more clear who requires and knows what * don't quote the requirement names - it is not something the user entered or need the exact spelling of ... and it is "identifiers" that are unambiguous anyway * remove double hint by removing "(upgrade Mercurial)" comment * don't mention upgrading Mercurial without mentioning enabling the feature - instead, just refer to wiki page for both * don't just talk about "details", talk about "more information"

revpair: drop useless conditional The `if not revs:` case is tested at the beginning of the function.

merge with stable

subrepo: add trailing newlines to warnings

subrepo: convert matched string to integer before comparing Git version (1, '4') is greater than (1, 5) so the version check never actually worked.

subrepo: only retrieve the first two components of the Git version This makes the version detection compatible with Git versions like '1.9-rc0'. We only cared about the first two components of the version anyway.

bundle2: force the first char of parameter to be an letter. We need a case sensitive character to convey mandatory/advisory parameter semantic in a later patches.

bundle2: refuse empty parameter name The bundle2 now raise value error when seeing invalid parameter names. The first introduced rules is: no empty parameter. The test extension is improve to properly abort when ValueError are encountered.

bundle2: urlunquote stream parameter name and value during unbundling Align to new escaping used during bundling.

bundle2: urlquote stream parameter name and value This introduces support for arbitrary characters in stream parameters name and value. The urlquote format has been chosen because it is: - simple, - standard, - no-op on simple alphanumerical entry.

bundle2: support for unbundling parameter value The unbundler now understand parameter value. introduced in the previous changeset.

bundle2: support for bundling parameter value Parameter can now have a value. We use a `<name>=<value>` form inspired from capabilities. There is still no kind of escaping in the name or value, yet.

bundle2: clarify stream parameter design in the documentation Stream level parameter have very restricted use case. Clarify why we chosen a textual format and point that applicative data goes in applicative parts.

repoview: add non-global tags to candidate list for blocking hidden changesets Previously, only bookmarks would be considered for blocking a changeset from being hidden. Now, we also consider non-global tags. This is helpful if we have local tags that might be hard to find once they are hidden, or tag that are added by extensions (e.g. hggit or remotebranches).

histedit: select the lowest rev when looking for a root in a revset (bc) When we specify a revision or a revset we just get the last element from the list. For revsets this can lead to unintended effects where you specify a revset like only() but instead histedit selects the highest revision in the set as root. Therefore we should always use the lowest revision number as root.

bundle2: support for unbundling simple parameter the unbundler now understand simple list of parameter.

bundle2: support bundling simple parameter This changeset add bundling capacity for simple parameters, not value or any special case are handled.

bundle2: make sure the unbundler refuse non bundle2 stream We now make use of the magic string at the beginning of the file.

bundle2: a very first version of bundle2 unbundler This changeset introduce an unbundler class to match the bundle2 bundler. It is currently able to unbundle an empty bundle2 only and will gain more feature at the same pace than the bundler. It also comes with its special extension command in test.

bundle2: very first version of a bundle2 bundler This changeset is the very first of a long series. It create a new bundle2 module and add a simple class that generate and empty bundle2 container. The module is documented with the current state of the implementation. For information about the final goal you may want to consult the mercurial wiki page: http://mercurial.selenic.com/wiki/BundleFormat2 The documentation of the module will be updated with later patches adding more and more feature to the format. This patches also introduce a test case. This test case build and use its own small extension that use the new bundle2 module. Since the new format is unable to do anything right now, we could not use real mercurial code to test it. Moreover, some advanced feature of the bundle2 spec will not be used by core mercurial at all. So we need to have them tested.

clone: abort if default destination has no meaningful name (BC) If source URL has no path, default destination is resolved as '.'. It is surprising than useful, and perhaps an unexpected behavior. This change does not solve issue3880, but can avoid to clone into current directory by accident.

clone: add doctest for default destination

scmutil: fix revrange when multiple revs are specified revrange was trying to add a list to a revset class, but revset classes only support adding with other revset classes. So wrap the lists in basesets.

parsers: fix compiler errors on MSVC 2008 This broke in 3681de20b0a7.

check-code: check for argument passing py2.6ism

merge with stable

sshpeer: only print out 'running ssh' messages in debug mode (BC) Previously, if another command was run with --verbose, and for whatever reason that invoked sshpeer, we'd get a 'running ssh' message from sshpeer. This extra line would interfere with that command's output and cause dumb parsers to break. For example, hg annotate can be run with --verbose to get full usernames. This, combined with the third-party remotefilelog extension which can cause ssh connections to be created, leads to an extra 'running ssh' line that breaks most parsers. This patch is (BC) because hg pull --verbose will no longer print out exactly what ssh command it is running. No tests are affected by this change.

tests: small refactoring of run-tests' handling of tests list

merge: mark mergestate as dirty when resolve changes _state Correctness - no visible difference so far.

backout: improve confusing 'cannot backout change on a different branch' abort These days 'branch' usually refer to a named branch. Instead, abort with 'cannot backout change that not is an ancestor'.

config: set a 'source' in most cases where config don't come from file but code Some extensions set configuration settings that showed up in 'hg showconfig --debug' with 'none' as source. That was confusing. Instead, they will now tell which extension they come from. This change tries to be consistent and specify a source everywhere - also where it perhaps is less relevant.

config: don't set source when no source is specified - don't overwrite with '' This prevents ui.fixconfig from overwriting the source of paths and it will thus show up in showconfig --debug.

config: give a useful hint of source for the most common command line settings 'hg showconfig --debug' will instead of: none: ui.verbose=False give the better hint: --verbose: ui.verbose=False

config: backout 77f1f206e135 - 743daa601445 removed the only use of overlay

mq: omit ".hgsubstate" from qnew/qrefresh target list for consistent node hash Before this patch, even if specified file patterns and -I/-X options cause listing ".hgsubstate" up in the target list, qnew/qrefresh put ".hgsubstate" into the target list individually and forcibly. This changes how many times ".hgsubstate" appear in the target list according to run-time conditions, and causes inconsistent node hash, even though revision content is same, because node hash calculation uses the specified target list directly (without duplication check or so). This patch always omits ".hgsubstate" from qnew/qrefresh target list for consistent node hash. This omitting doesn't miss including ".hgsubstate" changes, because: - "localrepository.commit()" puts ".hgsubstate" into the target list for "commitctx()" forcibly if needed - "mq.putsubstate2changes()" puts ".hgsubstate" into the target list for "patch.diff()" if it is not yet listed up

qnew: omit meaningless and harmful putting subrepositories into target list Before this patch, qnew puts updated subrepositories into target list forcibly, if any of -I, -X or patterns are specified. But this is meaningless and harmful, because: - putting subrepositories into target list doesn't affect the result of "localrepository.status()" "dirstate.status()" invoked via "localrepository.status()" always omits subrepositories from the result of it - any -I/-X opts and empty "pats" causes unexpected failure when any -I/-X opts are specified, "inclsubs" are always added to "pats", even if "pats" is empty. but this changes meaning of "pats" from "including all to be included" to "including only listed subrepositories" this may exclude ".hgsub" and cause unexpected exception raising ("can't commit subrepos without .hgsub" ). - qnew at other than repository root (with -I, -X or any patterns) causes unexpected failure "scmutil.match()" treats pattern without syntax type as 'relpath' type (= one rooted at cwd). but qnew puts subrepository paths rooted at the repository root, and it causes unexpected exception raising ("SUBREPO not under root ROOT" in "pathutil.canonpath()"), if "hg qnew" is executed at other than repository root with -I, -X or any patterns. This patch omits meaningless and harmful putting subrepositories into target list. This omitting doesn't miss including updated subrepositories, because subrepositories are specified to "scmutil.matchfiles()" directly, to get "match" object for "localrepository.commit()".

convert: more clear documentation of the 'include' default of a 'include .' At first glance it can be confusing that adding a superfluous include directive will exclude more files.

config: mention edit options and config topic in help

config: add --global and --local flags These start an editor on the system-wide or repository-level config files.

revrange: pass repo to revset parser This allows handling of hyphenated symbols for command-line revsets.

revset: try to handle hyphenated symbols if lookup callback is available Formerly an expression like "2.4-rc::" was tokenized as 2.4|-|rc|::. This allows dashes in symbols iff the whole symbol-like string can be looked up. Otherwise, it's tokenized as a series of symbols and operators. No attempt is made to accept dashed symbols inside larger symbol-like string, for instance foo-bar or bar-baz inside foo-bar-baz.

revset: pass a lookup function to the tokenizer

parser: allow passing a lookup function to a tokenizer This will allow us to dynamically handle hyphenated symbols in revsets.

benchmark-revset: add full version of benchmarked revset All revsets added to benchmark so far are aimed to show an improvement of performance from laziness. We had more wider version to track impact of laziness on them.

localrepo: rename capability set to lower case. This is not C and they are not even constant.

wireproto: move wireproto capabilities computation in a subfunction It will help people that need to add capabilities (in a more subtle was that just adding some to the list) in multiple way: 1. This function returns a list, not a string. Making it easier to look at, extend or alter the content. 2. The original capabilities function will be store in the dictionary of wire protocol command. So extension that wrap this function also need to update the dictionary entry. Both wrapping and update of the dictionary entry are needed because the `hello` wire protocol use the function itself. This is specifically sneaky for extension writer as ssh use the `hello` command while http use the `capabilities` command. With this new `_capabilities` function there is one and only one obvious place to wrap when needed.

wireproto: extract capabilities list in outside the wireproto function Before that it was over complicated to add capabilities from an extension. This mimic was is done for capabilities in localrepo.

merge with stable

commit: propagate --secret option to subrepos (issue4182) Before this patch, `hg commit --secret` was not getting propagated correctly, and subrepos were not getting the commit in the secret phase. The problem is that subrepos get their ui from the base repo's baseui object and ignore the ui object passed on to them. This sets and restores both ui objects with the appropriate option.

amend: save commit message into ".hg/last-message.txt" Before this patch, commit message (may be manually edited) for "commit --amend" is never saved into ".hg/last-message.txt", because it uses "localrepository.commitctx()" instead of "localrepository.commit()": saving into ".hg/last-message.txt" is executed only in the latter. This patch saves commit message for "commit --amend" into ".hg/last-message.txt" just after user editing. This is the simplest implementation to fix on stable. Editing and saving commit message for memctx should be centralized into the framework like "localrepository.commit()" with "editor" argument or so in the future.

histedit: save manually edited commit message into ".hg/last-message.txt" Before this patch, manually edited commit message for "fold" command in histedit-ing is never saved into ".hg/last-message.txt", because it uses "localrepository.commitctx()" instead of "localrepository.commit()": saving into ".hg/last-message.txt" is executed only in the latter. This patch saves manually edited commit message for "fold" command in histedit-ing into ".hg/last-message.txt" just after user editing. This is the simplest implementation to fix on stable. Editing and saving commit message for memctx should be centralized into the framework like "localrepository.commit()" with "editor" argument or so in the future.

qfold: save manually edited commit message into ".hg/last-message.txt" Before this patch, manually edited commit message for "hg qfold -e" isn't saved into ".hg/last-message.txt" until it is saved by "localrepository.savecommitmessage()" in "localrepository.commit()". This may lose such commit message, if unexpected exception is raised. This patch saves manually edited commit message for "hg qfold -e" into ".hg/last-message.txt" just after user editing. This patch doesn't save the message specified by -m/-l options as same as other commands. This is the simplest implementation to fix on stable. Editing and saving commit message should be centralized into the framework of "localrepository.commit()" with "editor" argument in the future. This patch uses repository wrapping class for exception raising before saving commit message in "localrepository.commit()" easily and certainly, because such exception requires corner case condition.

qnew: save manually edited commit message into ".hg/last-message.txt" Before this patch, manually edited commit message for "hg qnew -e" isn't saved into ".hg/last-message.txt" until it is saved by "localrepository.savecommitmessage()" in "localrepository.commit()". This may lose such commit message, if unexpected exception is raised. This patch saves manually edited commit message for "hg qnew -e" into ".hg/last-message.txt" just after user editing. This patch doesn't save the message specified by -m/-l options as same as other commands. This is the simplest implementation to fix on stable. Editing and saving commit message should be centralized into the framework of "localrepository.commit()" with "editor" argument in the future. This patch uses repository wrapping class for exception raising before saving commit message in "localrepository.commit()" easily and certainly, because such exception requires corner case condition.

tag: save manually edited commit message into ".hg/last-message.txt" Before this patch, manually edited commit message for "hg tag -e" isn't saved into ".hg/last-message.txt" until it is saved by "localrepository.savecommitmessage()" in "localrepository.commit()". This may lose such commit message, if unexpected exception is raised. This patch saves manually edited commit message for "hg tag -e" into ".hg/last-message.txt" just after user editing. This patch doesn't save the message specified by -m option (-l is not supported for "hg tag") as same as other commands. This is the simplest implementation to fix on stable. Editing and saving commit message should be centralized into the framework of "localrepository.commit()" with "editor" argument in the future.

rebase: use "commitforceeditor" instead of "ui.edit()" for "--collapse" Before this patch, "rebase --collapse --edit" without "--message" and "--logfile" invokes editor twice unexpectedly: 1. explicit "ui.edit()" invocation in rebase extension itself 2. indirect invocation in "localrepository.commit()" with "editor = commitforceeditor" assigned by "--edit" option This patch uses indirect "commitforceeditor" invocation instead of "ui.edit()" for "--collapse" without "--message" and "--logfile" to: - suppress redundant the former invocation - ensure editor invocation even when "--edit" is not specified

localrepo: save manually edited commit message as soon as possible Before this patch, "localrepository.commit()" invokes specified "editor" to edit commit message manually, and saves it after checking sub-repositories. This may lose manually edited commit message, if unexpected exception is raised while checking (or commiting recursively) sub-repositories. This patch saves manually edited commit message as soon as possible.

hgk: enable selected patch text on Windows Port a patch from gitk. Original description: On windows, mouse input follows the keyboard focus, so to allow selecting text from the patch canvas we must not shift focus back to the top level. This change has no negative impact on X, so we don't explicitly test for Win32 on this change. This provides similar selection capability as already available using X-Windows. Signed-off-by: Mark Levedahl <mdl123@verizon.net> Signed-off-by: Paul Mackerras <paulus@samba.org>

hgk: ignore ctrl-z as EOF on windows Port a patch from gitk. Original description: Cygwin's Tcl is configured to honor any occurence of ctrl-z as an end-of-file marker, while some commits in the git repository and possibly elsewhere include that character in the commit comment. This causes gitk ignore commit history following such a comment and incorrect graphs. This change affects only Windows as Tcl on other platforms already has eofchar == {}. This fixes problems noted by me and by Ray Lehtiniemi, and the fix was suggested by Shawn Pierce. Signed-off-by: Mark Levedahl <mdl123@verizon.net> Signed-off-by: Paul Mackerras <paulus@samba.org>

graphmod: changed code in dagwalker to use lazy implementations Used lazy methods when possible.

webcommands: changed code to use lazy classes when calling dagwalker This needs to be changed to use a baseset since dagwalker now expects to receive a smartset. This is basically wrapping revs into a baseset to be compatible with smartset implementations.

cmdutil: changed max method for lazy call Used the lazy max call instead of the python max implementation to be able to use lazysets for graphlog.

getgraphlogrevs: return an empty baseset instead of a empty list We aims at returning smartset only so that function higher in the stack can use smartset feature.

getgraphlogrevs: do not convert smartset to baseset We are now sure that revs is a smartset. We remove the baseset call that would defeat any lazyness.

cmdutil: changed revset for spanset Instead of using baseset(repo.changelog) changed it for spanset(repo) which is much faster.

cmdutil: changed code in _makegraphlogrevset not to use getitem __getitem__ is a method that is not implemented lazily on many of the new classes and it can be easily replaced with a structure that takes advantage of the new lazy implementations instead.

cmdutil: changed code in getgraphlogrevs not to use getitem __getitem__ is a method that is not implemented lazily on many of the new classes and it can be easily replaced with a structure that takes advantage of the new lazy implementations instead.

revset: changed minrev and maxrev implementations to use ordered sets Performance Benchmarking: 0) max(tip:0) 1) min(0:tip) 2) min(0::) b96cb15ec9e0 (2.9.1 release) 0) ! wall 0.005699 comb 0.000000 user 0.000000 sys 0.000000 (best of 450) 1) ! wall 0.005414 comb 0.010000 user 0.010000 sys 0.000000 (best of 493) 2) ! wall 0.025951 comb 0.030000 user 0.030000 sys 0.000000 (best of 107) 05267e6e94dd (public tip at submission time) 0) ! wall 0.015177 comb 0.020000 user 0.020000 sys 0.000000 (best of 175) 1) ! wall 0.014779 comb 0.010000 user 0.010000 sys 0.000000 (best of 189) 2) ! wall 12.345179 comb 12.350000 user 12.350000 sys 0.000000 (best of 3) Current patches: 0) ! wall 0.001911 comb 0.000000 user 0.000000 sys 0.000000 (best of 1357) 1) ! wall 0.001943 comb 0.010000 user 0.010000 sys 0.000000 (best of 1406) 2) ! wall 0.000405 comb 0.000000 user 0.000000 sys 0.000000 (best of 6761)

revset: changed addset to extend _orderedsetmixin Now _addset can use the lazy min and max implementation.

revset: add a default argument for baseset.__init__ We are now able to create empty baseset using `baseset()` as we are able to create empty list with `list()`.

revset: changed orderedlazyset to also extend _orderedsetmixin Now orderedlazyset can use the lazy min and max implementation.