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.