rebase: do not try to reactivate deleted divergent bookmark If the currently active bookmark is divergent one, it may be resolved during rebase. Trying to activate it will raise "KeyError: 'W@diverge'".

tests: backout 00f2d29308db pid check

revset: changed spanset implementation to take hidden revisions into account Hidden revisions are now excluded from the spanset. Now this doesn't break for people using changeset evolution.

template: add 'current' to scope during {bookmarks % ...} This adds the keyword 'current' to the template scope when processing a bookmark list. The 'current' keyword resolves to the name of the currently active bookmark in the repo. This allows us to apply special labels to the current bookmark to distinguish it (especially in the case where there are multiple bookmarks on the same commit). Example: "{bookmarks % '{bookmark}{ifeq(bookmark, current, \"*\")} '}" Results in a space separated list of bookmarks where the current bookmark has an asterix.

template: add revset() template function Adds a template function that executes a revset and returns the list of revisions as the result. It has the signature 'revset(query [, args...])'. The args are optional and are applied to the query string using the standard python string.format(args) pattern. This allows things like: '{revset("parents({0})", rev)}' to produce the parents of each individual commit in the log output. If no args are specified, the revset result is cached for the duration of the templater; so it's better to not use args if performance is a concern. By itself, revset() can be used to print commit parents, print the common ancestor of a commit with the main branch, etc. It can be used with the ifcontains() function to do things like '{ifcontains(rev, revset('.'), label(...), ...)}' to color the working copy parent, to color certain branches, to color draft commits, etc.

template: add ifcontains template function Adds a template function with the signature 'ifcontains(item, set, then[, else])'. It can be used to do things like '{ifcontains('.hgignore', file_mods, label(...), ...)}' to color commits that edit the .hgignore file. A future patch will add the revset() function which will combine with ifcontains to allow us to color commits if they are in the revset.

createmarkers: allow to pass metadata for a marker only The `metadata` argument only allow to specify metadata for all new markers. We extension the format of the `relations` argument to support optional metadata argument. The first user of this should be the evolve extension who want to store parent information of pruned changeset in extra (until we make a second version of the format)

obsstore: update create docstring to point to the coder friendly function The `obsstore` class have a `create` method that create new obsolescence marker from node. There is another function in the same module `createmarkers`. This other function is higher level and automatically missing meta data (ultimately calling the first one) We add a new comment in the docstring of `obsstore.create` highlighting that people writing new code probably want to use the top level one.

i18n: check equality of initial indentation between msgid and msgstr Document generation by runrst in "doc" directory may succeed silently, even though initial indentation is different between msgid and msgstr: for example, it may be unexpected or missing indentation. This patch adds the checker to check equality of initial indentation between msgid and msgstr. This checker is categorized as "warning" level, because problem detected by this is not so serious for usual Mercurial usage.

i18n: check equality of tail '::'-ness between msgid and msgstr Document generation by runrst in "doc" directory may succeed silently, even though there is the translated message missing tail '::'. In this case, it uses "<blockquote>" instead of "<pre>" to surround succeeding text block unexpectedly in generated HTML file. This patch adds the checker to check equality of tail '::'-ness between msgid and msgstr. To detect also msgstr unexpectedly ending with '::', this checker doesn't have matching regexp against msgid, and is applied on all msgid/msgstr pairs. This checker is categorized as "warning" level, because problem detected by this is not so serious for usual Mercurial usage.

run-tests: fix heredoctest for out-of-tree extensions heredoctest.py directory must be in python path to use heredoctest (>>>) in out-of-tree extension tests like: $ cd ext/tests $ python /some/hg/install/tests/run-tests.py test-ext.t

revset: added cache to lazysets This allows __contains__ to return faster when asked for same value twice.

histedit: shorten new fold message Lots of people, like Mr. Check-Code, insist on using 80-column terminals.

run-tests: unnecessary globs also count as warnings When a glob is unnecessary, now there's a diff output and 'run-tests.py -i' works for accepting the output. On windows, some tests which have "passed" currently (with some info lines printed) will now be reported as "warned". (I recommend to recognize "warned" by buildbot before applying this patch.)

run-tests: report a test as warned when only missing globs On windows, some test reported as failed will now be reported as "warned".

run-tests: add possibility for test-runners to report a "warned" test result A test result is recognized as "warned" when the test runner returns the exit code False. (False is similar to 0, which is reporting a command has run sucessfully.) The only difference in display is that the failure message while running writes "Warning:" instead of "ERROR:". The diff output is the same as when the test fails. Runing "run-tests.py -i" asks to accept the changed result also for tests reported as "warned". When running tests, a "warned" test would look like this: .. --- xxxx\tests\test-something.t +++ xxxx\tests\test-something.t.err @@ -1279,7 +1279,7 @@ $ echo anything $ hg commit -S -m whatever committing subrepository s - committing subrepository s/sbs + committing subrepository s/sbs (glob) warning: something happened committing subrepository t $ echo something Warning: xxxx\tests\test-sOMETHING.t output changed ~.s...s...s.. Reporting a test result as "warned" will be used in following patches.

run-tests: separate exit code when no failed tests but warned ones This can be used by buildbot to set the result "warnings" instead of "failed".

run-tests: introduce 'warned' as test result While running, a test resulting in 'warned' is shown as '~'. Test results with state warned are listed between the skipped and the failed tests. Example: Skipped test-revert-flags.t: missing feature: executable bit Skipped test-inotify-lookup.t: missing feature: inotify extension support Warned test-something.t: output changed Failed test-largefiles.t: output changed Failed test-subrepo.t: output changed # Ran 11 tests, 2 skipped, 1 warned, 2 failed. The test result "warned" will be used in later patches.

run-tests: handle sys.exit in main function

run-tests: remove unnecessary variable initialisation ret is always set before it is used, so remove ret = 0

histedit: clarify description of fold command N and (N-1) didn't add any information to description of fold. More useful is refering to the commit list as it is displayed in editor.

discovery: make "note: unsynced remote changes!" less serious than a warning This situation is not necessarily a problem and do not deserve a warning. It is just some information that can guide the user in understanding what is going on. Making it 'debug' would usually not give the hint when it is relevant so we make it a 'status' message.

discovery: improve "note: unsynced remote changes!" warning This message frequently caused confusion. "unsynced" is not a well established user-facing concept in Mercurial and the message was not very specific or helpful. Instead, show a message like: remote has heads on branch 'default' that are not known locally: 6c0482d977a3 This message will also (when relevant) be shown before aborting on "push creates new remote head". A similar (but actually very different) message was addressed in 6b618aa08b6e.

import: move tryone closure in cmdutil We extract the `tryone` function into the `cmdutil` module. A lot of the command context have to be passed to the utility function, but having and explicit declaration will allow extension to wrap it. This will allows use to make changeset evolution related experiment in dedicated extension. Improving the API of this function is noble goal but outside of the scope of this patches.

revset: optimize missing ancestor expressions A missing ancestor expression is any expression of the form (::x - ::y) or equivalent. Such expressions are remarkably common, and so far have involved multiple walks down the DAG, followed by a set difference operation. With this patch, such expressions will be transformed into uses of the fast algorithm at ancestor.missingancestor. For a repository with over 600,000 revisions, perfrevset for '::tip - ::-10000' returns: Before: ! wall 3.999575 comb 4.000000 user 3.910000 sys 0.090000 (best of 3) After: ! wall 0.132423 comb 0.130000 user 0.130000 sys 0.000000 (best of 75)

revset: add an undocumented _missingancestors function This will be used in an upcoming patch to optimize expressions of the form (::x - ::y).

commands.debugrevspec: add an option to print the optimized expression tree This will be used in an upcoming patch to test that the optimizer works.

tests: killdaemons.py for windows distinguishes access violation and terminated To distinguish between access violaition (process belonging to another user) and a terminated process, PROCESS_QUERY_INFORMATION must be enabled. But TerminateProcess still raises error 5 in both cases. Therefore check before if the process has already terminated.

tests: killdaemons.py for checks reason when getting no process handle

tests: killdaemons.py for windows waits for killed process to terminate After kill, wait for the process to terminate. When it does not in time, write a debug message similar as in other os. But no 2nd forceful attempt is done.

tests: kill for windows in killdaemons.py checks return values The return values of the windll calls are checked and when an error is indicated, it is raised. The handle is still closed properly.

merge with crew

merge with stable

help: new SHA-1 fingerprint of hg.intevation.org in hostfingerprints example The certificate was updated in February 2014. You can verify the certificate by using the Root CA certificate downloadable from https://ssl.intevation.de/ The intermediate CA is sent by https://hg.intevation.org/

pull: move changeset pulling in its own function pull: move changeset pulling in its own function Now that every necessary information is held in the `pulloperation` object, we can finally extract the changeset pulling to it's own function. This changeset is pure code movement only.

pull: move `fetch` subset into the object Tree discovey use a `fetch` variable to know what is being pulled. We move this information in the `pulloperation` object. This make it possible to extract the changeset pulling logic into its own function.

pull: make pulled subset a propertycache of the pull object The computation of the subset is simple operation using two useful pull information (1) the set of common changeset before the pull (2) the set of pulled changeset. We move this data into the `pulloperation` object since some phase will need them. And we turn the pulled subset computation behind a property case as multiple pull phase will need it.

pull: move phases synchronisation in its own function Now that every necessary information is held in the `pulloperation` object, we can finally extract the phase synchronisation phase to it's own function. This changeset is pure code movement only.

pull: move pulled subset into the object We compute the set of local changeset that were target of the pull. This is then used by phases logic to decide which part of the history should have it phase updated. We move this information into the object to allow extraction of phase synchronisation in its own function. I expect obsolete marker exchange to use it too in the future.

revset: added operations to spanset to duck type baseset Added more operations which are not lazy but only used so far to duck type baseset.

revset: added basic operations to spanset Added methods __add__, __sub__ and __and__ to duck type more methods in baseset

revset: added spanset class to represent revision ranges

revset: added lazyset implementation to extra revset

revset: added lazyset implementation to converted revset

revset: added lazyset implementation to closed revset

push: feed pulloperation object to _pullobsolete function We now have all necessary information in the `pulloperation` object itself.

pull: move transaction logic into the pull object Most local change that occurs during a pull are doing within a `transaction`. Currently this mean (1) adding new changeset (2) adding obsolescence markers. We want the two operations to be done in the same transaction. However we do not want to create a transaction if nothing is added to the repo. Creating an empty transaction would drop the previous transaction data and confuse tool and people who are still using rollback. So the current pull code has some logic to create and handle this transaction on demand. We are moving this logic in to the `pulloperation` object itself to simplify this lazy creation logic through all different par of the push. Note that, in the future, other part of pull (phases, bookmark) will probably want to be part of the transaction too.

pull: move obsolescence marker exchange in the exchange module The obsolescence marker exchange code was already extracted during a previous cycle. We are moving the extracted functio in this module. This function will read and write data in the `pulloperation` object and I prefer to have all core function collaborating through this object in the same place. This changeset is pure code movement only. Code change for direct consumption of the `pulloperation` object will come later.

pull: move `force` argument into pull object One more step toward a more modular pulh function.

pull: move `heads` argument into pull object One more step toward a more modular pull function.

pull: move `remote` argument into pull object One more step toward a more modular pull function.

pull: introduce a pulloperation object This object will hold all data and state gathered through the pull. This will allow us to split the long function into multiple small one. Smaller function will be easier to maintains and wrap. The idea is to blindly store all information related to the pull in this object so that each step and extension can use them if necessary. We start by putting the `repo` variable in the object. More migration in other function.

tests: lines with largefile .* file://$TESTTMP also match on windows on windows, largefile paths are written as "file:///C:/temp/...", corresponding to "file:///$TESTTMP/..." (all three slashes shown). But on posix systems they are written as "file:///tmp/..." corresponding to "file://$TESTTMP/..." (only two slashes shown). Write the glob "file:/*/" to match both versions.

debugobsolete: extract marker display in a dedicated function We want to be able to reuse and extend it from other function or extension while working on markers exchange. This changeset is pure core movement.

exchange: extract pull function from localrepo The localrepo class if far too big. Push and pull logic are extracted and reworked to better fit with the fact we exchange more than bundle now. This changeset extract the pulh code. later changeset will slowly slice it into smaller brick. The localrepo.pull method is kept for now to limit impact on user code. But it will be ultimately removed, now that the public API is hold by peer.

push: extract new common set computation from phase synchronisation Now that every necessary information is held in the `pushoperation` object, we can extract the new common set computation to it's own function. This changeset is pure code movement only.

push: move `commonheads` into the push object The phase synchronisation start by computing the new set of common head between local and remote and then do the phase synchronisation on this set. This new common set logic will eventually be used by the obsolescence markers exchange. So we are going to split the long phase synchronisation in two.

push: move discovery in its own function Now that every necessary information is held in the `pushoperation` object, we can extract the discovery logic to it's own function. This changeset is pure code movement only.

push: move outgoing check logic in its own function Now that every necessary information is held in the `pushoperation` object, we can extract the part responsible of aborting the push to it's own function. This changeset is mostly pure code movement. the exception is the fact this function returns a value to decide if changeset bundle should be pushed.

push: move `incoming` into the push object The fact that there is some unknown changes on remote one of the result of discovery. It is then used by some push validation logic. We move it in the object to be able to extract the said logic.

push: move changeset push logic in its own function Now that every necessary information is held in the `pushoperation` object, we can extract the logic pushing changeset to it's own function. This changeset is pure code movement only.

push: move `remoteheads` into the push object The heads of the remote repository are used to detect race when pushing changeset. We now store this information in `pushoperation` object to allow extraction of the changeset pushing part.

revset: added lazyset implementation to contains revset

revset: added lazyset implementation to secret revset

revset: added lazyset implementation to matching revset Performance Benchmarking: $ time hg log -qr "first(matching(0))" 0:9117c6561b0b real 0m2.213s user 0m2.149s sys 0m0.055s $ time ./hg log -qr "first(matching(0))" 0:9117c6561b0b real 0m0.177s user 0m0.137s sys 0m0.038s

revset: added lazyset implementation to _matchfiles Performance Benchmarking: $ time hg log -qr "first(file(README))" 0:9117c6561b0b real 0m2.234s user 0m2.180s sys 0m0.044s $ time ./hg log -qr "first(file(README))" 0:9117c6561b0b real 0m0.172s user 0m0.129s sys 0m0.042s

revset: added lazyset implementation to checkstatus This improves the performance of the revsets 'adds' 'modifies' and 'removes' Performance benchmarking: $ time hg log -qr "first(adds(README))" 0:9117c6561b0b real 0m2.279s user 0m2.222s sys 0m0.053s $ time ./hg log -qr "first(adds(README))" 0:9117c6561b0b real 0m0.172s user 0m0.131s sys 0m0.041s $ time hg log -qr "first(modifies(README))" 1:273ce12ad8f1 real 0m2.292s user 0m2.227s sys 0m0.061s $ time ./hg log -qr "first(modifies(README))" 1:273ce12ad8f1 real 0m0.178s user 0m0.130s sys 0m0.038s $ time hg log -qr "first(removes(README))" 2379:e90cff87f871 real 0m2.297s user 0m2.235s sys 0m0.058s $ time ./hg log -qr "first(removes(README))" 2379:e90cff87f871 real 0m0.975s user 0m0.797s sys 0m0.056s

revset: added lazyset implementation to public revset Performance Benchmarking: $ time hg log -qr "first(public())" ... real 0m1.184s user 0m1.051s sys 0m0.130s $ time ./hg log -qr "first(public())" ... real 0m0.548s user 0m0.427s sys 0m0.118s

color: add debugcolor command (issue4094) This patch adds a debugcolor command that prints all colors that the extension knows about.

revset: added lazyset implementation to merge revset Performance benchmarking: $ time hg log -qr "first(merge())" 102:58039eddbdda real 0m0.276s user 0m0.208s sys 0m0.047s $ time ./hg log -qr "first(merge())" 102:58039eddbdda real 0m0.192s user 0m0.154s sys 0m0.027s

revset: added lazyset implementation to grep revset Performance benchmarking: $ time hg log -qr "first(grep(hg))" 0:9117c6561b0b real 0m2.214s user 0m2.163s sys 0m0.045s $ time ./hg log -qr "first(grep(hg))" 0:9117c6561b0b real 0m0.211s user 0m0.146s sys 0m0.035s

revset: added lazyset implementation to desc revset Performance benchmarking: $ time hg log -qr "first(desc(hg))" changeset: 0:9117c6561b0b real 0m2.210s user 0m2.158s sys 0m0.049s $ time ./hg log -qr "first(desc(hg))" changeset: 0:9117c6561b0b real 0m0.171s user 0m0.131s sys 0m0.035s

revset: added lazyset implementation to draft revset

revset: added lazyset implementation bookmark revset

revset: added lazyset implementation to date revset Performance Benchmarking: $ time hg log -qr "first(date(05/03/2005))" 0:9117c6561b0b real 0m3.157s user 0m2.994s sys 0m0.087s $ time ./hg log -qr "first(date(05/03/2005))" 0:9117c6561b0b real 0m0.509s user 0m0.289s sys 0m0.070s

revset: added lazyset implementation to author revset Performance benchmarking: $ time hg log -qr "first(author(mpm))" 0:9117c6561b0b real 0m3.486s user 0m3.317s sys 0m0.077s $ time ./hg log -qr "first(author(mpm))" 0:9117c6561b0b real 0m0.551s user 0m0.295s sys 0m0.072s

revset: added lazyset implementation to keyword revset Performance benchmarking: $ time hg log -qr "first(keyword(changeset))" 0:9117c6561b0b real 0m3.466s user 0m3.345s sys 0m0.072s $ time ./hg log -qr "first(keyword(changeset))" 0:9117c6561b0b real 0m0.365s user 0m0.199s sys 0m0.083s

revset: changed limit revset implementation to work with lazy revsets Performance benchmarking: $ time hg log -qr "first(branch(default))" 0:9117c6561b0b real 0m3.130s user 0m3.025s sys 0m0.074s $ time ./hg log -qr "first(branch(default))" 0:9117c6561b0b real 0m0.300s user 0m0.198s sys 0m0.069s

revset: added lazyset implementation to branch revset Performance Benchmarking: $ time hg log -l1 -qr "branch(default)" 0:9117c6561b0b real 0m3.366s user 0m3.217s sys 0m0.095s $ time ./hg log -l1 -qr "branch(default)" 0:9117c6561b0b real 0m0.389s user 0m0.199s sys 0m0.061s

run-tests: fix typo and print out failing line Instead of stripping the newline and printing the line, only the newline was printed. The output on buildbot will make more sense now.

revset: changed getset so that it can return a lazyset Not converting it manually to a baseset anymore. At this point every revset method should return a baseset typed structure.

hgext: updated extensions to return a baseset when adding symbols

push: move phases synchronisation function in its own function Now that every necessary information is held in the `pushoperation` object, we can finally extract the phase synchronisation phase to it's own function. This is the first concrete block of code we extract from the huge push function. Hooray! This changeset is pure code movement only.

push: move outgoing object in the push object The set of outgoing and common changeset are used by phases to compute the new common set between local and remote. So we need to move it into the object to extract the phase sync from the god function. Note that this information will be used by obsolescence markers too.

push: move push return value in the push object The return code convey information about the success of changeset push. This is used by phases to compute the new common set between local and remote. So we need to move it into the object to extract the phase sync from the god function. Note that this information will be used by obsolescence markers too.

push: move local phase move in a normal function We now have the modularity for simpler approach `localphasemove`.

push: explicitly feed pushop to localphasemove Now that pushop is holding all the push related data, we do not really need a closure anymore. So we start feeding the object to `localphasemove` and will make it a normal function in the next commit.

push: move local lock logic in pushoperation During push, we try to lock the local repo to move local phase according to what we saw/pushed on the remote repo. Locking the repo may fail, in that case we let the push proceed without local phase movement (printing warning). This mean we have code in phase synchronisation that will check if the local repo is locked or not. we need to move this information in the push object to be able to extract the phase synchronisation in its own function. This is done as a boolean because putting reference to the actual lock outside of the main function sounded a bad idea.

push: move obsolescence related message into _pushobsolescence function No good reason to have them in the main fonction.

push: drop now outdated comment This `_pushobsolete` now exist for modularity purpose.

push: feed pushoperation object to _pushobsolete function This will allow the obsolete marker synchronisation to have full information on the ongoing push and pass information to other operation.

push: move obsolescence marker exchange in the exchange module The obsolescence marker exchange code was already extracted during a previous cycle. We are moving the extracted functio in this module. This function will read and write data in the `pushoperation` object and I prefer to have all core function collaborating through this object in the same place. This changeset is pure code movement only. Code change for direct consumption of the `pushoperation` object will come later.

push: feed pushoperation object to _pushbookmark function This will able the bookmark synchronisation to have full information on the ongoing push and pass information to other operation.

merge with stable

revset: added operations to duck type baseset Added more operations which are not lazy but only used so far to duck type baseset. Their implementations will be changed in future patches.

revset: added basic operations to lazyset Added methods __add__, __sub__ and __and__ to duck type more methods in baseset

revset: added lazyset class with basic operations This class allows us to return values from large revsets as soon as they are computed instead of having to wait for the entire revset to be calculated.

tests: test that the pid returned by `hg serve` looks reasonable This failed on windows before win32.spawndetached has been fixed. The process name was "cmd.exe" and not "hg.exe" or "python.exe".

win32: spawndetached returns pid of detached process and not of cmd.exe win32.spawndetached starts the detached process by `cmd.exe` (or COMSPEC). The pid it returned was the one of cmd.exe and not the one of the detached process. When this pid is used to kill the process, the detached process is not killed, but only cmd.exe. With this patch the pid of the detached process is written to the pid file. Killing the process works as expected. The pid is only evaluated on writing the pid file. It is unnecessary to search the pid when it is not needed. And more important, it probably does not yet exist right after the cmd.exe process was started. When the pid is written to the file, waiting for the start of the detached process has already happened. Use this functionality instead of writing a 2nd wait function. Many tests on windows will not fail anymore, all those with the first failing line "abort: child process failed to start". (The processes still hanging around from previous test runs have to be killed first. They still block a tcp port.) A good test for the functionality of this patch is test-treediscovery.t, because it starts and kills `hg serve -d` several times.

revset: minor changes adding baseset to revsets Changed bits of code to work with baseset implementations.

tests: rewrite path in test-shelve.t for not being mangled on msys msys (on windows) converets '-R bundle:.XX/XX' to '-R bundle:;.XX/XX'. Avoid this by writing '-R bundle://.XX/XX'. This is used more often than the alternative work arounds like '-Rbundle://.XX/XX' or '-R bundle:Y/../.XX/XX'.

hooks: only disable/re-enable demandimport when it's already enabled This fixes an issue introduced in d7c28954d901 where, when disabling demandimport while running hooks, it's inadvertently re-enabled even when it was never enabled in the first place. This doesn't affect normal command line usage of Mercurial; it only matters when Mercurial is run with demandimport intentionally disabled.

merge with stable

convert: secret config option for disabling debugsvnlog Subversion issues involving svn log such as d54467c1a198 can be tricky to debug when it is run in an 'hg debugsvnlog' sub process. Debugging is simpler when convert only uses one process. With this change convert will invoke the svn log directly when setting [convert] svn.debugsvnlog = False This is intentionally not documented.

convert: make subversion revsplit more stable when meeting revisions without @ revsplit would crash for instance if given a subversion string without @ ... and that could somehow happen when playing around with convert.

revset: minor changes adding baseset to revsets Changed bits of code to work with baseset implementations.

revset: added __add__ method to baseset class

revset: added docstring to baseset class

merge: don't overwrite file untracked after remove, abort with 'untracked files' Merge could overwrite untracked files and cause data loss. Instead we now handle the 'local side removed file and has untracked file instead' case as the 'other side added file that local has untracked' case: FILE: untracked file exists abort: untracked files in working directory differ from files in requested revision It could perhaps make sense to create .orig files when overwriting, either instead of aborting or when overwriting anyway because of force ... but for now we stay consistent with similar cases.

shelve: better (and slightly redundant) test coverage for unshelve conflicts

shelve: status messages from unshelve It was hard for the user to know what was going on when unshelving - especially if the user had to resolve conflicts and thus got to see the intermediate states. Seeing that pending changes was gone could scare the user, make him panic, and do stuff that really made him lose data. Merging (both when rebasing and with pending changes) also requires some understanding of where in the process you are and what you are merging. To help the user we now show a couple of status messages (when relevant): temporarily committing pending changes (restore with 'hg unshelve --abort') rebasing shelved changes

shelve: be quiet when unshelve pulls from the shelve bundle unshelve was quite verbose and it was hard for a user to follow what really was going on. It ended up saying 'added 1 changesets' ... but the user just expected and got pending changes and never saw any changeset. The use of bundles is an implementation detail that we don't have to leak here. Pulling is quite verbose, optimized for pulling many changesets from remote repos - that is not the case here. Instead, set the quiet flag when pulling the bundle - not only when temporarily committing pending changes. The 'finally' restore of ui.quiet is moved to the outer try/finally used for locking.

shelve: add 'changes to' prefix to default shelve message The shelved changes _could_ perhaps be amended to the parent changeset but it _is_ not the parent changeset. Using the description from the parent changeset is thus wrong and confusing. Instead, add a 'changes to' prefix.

shelve: mention FILE options in help Shelve do normally take a list of files or patterns to shelve and the command summary should thus show [FILE]... Note: --delete is a bit special and interpret the parameters as a list of shelve names. This change makes that even less obvious from the help. Too bad - we can't please everyone.

shelve: mention walk options in help

shelve: really pass publicancestors to changegroupsubset - not the parents publicancestors returned the parents of the public ancestors ... and changegroupsubset used the parents of these as base for the bundle. That gave bundles with one layer of changesets more than necessary.

shelve: publicancestors do not have to visit nullrev Not visiting nullrev seems more correct and might be a minor optimization.

localrepo: make it clear that changegroupsubset doesn't take bases but roots changegroupsubset will take the parents of the roots to find the bases. Other parts of Mercurial do not expect that, and a result of that is that some bundles contain more changesets than necessary. No real changes here - just renaming a parameter to document what it is.

repoview: use repo.revs() instead of a private revset method Breaks an import cycle.

commands: use ctx.getfileset instead of fileset.getfileset