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.

pull: move bookmark movements inside the `exchange.pull` There is no reason for bookmarks to get a special treatment. As a first step we move the code as is in the `exchange.pull` function. Integration with the rest of the flow will come later. Adding bookmarks to pull means that most clone paths are now pulling bookmarks through pull. We ensure that bookmark-update messages are properly suppressed in that case. In test-pull-http.t the 'requesting all changes' message disappear because we now get the authentication error on the `listkeys`command before such message is printed.

bookmarks: allow `updatefromremote` to be quiet This will be useful to use the function during clone (clone is not printing any bookmark data right now)

util: fix sorteddict.pop When using `.pop` on such object the list was not cleared of the popped key, leading to crash.

localrepo: pass arbitrary kwargs from `repo.pull` to `exchange.pull` We'll add bookmark-related arguments to `repo.pull` so we need to widen the signature of `repo.pull`. We should probably kill `repo.pull` now that `repo.push` is dead but this is outside the scope of this series.

pull: use `other.url()` as the source of a bookmark pull We want to move the bookmarks movement into `exchange.pull`, for this purpose we need to stop relying on variables from `command.pull`.

setup: set mode 644 or 755 on installed files

branches: reduce nesting in for loop

i18n: use datapath for i18n like for templates and help To avoid circular module dependencies we initialize i18n from util when datapath is found.

help: don't search randomly for help data - trust util.datapath The search was introduced in c904e76e3834 without a convincing explanation why it should be necessary ... except for consistency with templater handling. Now, just keep it simple.

templater: don't search randomly for templates - trust util.datapath The search was introduced in 2653740d8118. It might have been necessary back then when using __file__ directly and frozen-ness wasn't considered. Now we should know exactly where the templates can be found.

templater: inline global 'path' list in templatepaths

templater: introduce templatepaths for getting paths searched for templates Avoid function with different return types depending on parameters.

util: introduce datapath for getting the location of supporting data files templates, help and locale data is normally stored as sub folders in the directory containing the source of the mercurial module. In a frozen build they live as sub folders next to 'hg.exe' and 'library.zip'. These different kind of data were handled in different ways. Unify that by introducing util.datapath. The value is computed from the environment and is always used, so we just calculate the value on module load.

util: move _hgexecutable a few lines, closer to where it is used

hgk: define bookmark colour explicitly, as Tk 8.6 has changed their meaning

largefiles: remove 'forget' list that's always empty

bookmarks: fix divergent bookmark path normalization

exchange: remove a broken i18n abuse

bookmark: make the search for divergent names more robust We translate the "url we update from" and "the url in the config" into their canonical representation. This is useful for urls that have multiple equivalent forms: /foo/bar/ == file:/foo/bar/ == file:///foo/bar eg: hg pull --config path.bar=/foo/bar/ file:/foo/bar

pull: gather all bookmark-pulling code together Pulling bookmarks is done in two rounds. First we do a simple update, then we use the content of the `bookmark` argument to possibly overwrite some bookmark with their remote location. The second step was not done right after the first one for some obscure reason. We now perform them one after the other.

push: perform bookmark export in the push function This part is responsible for adding new bookmarks on the remote. Before that, it was done on its own in `commands.push`. The export is still not integrated with the rest of the push process, but at least it now dwells in the right function.

push: add `pushoperation.bkresult` This attribute will be used to carry the result of the bookmark push (when the `push` function will effectively be doing any bookmarks pushes)

push: pass list of bookmark to `exchange.push` Currently stored but not unused. This parameter will control bookmarks explicitly pushed (added to the server if missing).

exchange: import bookmarks as bookmod Using the original names makes it difficult to use `bookmarks` as a variable name.

push: sanitize handling of bookmark push return value Mixing return and assignment does not make sense, let's unify this.

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

push: `exchange.push` instead of `localrepo.push` The latter is going away.

clone: use `exchange.push` instead of `localrepo.push` The latter is going away.

push: use `exchange.push` in `commands.push` To gain access to all results from the push, we need to have access to the `pushoperation` object. We call `exchange.push` to do so. It is impossible to just change the `localrepo.push` signature because the change may be too subtle to be caught by external extension wrapping `localrepo.push`. This mean we'll have to kill `localrepo.push` because just using `exchange.push` in `commands.py` would silently disable all wrapping around `localrepo.push` by third-party extensions. So we'll remove it in a later changeset to get such extensions to fail noisily.

push: `exchange.push` now returns the `pushoperation` object Returning the pushop object gives access to more information (upcoming bookmark push result for example). `localrepo.push` currently extracts the `cgresult` for callers.

push: rename `pushop.ret` to `pushop.cgresult` We are about to introduce more results-related attributes on pushop (for bookmarks) so we need a more distinctive name. We now use `cgresult` as `pulloperation` does.

obsolete: use version constants in the format mapping

obsolete: use the `version` argument in encodemarkers Recent scientific studies show that assigning a variable have no effect on a unrelated constant. We therefore use the variable where we intended to in the first place.

obsolete: gather all contents related to format version 0 in a single place All contents includes documentation, constants, and functions, so we gather all of those things into a single location. The diff is confusing because it cannot understand what code is semantically moved around in this grand migration.

revert: properly back up added files with local modification These files were previously not backed up because the backup mechanism was not smart enough. This leads to data lose for the user since uncommitted contents were discarded. We now properly move the modified version to <filename>.orig before deleting it. We have to use a small hack to do a different action if "--no-backup" is specified. This is needed because the backup process is actually a move (not a copy) so the file is already missing when we backup. The internet kitten is a bit disapointed about that, but such is life. This patch concludes the "lets refactor revert" phases. We can now open the "Lets find stupid bug with renames and merge" phases. I'm sure that now that the code is clearer we could do it in another simpler way, but I consider the current improvement good enough for now.

revert: track added files with local modifications Those files need to be backed up but are currently not. We compute the set of them to be able to use a different backup strategy in the next changeset.

revert: distinguish between "check" and "backup" strategy "check" behaves as backup did before. We check if the current file differs from destination and we create a backup if it does. This is used for untracked files that will be overwritten by formerly-deleted files. We have to do the manual check since no status output can provide the content comparison. "backup" is now doing unconditional backup. This can be used for files seen as modified compared to both the target and the working directory. In such a case, we know that the file differs from target without actually comparing any content. This new "backup" strategy will be especially useful in the case of files added between the target and the working directory -parent- with additional modifications in the working directory -itself-. In that case we know we need to back it up, but we cannot run the content check as the files does not exists in target.

revert: small refactoring in the way backup value are handled The current backup value may have two different values: 1. Do not try to do backup 2. Do backup if applicable We are about to move to: 1. Do not try to do backup 2. Do backup if applicable 3. Do backup in all cases So we change the current values to make room for the new one.

merge with stable

Added signature for changeset f768c888aaa6

Added tag 3.1.2 for changeset f768c888aaa6

parsers: fix Py2.4 argument parsing issue Since fa53d66b45a8, we were getting this strange message with Py2.4: TypeError: argument 1 must be impossible<bad format char>, not int ..because we were using the 'n' type specifier introduced in 2.5. It turns out that offset is actually a revision number index, which ought to be an int anyway. So we store it in an int, use the 'i' specifier, rely on Py_ParseTuple for range checking, and rename it to avoid type confusion.

merge with i18n

diff: document the nobinary option Since 3fbef7ac26f0, we have a diff.nobinary option. This is handy, but the only way I found out about it was by looking at the release notes for 3.1, which is not something I normally do.

i18n-pt_BR: minor fixes and rewording on histedit help text