log: do not hide the public phase in debug mode (BC) When 51fc43253a52 introduced phases to the `hg log --debug` output, it also disabled outputting public phase. At the same time, it always shows phases in the default template, `hg log --debug -T default`. Those two should produce the same output, but they don't. I think it makes a lot more sense to always show all phases. There's already loss of backwards compatibility in this case when using a newer hg on an old hg repo, since draft commits will show up in the output of `hg log --debug`. Finally, I just don't think that any sort of information should be hidden with --debug. This flag should be about showing as much information as possible.

templater: set the correct phase for parents Akin to f6371cc62d2a which did this for `hg log`, the following sets the correct phase for the {phase} keyword when the context is a parent of the current cset. This allows templates such as the following to be defined, parent = '{label("log.parent changeset.{phase}", "parent: {rev}:{node|formatnode}")}\n' which when called on a parent (e.g. with the `parents` template keyword), will produce the correct phase.

color: omit debug label output on empty strings This is most noticeable when using custom templates. Before this patch, a template like {label("foo.bar", baz)} would emit [foo.bar|] whenever baz was empty. This cset simply omits all output when baz is empty.

tests: make hghave list features alphabetically

revset: remove the now unused _descgeneratorset class

revset: use _generatorset in _revancestors The _descgeneratorset class is going away.

revset: remove now unused class _ascgeneratorset

revset: use _generatorset directly in _revdescendant _ascgeneratorset is going away.

generatorset: move membership testing on ordered gen to the main class We are phasing out the ordered version of the class to simplify the code.

generatorset: make use of the new mechanism in the subclass Until we remove them, we use the new parameter of _generatorset to make sure the code is run.

generatorset: make it possible to use gen as fastasc or fastdesc We gain a parameter to inform that the generator is ascending or descending. If the generator is ordered, it is also used for the `fastasc` or `fastdesc` version. The _ascgeneratorset and _descgeneratorset class will be removed soon.

baseset: rely on the abstractsmartset implementation for filter

_orderedsetmixin: drop this now unused class All my friends are dead.

spanset: drop _orderedsetmixin inheritance The min/max method are as well provided by abstractsmartset.

orderedlazyset: drop this now unused class All my friends are dead.

_descendant: use filteredset instead of orderedlazyset The orderedlazyset class is going away. Filteredset gives the same service.

addset: use the base implementation for ascending and descending

addset: use base implementation for __filter__

addset: use base implementation for __add__

addset: use base implementation for __sub__

addset: use base implementation for __and__

addset: promote to real smartset Better revset performance are also achieved with less overlay. There is no good reason for addset to not be a smartset. We can replace the `_orderedsetmixin` inheritance since `abstractsmartset` has efficient min and max too.

addset: add a __nonzero__ method This is required to be a full smartset (not sure what was happening before that...)

addset: offer a fastasc and fastdesc methods If the underlying object offers fast iterators, we use them to provide fast iterators too.

addset: split simple and ordered iteration We have two goals here. First, we would like to restore the former iteration order we had in 2.9. Second, we want this logic to be reusable for `fastasc` and `fastdesc` methods.

generatorset: promote to smartset This is not going to be efficient but we need all basic set classes to be smartsets for the other classes to work.

generatorset: implement __nonzero__ This is necessary to become a real smartset.

spanset: use base implementation for __add__

spanset: use base implementation for __sub__

spanset: use base implementation for __and__

spanset: use base implementation for filter

filteredset: use base implementation for filter

filteredset: use base implementation for __add__

filteredset: use base implementation for __sub__

filteredset: use base implementation for __and__

abstractsmartset: add default implementation for __sub__

abstractsmartset: add default implementation for __add__

abstractsmartset: add default implementation for __and__

abstractsmartset: add default implementation for filter

lazyset: rename the class to filteredset All smartsets try to be lazy. The purpose of this class is to apply a filter on another set. So we rename the class (and all its occurences) to `filteredset`.

lazyset: add order awareness to the class Just a bit of extra code makes the lazyset aware of order. This renders orderedlazyset useless. At some point, the `subset` will become responsible for this ordering logic. But we are not there yet because the various objects used as subsets are not good enough.

lazyset: remove min/max This is now handled by abstractsmartset.

baseset: remove min/max methods This is now handled by the base class.

abstractsmartset: add a default implementation for min and max This default implementation takes advantage of the fast iterator if available.

lazyset: drop now useless ascending/descending definition

lazyset: inherit the fastasc and fastdesc method from subset When the filtered subset has such methods, we can use them. It is implemented as properties to be able to quickly return None if no corresponding fastasc exists on the subset.

lazyset: split the iteration logic from the condition filtering logic So that the filter can be reused by `fastasc` or `fastdesc`.

spanset: do a single range check in __contains__ Now that `start <= end` is always true, we can simplify this function.

spanset: enforce the order lazily to gain `fastasc` and `fastdesc` methods Instead of having the direction of iteration enforced through the ordering of `start` and `end` attributes of spanset, we encode the iteration direction in an explicit attribute and always store start < end. The logic for sort and reverse has to be updated. The __iter__ is now based on the newly introduced `fastasc` and `fastdesc` methods. This will allow other code simplifications in the future.

abstractsmartset: document the `fastasc` and `fastdesc` attributes/methods See the in-line documentation for details. (This is the beginning of a massive overhaul of revset).

spanset: remove ascending/descending implementation We can rely on their implementation in abstractsmartset.

baseset: remove ascending/descending redefinition We can rely on the abstractsmartset implementation.

abstractsmartset: default implementation for `ascending` and `descending` These two methods are actually silly aliases for `sort()` and `sort(reverse=True)`. So we get that aliasing at the abstractsmartset level. We will slowly phase out all the custom implementations and eventually remove any mentions of it from the code.

revert: bring back usage of `subset & ps` in `parents` Changeset 95af98616aa7 switched the order of the operand of the "&" computation to work around an issue from repo-wide spanset. The need for a workaround has been alleviated by the introduction of `fullreposet`. So we restore it to normal. The benchmark shows no significant changes as expected. We also revert the bogus test change introduced by 95af98616aa7. The order is actually important.

color: update docstring for debug option 964dd1c491ca updated the format for the --color=debug option. This updates the documentation to match this new format.

color: document the possibility to colourise tabs in diffs This is a no-op change that simply suggests that tabs can be colourised, but defaults to no colour effects for tabs. This complements cset c343557a8442. Like the similar effects for phases from f8e2aebbb24c, we set the default effects to '' instead of None, so that this is a true noop change. Otherwise, the diff.tab effect would override (i.e. neutralise) the effect of the surrounding label.

contrib/synthrepo: walk a repo's directory structure during analysis Augments the analyze command to additionally walk the repo's current directory structure (or of any directory tree), counting how many files appear in which paths. This data is saved in the repo model to be used by synthesize, for creating an initial commit with many files. This change is aimed at developing, testing and measuring scaling improvements when importing/converting a large repository to mercurial.

contrib/synthrepo: generate initial repo contents using directory shape model Augments the synthesize command to use an additional parameter to the analyzed repo model: the number of files in each directory at a given snapshot. Before synthesizing history, an arbitrary number of files will be generated in a distribution matching the analyzed directory structure. Intended for developing, testing and measuring scaling improvements when importing/converting a large repository to Mercurial.

filemerge: switch the default name for internal tools from internal:x to :x

filemerge: introduce :x as short version of internal:x merge tool name "internal:" is so much typing - it is frequently specified on the command line and gives options that are longer than any other I have seen.

branches: include active, closed and current flags in template output

branches: merge white space to format string Diffs of test output should be harmless. A white space character is moved into "log.changeset" color region.

branches: port to generic templater

branches: format rev as integer that is necessary for generic templater

formatter: add general way to switch hex/short functions This seems a bit awkward, but it can avoid duplicates in annotate, tags, branches and bookmarks. I guess fm.hexfunc can eventually be removed (or redesigned) when it gets template backend.

locarepo: remove the `pull` method (API) All the logic of this function is in the `exchange.pull` function for some time. We just stop calling `localrepo.pull` in `command.pull` to have access to more information. Leaving `localrepo.pull` in place will let third-party extensions wrap it but it would never be called by `hg pull` making the wrapping useless. Therefore, the method is removed so that third-party code fail noisily and get properly upgraded.

transplant: use exchange.pull localrepo.pull is going away. See 4d52e6eb98ea for details.

convert-hg: use localrepo.pull localrepo.pull is going away. See 4d52e6eb98ea for details.

fetch: use exchange.pull localrepo.pull is going away. See 4d52e6eb98ea for details.

localrepo: use exchange.pull when cloning localrepo.pull is going away. See 4d52e6eb98ea for details.

subrepo: use exchange.pull localrepo.pull is going away, see 4d52e6eb98ea for details.

commands: directly use exchange.pull localrepo.pull is going away. See explanations in 4d52e6eb98ea.

exchange: have `pull` return the pulloperation object We mimic what was done for `push` for similar reason. We are about to drop `localrepo.pull` (for consistency with dropping `localrepo.push` and we better have an API as extensible as `push` is. Find explanations about localrepo.push removal in 4d52e6eb98ea.

revset: introduce an abstractsmartset class This class documents all methods required by a smartset. This makes it easier for people to respect the API and ensure we fail loudly when something does not. It will later also contain common default implementations for multiple methods, making it easier to have smartset classes with minimal work.

revset: add a `__nonzero__` to baseset We are about to add a base class for `baseset` with an abstract `__nonzero__` method. So we need this method to be explicitly defined to avoid issues. The built-in list object apparently does not have a `__nonzero__` and relies on `__len__` for this purpose?

revset: drop isinstance(baseset) in spanset.__sub__ As baseset now has a fast __contains___ operator, this `baseset.set()` dance is no longer needed. No regressions are visible in the benchmark.

revset: drop isinstance(baseset) in spanset.__and__ As baseset now has a fast __contains___ operator, this `baseset.set()` dance is no longer needed. No regressions are visible in the benchmark.

revset: drop isinstance(baseset) from baseset.__and__ As baseset now has a fast __contains___ operator, this `baseset.set()` dance is no longer needed. No regressions are visible in the benchmark.

revset: use direct access to __contains__ in spanset.__sub__ Using `x.__contains__(r)` instead of `r in x` does not matter for built-in type (set) but have a positive impact for all other classes. This will let us drop some usage of baseset.set() in future patches. This also probably improves some performance.

revset: use a single return statement in matcher function This makes it easy to insert post processing and debug code on the returned value.

obsolete: replace "nb" notation with "num" (for "number") As requested by Matt Mackall.

shelve: remove unused status variables

gpg: use an abort hint and don't mention --force

gpg: move test of force before status call

gpg: drop unnecessary slicing of status array The call to repo.status() does not request status for clean files, so there is no reason to slice it out from the result. Leaving the tuple untouched will simplify a future change.

tag: use an abort hint

tag: only check the status of .hgtags

tag: properly abort if an unknown or ignored .hgtags is present This was a regression introduced by 4faaa0535ea7 in 2008.

summary: remove unused code for listing ignored files The call to repo.status() does not request ignored files to be listed, so remove the code for printing them.

fetch: use cmdutil.bailifchanged() Use the existing method cmdutil.bailifchanged() instead of implementing it again in fetch.py. An effect of this is that the error messages in case of uncommited changes will be different.

ui: fix comment about non-interactive prompts This fixes my earlier in-flight addition to Mads' change.

formatter: convert booleans to json It will be used in branches output.

merge: mute the status message when bid merge kicks in Bid merge is now the default and it is not necessary to tell the user that an experimental feature kicked in. (It could however still be relevant to get a notice that it is one of the rare criss-cross merge situations so the user is warned that the situation is more tricky than usual.)

merge: use bid merge by default (BC) In most cases merges will work exactly as before. The only difference is in criss-cross merge situations where there is multiple ancestors. Instead of picking an more or less arbitrary ancestor, it will consider both ancestors and pick the best bids. Bid merge can be disabled with --config merge.preferancestor='!'.

changectx: skip all invalid merge.preferancestor values A better fix for 17011b36aac7 that will ignore other kinds of "invalid" revisions.

revset: rely on built in iterator when possible in _generatorset.__iter__ Doing manual iteration is expensible. We rely on built in list iteration whenever possible. The other case has to become a closure we cannot have a both yield and return in the same function.

revset: prefetch an attribute in _generatorset.__iter__ Python's attribute lookup are expensible, lets do less of them. This gives us a 7% speedup on this revset iteration (from 0.063403 to 0.059032)

templater: add count template filter, plus tests Previously there was no way of telling how much children or bookmarks or tags a certain changeset has in a template. It was possible to tell if a changeset has either 0 or not 0 bookmarks, but not to tell if it has 1 or 2 of them, for example. This filter, simply named count, makes it possible to count the number of items in a list or the length of a string (or, anything that python's len can count). E.g.: {children|count}, {bookmarks|count}, {file_adds|count}. Testing the filter on node hash and shortened node hash is chosen because they both have defined length. As for lists of strings - children, tags and file_adds are used, because they provide some variety and also prove that what's counted is the number of string items in the list, and not the list stringified (they are lists of non-empty, multi-character strings). Additionally, revset template function is used for testing the filter, since the combination is very flexible and will possibly be used together a lot. (The previous version of this patch had an incorrect email subject and was apparently lost - patchwork says the patch has been accepted, but it's not so. The changes between that and this patch are minimal: now the filter does not disturb the alphabetical order of function definitions and dict keys.)

push: update bookmarks (on server) within a transaction A nice side effect is that bookmarks sent through bundle2 are updated within the same transaction as all other changes.

pull: perform bookmark updates in the transaction

bookmark: add a `bmstore.recordupdate` to plug bookmarks into the transaction Instead of manually writing bookmarks when they are updated, we can just record this update to the transaction and rely on it to update the on-disk file.

bookmarks: split bookmark serialization and file handling If we want to handle bookmarks in a transaction we need to decouple the file handling and the actual production of the content. This is similar to how we handle phases in transaction.

transaction: allow generating file outside of store We allow a vfs argument to `addfilegenerator`. This allows generating files outside of the store directory like bookmarks. However, this is not really working since we do not have the infrastructure to backup and restore files outside of store. By chance, the bookmark file is already backed up by another mechanism so we can restrict this new feature to bookmarks (which is our only interest here) and proceed.

transaction: work around and document issue with file backup The backup restoration is actually hard-coded for the main file. And this hard-coded list is the only one used when repairing an interrupted transaction from another process. Solving this problem is out of the scope of this series so we document it and work around its implications.

bundle2: remove an explicit packing The final writing of the empty part was done explicitly. We now using proper pack call using symbolic constant. This open simple change in the bundle2 format.

bundle2: split test in two We split the test between the one dedicated to the binary format and the one dedicated to checking the exchange of data using pull and push.

pull: merge bookmark updates and imports We do all the things in one go now, updating existing bookmark, adding new ones, and overwriting the ones explicitly specified for --bookmark. This impacts the tests by removing some duplicated or unnecessary output.

pull: gather explicit bookmark pulls with bookmark updates There is no reason to make them at different times. So we gather them. This is the first step toward merging them.

subrepo: stop pulling bookmark manually Bookmark pulling is now done with all the other pull steps in the `exchange.pull` function.

pull: retrieve bookmarks through bundle2 We can retrieve any pushkey namespace through bundle2. So we also ask for bookmark data and use them to update the local repo.

pull: retrieve bookmarks before obsmarkers Retrieving bookmarks before obsmarkers will avoid turning some changesets hidden right before making them visible again if a bookmark keeps them visible.

pull: move bookmark pulling into its own function This requires adding an attribute on the pulloperation object. The bookmark pulling is protected behind a "todostep" as other steps of pull.

pull: perform the todostep inside functions handling old way of pulling This matches what is done during push.

bookmark: remove now unused `pushtoremote` function Everything is unified in the push discovery now.

push: gather all bookmark decisions together The discovery phases for bookmarks now use the list of explicitly pushed bookmarks to do addition, removal and overwriting. Tests are impacted because this reduces the amount of listkeys calls issued, removes some duplicated messages and improves the accuracy of some messages.

push: prepare the issue of multiple kinds of messages To gather all the bookmark pushing actions together, we need code performing those actions to be ready for them. We need to be able to produce different messages for different actions.

push: set bkresult when pushing bookmarks through bundle2

clone: remove duplicated bookmark pulling Now that all clone methods (copy, pull and push) also transport bookmarks, we can safely drop the manual pulling that was performed during clone.

clone: explicitly push bookmarks when cloning from local to remote We need to explicitly push all local bookmarks when doing the clone from a local repo to a remote one through ssh. This will let us remove the manual export of bookmarks in clone and rely on the official exchange in push and pull instead.

clone: copy `.hg/bookmarks` during copy clone Now that the standard pull function includes bookmarks, we need to ensure that a copy clone also copies the bookmarks. This will let us drop the manual bookmark pulling done independently during a clone.