author | Boris Feld <boris.feld@octobus.net> |
Sat, 18 Aug 2018 12:45:44 +0200 | |
changeset 39490 | 966950954fda |
parent 39304 | fc54a290b4b0 |
child 39624 | 713085b45810 |
permissions | -rw-r--r-- |
13350
a7376b92caaa
bookmarks: move basic io to core
Matt Mackall <mpm@selenic.com>
parents:
diff
changeset
|
1 |
# Mercurial bookmark support code |
a7376b92caaa
bookmarks: move basic io to core
Matt Mackall <mpm@selenic.com>
parents:
diff
changeset
|
2 |
# |
a7376b92caaa
bookmarks: move basic io to core
Matt Mackall <mpm@selenic.com>
parents:
diff
changeset
|
3 |
# Copyright 2008 David Soria Parra <dsp@php.net> |
a7376b92caaa
bookmarks: move basic io to core
Matt Mackall <mpm@selenic.com>
parents:
diff
changeset
|
4 |
# |
a7376b92caaa
bookmarks: move basic io to core
Matt Mackall <mpm@selenic.com>
parents:
diff
changeset
|
5 |
# This software may be used and distributed according to the terms of the |
a7376b92caaa
bookmarks: move basic io to core
Matt Mackall <mpm@selenic.com>
parents:
diff
changeset
|
6 |
# GNU General Public License version 2 or any later version. |
a7376b92caaa
bookmarks: move basic io to core
Matt Mackall <mpm@selenic.com>
parents:
diff
changeset
|
7 |
|
25917
aa323b53e3f9
bookmarks: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
25743
diff
changeset
|
8 |
from __future__ import absolute_import |
aa323b53e3f9
bookmarks: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
25743
diff
changeset
|
9 |
|
aa323b53e3f9
bookmarks: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
25743
diff
changeset
|
10 |
import errno |
35257
3340d46a5c3f
bookmark: add methods to binary encode and decode bookmark values
Boris Feld <boris.feld@octobus.net>
parents:
34708
diff
changeset
|
11 |
import struct |
25917
aa323b53e3f9
bookmarks: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
25743
diff
changeset
|
12 |
|
aa323b53e3f9
bookmarks: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
25743
diff
changeset
|
13 |
from .i18n import _ |
aa323b53e3f9
bookmarks: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
25743
diff
changeset
|
14 |
from .node import ( |
aa323b53e3f9
bookmarks: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
25743
diff
changeset
|
15 |
bin, |
aa323b53e3f9
bookmarks: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
25743
diff
changeset
|
16 |
hex, |
32956
4f0a7f604449
commands: move checkconflict to bookmarks module
Sean Farley <sean@farley.io>
parents:
32955
diff
changeset
|
17 |
short, |
35257
3340d46a5c3f
bookmark: add methods to binary encode and decode bookmark values
Boris Feld <boris.feld@octobus.net>
parents:
34708
diff
changeset
|
18 |
wdirid, |
25917
aa323b53e3f9
bookmarks: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
25743
diff
changeset
|
19 |
) |
aa323b53e3f9
bookmarks: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
25743
diff
changeset
|
20 |
from . import ( |
aa323b53e3f9
bookmarks: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
25743
diff
changeset
|
21 |
encoding, |
29354
af849596752c
bookmarks: abort 'push -B .' when no active bookmark
liscju <piotr.listkiewicz@gmail.com>
parents:
29300
diff
changeset
|
22 |
error, |
33146
7017567ebdf2
obsutil: move 'foreground' to the new modules
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
33092
diff
changeset
|
23 |
obsutil, |
33092
d170f59f6f55
py3: fix kwargs handling for `hg bookmarks`
Pulkit Goyal <7895pulkit@gmail.com>
parents:
33011
diff
changeset
|
24 |
pycompat, |
32955
70661eeb8ddb
commands: move checkformat to bookmarks module
Sean Farley <sean@farley.io>
parents:
32794
diff
changeset
|
25 |
scmutil, |
31052
0332b8fafd05
bookmarks: check HG_PENDING strictly
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
30634
diff
changeset
|
26 |
txnutil, |
25917
aa323b53e3f9
bookmarks: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
25743
diff
changeset
|
27 |
util, |
aa323b53e3f9
bookmarks: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
25743
diff
changeset
|
28 |
) |
13350
a7376b92caaa
bookmarks: move basic io to core
Matt Mackall <mpm@selenic.com>
parents:
diff
changeset
|
29 |
|
33009
4b81776baa7a
commands: move activebookmarklabel to bookmarks module
Sean Farley <sean@farley.io>
parents:
33007
diff
changeset
|
30 |
# label constants |
4b81776baa7a
commands: move activebookmarklabel to bookmarks module
Sean Farley <sean@farley.io>
parents:
33007
diff
changeset
|
31 |
# until 3.5, bookmarks.current was the advertised name, not |
4b81776baa7a
commands: move activebookmarklabel to bookmarks module
Sean Farley <sean@farley.io>
parents:
33007
diff
changeset
|
32 |
# bookmarks.active, so we must use both to avoid breaking old |
4b81776baa7a
commands: move activebookmarklabel to bookmarks module
Sean Farley <sean@farley.io>
parents:
33007
diff
changeset
|
33 |
# custom styles |
4b81776baa7a
commands: move activebookmarklabel to bookmarks module
Sean Farley <sean@farley.io>
parents:
33007
diff
changeset
|
34 |
activebookmarklabel = 'bookmarks.active bookmarks.current' |
4b81776baa7a
commands: move activebookmarklabel to bookmarks module
Sean Farley <sean@farley.io>
parents:
33007
diff
changeset
|
35 |
|
27186
34d26e22a2b0
bookmarks: hoist getbkfile out of bmstore class
Augie Fackler <augie@google.com>
parents:
27185
diff
changeset
|
36 |
def _getbkfile(repo): |
34d26e22a2b0
bookmarks: hoist getbkfile out of bmstore class
Augie Fackler <augie@google.com>
parents:
27185
diff
changeset
|
37 |
"""Hook so that extensions that mess with the store can hook bm storage. |
34d26e22a2b0
bookmarks: hoist getbkfile out of bmstore class
Augie Fackler <augie@google.com>
parents:
27185
diff
changeset
|
38 |
|
34d26e22a2b0
bookmarks: hoist getbkfile out of bmstore class
Augie Fackler <augie@google.com>
parents:
27185
diff
changeset
|
39 |
For core, this just handles wether we should see pending |
34d26e22a2b0
bookmarks: hoist getbkfile out of bmstore class
Augie Fackler <augie@google.com>
parents:
27185
diff
changeset
|
40 |
bookmarks or the committed ones. Other extensions (like share) |
34d26e22a2b0
bookmarks: hoist getbkfile out of bmstore class
Augie Fackler <augie@google.com>
parents:
27185
diff
changeset
|
41 |
may need to tweak this behavior further. |
34d26e22a2b0
bookmarks: hoist getbkfile out of bmstore class
Augie Fackler <augie@google.com>
parents:
27185
diff
changeset
|
42 |
""" |
31052
0332b8fafd05
bookmarks: check HG_PENDING strictly
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
30634
diff
changeset
|
43 |
fp, pending = txnutil.trypending(repo.root, repo.vfs, 'bookmarks') |
0332b8fafd05
bookmarks: check HG_PENDING strictly
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
30634
diff
changeset
|
44 |
return fp |
27186
34d26e22a2b0
bookmarks: hoist getbkfile out of bmstore class
Augie Fackler <augie@google.com>
parents:
27185
diff
changeset
|
45 |
|
37847
8256962e798c
bookmarks: hide dict behind bmstore class
Yuya Nishihara <yuya@tcha.org>
parents:
37641
diff
changeset
|
46 |
class bmstore(object): |
17922
7f5dab94e48c
bookmarks: introduce a bmstore to manage bookmark persistence
Augie Fackler <raf@durin42.com>
parents:
17918
diff
changeset
|
47 |
"""Storage for bookmarks. |
7f5dab94e48c
bookmarks: introduce a bmstore to manage bookmark persistence
Augie Fackler <raf@durin42.com>
parents:
17918
diff
changeset
|
48 |
|
27698
dad6404ccddb
bmstore: add handling of the active bookmark
Augie Fackler <augie@google.com>
parents:
27685
diff
changeset
|
49 |
This object should do all bookmark-related reads and writes, so |
dad6404ccddb
bmstore: add handling of the active bookmark
Augie Fackler <augie@google.com>
parents:
27685
diff
changeset
|
50 |
that it's fairly simple to replace the storage underlying |
dad6404ccddb
bmstore: add handling of the active bookmark
Augie Fackler <augie@google.com>
parents:
27685
diff
changeset
|
51 |
bookmarks without having to clone the logic surrounding |
dad6404ccddb
bmstore: add handling of the active bookmark
Augie Fackler <augie@google.com>
parents:
27685
diff
changeset
|
52 |
bookmarks. This type also should manage the active bookmark, if |
dad6404ccddb
bmstore: add handling of the active bookmark
Augie Fackler <augie@google.com>
parents:
27685
diff
changeset
|
53 |
any. |
17922
7f5dab94e48c
bookmarks: introduce a bmstore to manage bookmark persistence
Augie Fackler <raf@durin42.com>
parents:
17918
diff
changeset
|
54 |
|
7f5dab94e48c
bookmarks: introduce a bmstore to manage bookmark persistence
Augie Fackler <raf@durin42.com>
parents:
17918
diff
changeset
|
55 |
This particular bmstore implementation stores bookmarks as |
7f5dab94e48c
bookmarks: introduce a bmstore to manage bookmark persistence
Augie Fackler <raf@durin42.com>
parents:
17918
diff
changeset
|
56 |
{hash}\s{name}\n (the same format as localtags) in |
7f5dab94e48c
bookmarks: introduce a bmstore to manage bookmark persistence
Augie Fackler <raf@durin42.com>
parents:
17918
diff
changeset
|
57 |
.hg/bookmarks. The mapping is stored as {name: nodeid}. |
7f5dab94e48c
bookmarks: introduce a bmstore to manage bookmark persistence
Augie Fackler <raf@durin42.com>
parents:
17918
diff
changeset
|
58 |
""" |
13351
6c5368cd2df9
bookmarks: move read methods to core
Matt Mackall <mpm@selenic.com>
parents:
13350
diff
changeset
|
59 |
|
17922
7f5dab94e48c
bookmarks: introduce a bmstore to manage bookmark persistence
Augie Fackler <raf@durin42.com>
parents:
17918
diff
changeset
|
60 |
def __init__(self, repo): |
7f5dab94e48c
bookmarks: introduce a bmstore to manage bookmark persistence
Augie Fackler <raf@durin42.com>
parents:
17918
diff
changeset
|
61 |
self._repo = repo |
37847
8256962e798c
bookmarks: hide dict behind bmstore class
Yuya Nishihara <yuya@tcha.org>
parents:
37641
diff
changeset
|
62 |
self._refmap = refmap = {} # refspec: node |
37850
04ceb267271a
bookmarks: cache reverse mapping (issue5868)
Yuya Nishihara <yuya@tcha.org>
parents:
37849
diff
changeset
|
63 |
self._nodemap = nodemap = {} # node: sorted([refspec, ...]) |
32738
999aa9cfb4d3
bookmarks: move variable initialization earlier
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
32737
diff
changeset
|
64 |
self._clean = True |
999aa9cfb4d3
bookmarks: move variable initialization earlier
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
32737
diff
changeset
|
65 |
self._aclean = True |
32735
d7522f983f37
bookmarks: explicitly convert to 'node' during initialization
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
32734
diff
changeset
|
66 |
nm = repo.changelog.nodemap |
d7522f983f37
bookmarks: explicitly convert to 'node' during initialization
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
32734
diff
changeset
|
67 |
tonode = bin # force local lookup |
17922
7f5dab94e48c
bookmarks: introduce a bmstore to manage bookmark persistence
Augie Fackler <raf@durin42.com>
parents:
17918
diff
changeset
|
68 |
try: |
32794
6f775d10e83b
bookmarks: make sure we close the bookmark file after reading
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
32793
diff
changeset
|
69 |
with _getbkfile(repo) as bkfile: |
6f775d10e83b
bookmarks: make sure we close the bookmark file after reading
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
32793
diff
changeset
|
70 |
for line in bkfile: |
6f775d10e83b
bookmarks: make sure we close the bookmark file after reading
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
32793
diff
changeset
|
71 |
line = line.strip() |
6f775d10e83b
bookmarks: make sure we close the bookmark file after reading
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
32793
diff
changeset
|
72 |
if not line: |
6f775d10e83b
bookmarks: make sure we close the bookmark file after reading
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
32793
diff
changeset
|
73 |
continue |
6f775d10e83b
bookmarks: make sure we close the bookmark file after reading
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
32793
diff
changeset
|
74 |
try: |
6f775d10e83b
bookmarks: make sure we close the bookmark file after reading
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
32793
diff
changeset
|
75 |
sha, refspec = line.split(' ', 1) |
6f775d10e83b
bookmarks: make sure we close the bookmark file after reading
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
32793
diff
changeset
|
76 |
node = tonode(sha) |
6f775d10e83b
bookmarks: make sure we close the bookmark file after reading
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
32793
diff
changeset
|
77 |
if node in nm: |
6f775d10e83b
bookmarks: make sure we close the bookmark file after reading
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
32793
diff
changeset
|
78 |
refspec = encoding.tolocal(refspec) |
37847
8256962e798c
bookmarks: hide dict behind bmstore class
Yuya Nishihara <yuya@tcha.org>
parents:
37641
diff
changeset
|
79 |
refmap[refspec] = node |
37850
04ceb267271a
bookmarks: cache reverse mapping (issue5868)
Yuya Nishihara <yuya@tcha.org>
parents:
37849
diff
changeset
|
80 |
nrefs = nodemap.get(node) |
04ceb267271a
bookmarks: cache reverse mapping (issue5868)
Yuya Nishihara <yuya@tcha.org>
parents:
37849
diff
changeset
|
81 |
if nrefs is None: |
04ceb267271a
bookmarks: cache reverse mapping (issue5868)
Yuya Nishihara <yuya@tcha.org>
parents:
37849
diff
changeset
|
82 |
nodemap[node] = [refspec] |
04ceb267271a
bookmarks: cache reverse mapping (issue5868)
Yuya Nishihara <yuya@tcha.org>
parents:
37849
diff
changeset
|
83 |
else: |
04ceb267271a
bookmarks: cache reverse mapping (issue5868)
Yuya Nishihara <yuya@tcha.org>
parents:
37849
diff
changeset
|
84 |
nrefs.append(refspec) |
04ceb267271a
bookmarks: cache reverse mapping (issue5868)
Yuya Nishihara <yuya@tcha.org>
parents:
37849
diff
changeset
|
85 |
if nrefs[-2] > refspec: |
04ceb267271a
bookmarks: cache reverse mapping (issue5868)
Yuya Nishihara <yuya@tcha.org>
parents:
37849
diff
changeset
|
86 |
# bookmarks weren't sorted before 4.5 |
04ceb267271a
bookmarks: cache reverse mapping (issue5868)
Yuya Nishihara <yuya@tcha.org>
parents:
37849
diff
changeset
|
87 |
nrefs.sort() |
32794
6f775d10e83b
bookmarks: make sure we close the bookmark file after reading
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
32793
diff
changeset
|
88 |
except (TypeError, ValueError): |
6f775d10e83b
bookmarks: make sure we close the bookmark file after reading
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
32793
diff
changeset
|
89 |
# TypeError: |
6f775d10e83b
bookmarks: make sure we close the bookmark file after reading
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
32793
diff
changeset
|
90 |
# - bin(...) |
6f775d10e83b
bookmarks: make sure we close the bookmark file after reading
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
32793
diff
changeset
|
91 |
# ValueError: |
6f775d10e83b
bookmarks: make sure we close the bookmark file after reading
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
32793
diff
changeset
|
92 |
# - node in nm, for non-20-bytes entry |
6f775d10e83b
bookmarks: make sure we close the bookmark file after reading
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
32793
diff
changeset
|
93 |
# - split(...), for string without ' ' |
6f775d10e83b
bookmarks: make sure we close the bookmark file after reading
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
32793
diff
changeset
|
94 |
repo.ui.warn(_('malformed line in .hg/bookmarks: %r\n') |
36568
a5eefc9cccc5
bookmarks: fix a repr in a message on Python 3
Augie Fackler <augie@google.com>
parents:
36453
diff
changeset
|
95 |
% pycompat.bytestr(line)) |
25660
328739ea70c3
global: mass rewrite to use modern exception syntax
Gregory Szorc <gregory.szorc@gmail.com>
parents:
25569
diff
changeset
|
96 |
except IOError as inst: |
17922
7f5dab94e48c
bookmarks: introduce a bmstore to manage bookmark persistence
Augie Fackler <raf@durin42.com>
parents:
17918
diff
changeset
|
97 |
if inst.errno != errno.ENOENT: |
7f5dab94e48c
bookmarks: introduce a bmstore to manage bookmark persistence
Augie Fackler <raf@durin42.com>
parents:
17918
diff
changeset
|
98 |
raise |
27698
dad6404ccddb
bmstore: add handling of the active bookmark
Augie Fackler <augie@google.com>
parents:
27685
diff
changeset
|
99 |
self._active = _readactive(repo, self) |
dad6404ccddb
bmstore: add handling of the active bookmark
Augie Fackler <augie@google.com>
parents:
27685
diff
changeset
|
100 |
|
dad6404ccddb
bmstore: add handling of the active bookmark
Augie Fackler <augie@google.com>
parents:
27685
diff
changeset
|
101 |
@property |
dad6404ccddb
bmstore: add handling of the active bookmark
Augie Fackler <augie@google.com>
parents:
27685
diff
changeset
|
102 |
def active(self): |
dad6404ccddb
bmstore: add handling of the active bookmark
Augie Fackler <augie@google.com>
parents:
27685
diff
changeset
|
103 |
return self._active |
dad6404ccddb
bmstore: add handling of the active bookmark
Augie Fackler <augie@google.com>
parents:
27685
diff
changeset
|
104 |
|
dad6404ccddb
bmstore: add handling of the active bookmark
Augie Fackler <augie@google.com>
parents:
27685
diff
changeset
|
105 |
@active.setter |
dad6404ccddb
bmstore: add handling of the active bookmark
Augie Fackler <augie@google.com>
parents:
27685
diff
changeset
|
106 |
def active(self, mark): |
37847
8256962e798c
bookmarks: hide dict behind bmstore class
Yuya Nishihara <yuya@tcha.org>
parents:
37641
diff
changeset
|
107 |
if mark is not None and mark not in self._refmap: |
27698
dad6404ccddb
bmstore: add handling of the active bookmark
Augie Fackler <augie@google.com>
parents:
27685
diff
changeset
|
108 |
raise AssertionError('bookmark %s does not exist!' % mark) |
dad6404ccddb
bmstore: add handling of the active bookmark
Augie Fackler <augie@google.com>
parents:
27685
diff
changeset
|
109 |
|
dad6404ccddb
bmstore: add handling of the active bookmark
Augie Fackler <augie@google.com>
parents:
27685
diff
changeset
|
110 |
self._active = mark |
dad6404ccddb
bmstore: add handling of the active bookmark
Augie Fackler <augie@google.com>
parents:
27685
diff
changeset
|
111 |
self._aclean = False |
27187
d9dcc5c09d77
bmstore: add basic clean-state tracking
Augie Fackler <augie@google.com>
parents:
27186
diff
changeset
|
112 |
|
37847
8256962e798c
bookmarks: hide dict behind bmstore class
Yuya Nishihara <yuya@tcha.org>
parents:
37641
diff
changeset
|
113 |
def __len__(self): |
8256962e798c
bookmarks: hide dict behind bmstore class
Yuya Nishihara <yuya@tcha.org>
parents:
37641
diff
changeset
|
114 |
return len(self._refmap) |
8256962e798c
bookmarks: hide dict behind bmstore class
Yuya Nishihara <yuya@tcha.org>
parents:
37641
diff
changeset
|
115 |
|
8256962e798c
bookmarks: hide dict behind bmstore class
Yuya Nishihara <yuya@tcha.org>
parents:
37641
diff
changeset
|
116 |
def __iter__(self): |
8256962e798c
bookmarks: hide dict behind bmstore class
Yuya Nishihara <yuya@tcha.org>
parents:
37641
diff
changeset
|
117 |
return iter(self._refmap) |
8256962e798c
bookmarks: hide dict behind bmstore class
Yuya Nishihara <yuya@tcha.org>
parents:
37641
diff
changeset
|
118 |
|
8256962e798c
bookmarks: hide dict behind bmstore class
Yuya Nishihara <yuya@tcha.org>
parents:
37641
diff
changeset
|
119 |
def iteritems(self): |
8256962e798c
bookmarks: hide dict behind bmstore class
Yuya Nishihara <yuya@tcha.org>
parents:
37641
diff
changeset
|
120 |
return self._refmap.iteritems() |
8256962e798c
bookmarks: hide dict behind bmstore class
Yuya Nishihara <yuya@tcha.org>
parents:
37641
diff
changeset
|
121 |
|
8256962e798c
bookmarks: hide dict behind bmstore class
Yuya Nishihara <yuya@tcha.org>
parents:
37641
diff
changeset
|
122 |
def items(self): |
8256962e798c
bookmarks: hide dict behind bmstore class
Yuya Nishihara <yuya@tcha.org>
parents:
37641
diff
changeset
|
123 |
return self._refmap.items() |
8256962e798c
bookmarks: hide dict behind bmstore class
Yuya Nishihara <yuya@tcha.org>
parents:
37641
diff
changeset
|
124 |
|
8256962e798c
bookmarks: hide dict behind bmstore class
Yuya Nishihara <yuya@tcha.org>
parents:
37641
diff
changeset
|
125 |
# TODO: maybe rename to allnames()? |
8256962e798c
bookmarks: hide dict behind bmstore class
Yuya Nishihara <yuya@tcha.org>
parents:
37641
diff
changeset
|
126 |
def keys(self): |
8256962e798c
bookmarks: hide dict behind bmstore class
Yuya Nishihara <yuya@tcha.org>
parents:
37641
diff
changeset
|
127 |
return self._refmap.keys() |
8256962e798c
bookmarks: hide dict behind bmstore class
Yuya Nishihara <yuya@tcha.org>
parents:
37641
diff
changeset
|
128 |
|
8256962e798c
bookmarks: hide dict behind bmstore class
Yuya Nishihara <yuya@tcha.org>
parents:
37641
diff
changeset
|
129 |
# TODO: maybe rename to allnodes()? but nodes would have to be deduplicated |
37850
04ceb267271a
bookmarks: cache reverse mapping (issue5868)
Yuya Nishihara <yuya@tcha.org>
parents:
37849
diff
changeset
|
130 |
# could be self._nodemap.keys() |
37847
8256962e798c
bookmarks: hide dict behind bmstore class
Yuya Nishihara <yuya@tcha.org>
parents:
37641
diff
changeset
|
131 |
def values(self): |
8256962e798c
bookmarks: hide dict behind bmstore class
Yuya Nishihara <yuya@tcha.org>
parents:
37641
diff
changeset
|
132 |
return self._refmap.values() |
8256962e798c
bookmarks: hide dict behind bmstore class
Yuya Nishihara <yuya@tcha.org>
parents:
37641
diff
changeset
|
133 |
|
8256962e798c
bookmarks: hide dict behind bmstore class
Yuya Nishihara <yuya@tcha.org>
parents:
37641
diff
changeset
|
134 |
def __contains__(self, mark): |
8256962e798c
bookmarks: hide dict behind bmstore class
Yuya Nishihara <yuya@tcha.org>
parents:
37641
diff
changeset
|
135 |
return mark in self._refmap |
8256962e798c
bookmarks: hide dict behind bmstore class
Yuya Nishihara <yuya@tcha.org>
parents:
37641
diff
changeset
|
136 |
|
8256962e798c
bookmarks: hide dict behind bmstore class
Yuya Nishihara <yuya@tcha.org>
parents:
37641
diff
changeset
|
137 |
def __getitem__(self, mark): |
8256962e798c
bookmarks: hide dict behind bmstore class
Yuya Nishihara <yuya@tcha.org>
parents:
37641
diff
changeset
|
138 |
return self._refmap[mark] |
8256962e798c
bookmarks: hide dict behind bmstore class
Yuya Nishihara <yuya@tcha.org>
parents:
37641
diff
changeset
|
139 |
|
8256962e798c
bookmarks: hide dict behind bmstore class
Yuya Nishihara <yuya@tcha.org>
parents:
37641
diff
changeset
|
140 |
def get(self, mark, default=None): |
8256962e798c
bookmarks: hide dict behind bmstore class
Yuya Nishihara <yuya@tcha.org>
parents:
37641
diff
changeset
|
141 |
return self._refmap.get(mark, default) |
33517
08bf0ebc6c8e
bookmark: deprecate direct set of a bookmark value
Boris Feld <boris.feld@octobus.net>
parents:
33516
diff
changeset
|
142 |
|
37849
82a153e6dc4a
bookmarks: make argument names of _set/_del() more specific
Yuya Nishihara <yuya@tcha.org>
parents:
37848
diff
changeset
|
143 |
def _set(self, mark, node): |
27187
d9dcc5c09d77
bmstore: add basic clean-state tracking
Augie Fackler <augie@google.com>
parents:
27186
diff
changeset
|
144 |
self._clean = False |
37850
04ceb267271a
bookmarks: cache reverse mapping (issue5868)
Yuya Nishihara <yuya@tcha.org>
parents:
37849
diff
changeset
|
145 |
if mark in self._refmap: |
04ceb267271a
bookmarks: cache reverse mapping (issue5868)
Yuya Nishihara <yuya@tcha.org>
parents:
37849
diff
changeset
|
146 |
self._del(mark) |
37849
82a153e6dc4a
bookmarks: make argument names of _set/_del() more specific
Yuya Nishihara <yuya@tcha.org>
parents:
37848
diff
changeset
|
147 |
self._refmap[mark] = node |
37850
04ceb267271a
bookmarks: cache reverse mapping (issue5868)
Yuya Nishihara <yuya@tcha.org>
parents:
37849
diff
changeset
|
148 |
nrefs = self._nodemap.get(node) |
04ceb267271a
bookmarks: cache reverse mapping (issue5868)
Yuya Nishihara <yuya@tcha.org>
parents:
37849
diff
changeset
|
149 |
if nrefs is None: |
04ceb267271a
bookmarks: cache reverse mapping (issue5868)
Yuya Nishihara <yuya@tcha.org>
parents:
37849
diff
changeset
|
150 |
self._nodemap[node] = [mark] |
04ceb267271a
bookmarks: cache reverse mapping (issue5868)
Yuya Nishihara <yuya@tcha.org>
parents:
37849
diff
changeset
|
151 |
else: |
04ceb267271a
bookmarks: cache reverse mapping (issue5868)
Yuya Nishihara <yuya@tcha.org>
parents:
37849
diff
changeset
|
152 |
nrefs.append(mark) |
04ceb267271a
bookmarks: cache reverse mapping (issue5868)
Yuya Nishihara <yuya@tcha.org>
parents:
37849
diff
changeset
|
153 |
nrefs.sort() |
33518
712a85b3677f
bookmark: deprecate direct del of a bookmark value
Boris Feld <boris.feld@octobus.net>
parents:
33517
diff
changeset
|
154 |
|
37849
82a153e6dc4a
bookmarks: make argument names of _set/_del() more specific
Yuya Nishihara <yuya@tcha.org>
parents:
37848
diff
changeset
|
155 |
def _del(self, mark): |
27187
d9dcc5c09d77
bmstore: add basic clean-state tracking
Augie Fackler <augie@google.com>
parents:
27186
diff
changeset
|
156 |
self._clean = False |
37850
04ceb267271a
bookmarks: cache reverse mapping (issue5868)
Yuya Nishihara <yuya@tcha.org>
parents:
37849
diff
changeset
|
157 |
node = self._refmap.pop(mark) |
04ceb267271a
bookmarks: cache reverse mapping (issue5868)
Yuya Nishihara <yuya@tcha.org>
parents:
37849
diff
changeset
|
158 |
nrefs = self._nodemap[node] |
04ceb267271a
bookmarks: cache reverse mapping (issue5868)
Yuya Nishihara <yuya@tcha.org>
parents:
37849
diff
changeset
|
159 |
if len(nrefs) == 1: |
04ceb267271a
bookmarks: cache reverse mapping (issue5868)
Yuya Nishihara <yuya@tcha.org>
parents:
37849
diff
changeset
|
160 |
assert nrefs[0] == mark |
04ceb267271a
bookmarks: cache reverse mapping (issue5868)
Yuya Nishihara <yuya@tcha.org>
parents:
37849
diff
changeset
|
161 |
del self._nodemap[node] |
04ceb267271a
bookmarks: cache reverse mapping (issue5868)
Yuya Nishihara <yuya@tcha.org>
parents:
37849
diff
changeset
|
162 |
else: |
04ceb267271a
bookmarks: cache reverse mapping (issue5868)
Yuya Nishihara <yuya@tcha.org>
parents:
37849
diff
changeset
|
163 |
nrefs.remove(mark) |
35679
5a2d505a9174
bookmark: deprecate direct update of a bookmark value
Boris Feld <boris.feld@octobus.net>
parents:
35647
diff
changeset
|
164 |
|
37848
6e2259847f5f
bookmarks: extract function that looks up bookmark names by node
Yuya Nishihara <yuya@tcha.org>
parents:
37847
diff
changeset
|
165 |
def names(self, node): |
6e2259847f5f
bookmarks: extract function that looks up bookmark names by node
Yuya Nishihara <yuya@tcha.org>
parents:
37847
diff
changeset
|
166 |
"""Return a sorted list of bookmarks pointing to the specified node""" |
37850
04ceb267271a
bookmarks: cache reverse mapping (issue5868)
Yuya Nishihara <yuya@tcha.org>
parents:
37849
diff
changeset
|
167 |
return self._nodemap.get(node, []) |
37848
6e2259847f5f
bookmarks: extract function that looks up bookmark names by node
Yuya Nishihara <yuya@tcha.org>
parents:
37847
diff
changeset
|
168 |
|
37450
81d35d5d35f9
bookmarks: introduce a repo._bookmarks.changectx(mark) method and use it
Martin von Zweigbergk <martinvonz@google.com>
parents:
37397
diff
changeset
|
169 |
def changectx(self, mark): |
37847
8256962e798c
bookmarks: hide dict behind bmstore class
Yuya Nishihara <yuya@tcha.org>
parents:
37641
diff
changeset
|
170 |
node = self._refmap[mark] |
8256962e798c
bookmarks: hide dict behind bmstore class
Yuya Nishihara <yuya@tcha.org>
parents:
37641
diff
changeset
|
171 |
return self._repo[node] |
37450
81d35d5d35f9
bookmarks: introduce a repo._bookmarks.changectx(mark) method and use it
Martin von Zweigbergk <martinvonz@google.com>
parents:
37397
diff
changeset
|
172 |
|
33480
ef54789a947d
bookmark: introduce a 'applychanges' function to gather bookmark movement
Boris Feld <boris.feld@octobus.net>
parents:
33146
diff
changeset
|
173 |
def applychanges(self, repo, tr, changes): |
ef54789a947d
bookmark: introduce a 'applychanges' function to gather bookmark movement
Boris Feld <boris.feld@octobus.net>
parents:
33146
diff
changeset
|
174 |
"""Apply a list of changes to bookmarks |
ef54789a947d
bookmark: introduce a 'applychanges' function to gather bookmark movement
Boris Feld <boris.feld@octobus.net>
parents:
33146
diff
changeset
|
175 |
""" |
33516
f9e6e43c7987
bookmark: track bookmark changes at the transaction level
Boris Feld <boris.feld@octobus.net>
parents:
33515
diff
changeset
|
176 |
bmchanges = tr.changes.get('bookmarks') |
33480
ef54789a947d
bookmark: introduce a 'applychanges' function to gather bookmark movement
Boris Feld <boris.feld@octobus.net>
parents:
33146
diff
changeset
|
177 |
for name, node in changes: |
37847
8256962e798c
bookmarks: hide dict behind bmstore class
Yuya Nishihara <yuya@tcha.org>
parents:
37641
diff
changeset
|
178 |
old = self._refmap.get(name) |
33480
ef54789a947d
bookmark: introduce a 'applychanges' function to gather bookmark movement
Boris Feld <boris.feld@octobus.net>
parents:
33146
diff
changeset
|
179 |
if node is None: |
33518
712a85b3677f
bookmark: deprecate direct del of a bookmark value
Boris Feld <boris.feld@octobus.net>
parents:
33517
diff
changeset
|
180 |
self._del(name) |
33480
ef54789a947d
bookmark: introduce a 'applychanges' function to gather bookmark movement
Boris Feld <boris.feld@octobus.net>
parents:
33146
diff
changeset
|
181 |
else: |
33517
08bf0ebc6c8e
bookmark: deprecate direct set of a bookmark value
Boris Feld <boris.feld@octobus.net>
parents:
33516
diff
changeset
|
182 |
self._set(name, node) |
33516
f9e6e43c7987
bookmark: track bookmark changes at the transaction level
Boris Feld <boris.feld@octobus.net>
parents:
33515
diff
changeset
|
183 |
if bmchanges is not None: |
f9e6e43c7987
bookmark: track bookmark changes at the transaction level
Boris Feld <boris.feld@octobus.net>
parents:
33515
diff
changeset
|
184 |
# if a previous value exist preserve the "initial" value |
f9e6e43c7987
bookmark: track bookmark changes at the transaction level
Boris Feld <boris.feld@octobus.net>
parents:
33515
diff
changeset
|
185 |
previous = bmchanges.get(name) |
f9e6e43c7987
bookmark: track bookmark changes at the transaction level
Boris Feld <boris.feld@octobus.net>
parents:
33515
diff
changeset
|
186 |
if previous is not None: |
f9e6e43c7987
bookmark: track bookmark changes at the transaction level
Boris Feld <boris.feld@octobus.net>
parents:
33515
diff
changeset
|
187 |
old = previous[0] |
f9e6e43c7987
bookmark: track bookmark changes at the transaction level
Boris Feld <boris.feld@octobus.net>
parents:
33515
diff
changeset
|
188 |
bmchanges[name] = (old, node) |
33515
3325c7dcabaa
bookmark: deprecate 'recordchange' in favor of 'applychanges'
Boris Feld <boris.feld@octobus.net>
parents:
33514
diff
changeset
|
189 |
self._recordchange(tr) |
33480
ef54789a947d
bookmark: introduce a 'applychanges' function to gather bookmark movement
Boris Feld <boris.feld@octobus.net>
parents:
33146
diff
changeset
|
190 |
|
33515
3325c7dcabaa
bookmark: deprecate 'recordchange' in favor of 'applychanges'
Boris Feld <boris.feld@octobus.net>
parents:
33514
diff
changeset
|
191 |
def _recordchange(self, tr): |
22665
8319f7e78395
bookmark: add a `bmstore.recordupdate` to plug bookmarks into the transaction
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22664
diff
changeset
|
192 |
"""record that bookmarks have been changed in a transaction |
8319f7e78395
bookmark: add a `bmstore.recordupdate` to plug bookmarks into the transaction
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22664
diff
changeset
|
193 |
|
8319f7e78395
bookmark: add a `bmstore.recordupdate` to plug bookmarks into the transaction
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22664
diff
changeset
|
194 |
The transaction is then responsible for updating the file content.""" |
8319f7e78395
bookmark: add a `bmstore.recordupdate` to plug bookmarks into the transaction
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22664
diff
changeset
|
195 |
tr.addfilegenerator('bookmarks', ('bookmarks',), self._write, |
23317
197e17be5407
transaction: use 'location' instead of 'vfs' objects for file generation
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
23199
diff
changeset
|
196 |
location='plain') |
22941
da2758c0aca0
bookmarks: inform transaction-related hooks that some bookmarks were moved
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22667
diff
changeset
|
197 |
tr.hookargs['bookmark_moved'] = '1' |
22665
8319f7e78395
bookmark: add a `bmstore.recordupdate` to plug bookmarks into the transaction
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22664
diff
changeset
|
198 |
|
23469
65e48b8d20f5
bookmarks: factor out repository lookup from writing bookmarks file
Ryan McElroy <rmcelroy@fb.com>
parents:
23458
diff
changeset
|
199 |
def _writerepo(self, repo): |
65e48b8d20f5
bookmarks: factor out repository lookup from writing bookmarks file
Ryan McElroy <rmcelroy@fb.com>
parents:
23458
diff
changeset
|
200 |
"""Factored out for extensibility""" |
27698
dad6404ccddb
bmstore: add handling of the active bookmark
Augie Fackler <augie@google.com>
parents:
27685
diff
changeset
|
201 |
rbm = repo._bookmarks |
37847
8256962e798c
bookmarks: hide dict behind bmstore class
Yuya Nishihara <yuya@tcha.org>
parents:
37641
diff
changeset
|
202 |
if rbm.active not in self._refmap: |
27698
dad6404ccddb
bmstore: add handling of the active bookmark
Augie Fackler <augie@google.com>
parents:
27685
diff
changeset
|
203 |
rbm.active = None |
dad6404ccddb
bmstore: add handling of the active bookmark
Augie Fackler <augie@google.com>
parents:
27685
diff
changeset
|
204 |
rbm._writeactive() |
17922
7f5dab94e48c
bookmarks: introduce a bmstore to manage bookmark persistence
Augie Fackler <raf@durin42.com>
parents:
17918
diff
changeset
|
205 |
|
27799
24b4dbb16c60
with: use context manager for wlock in _writerepo
Bryan O'Sullivan <bryano@fb.com>
parents:
27698
diff
changeset
|
206 |
with repo.wlock(): |
29300
f92afd23a099
bookmarks: make writing files out avoid ambiguity of file stat
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
29084
diff
changeset
|
207 |
file_ = repo.vfs('bookmarks', 'w', atomictemp=True, |
f92afd23a099
bookmarks: make writing files out avoid ambiguity of file stat
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
29084
diff
changeset
|
208 |
checkambig=True) |
27188
6a1301e22bd7
bmstore: close file in a finally block in _writerepo
Augie Fackler <augie@google.com>
parents:
27187
diff
changeset
|
209 |
try: |
6a1301e22bd7
bmstore: close file in a finally block in _writerepo
Augie Fackler <augie@google.com>
parents:
27187
diff
changeset
|
210 |
self._write(file_) |
6a1301e22bd7
bmstore: close file in a finally block in _writerepo
Augie Fackler <augie@google.com>
parents:
27187
diff
changeset
|
211 |
except: # re-raises |
6a1301e22bd7
bmstore: close file in a finally block in _writerepo
Augie Fackler <augie@google.com>
parents:
27187
diff
changeset
|
212 |
file_.discard() |
6a1301e22bd7
bmstore: close file in a finally block in _writerepo
Augie Fackler <augie@google.com>
parents:
27187
diff
changeset
|
213 |
raise |
6a1301e22bd7
bmstore: close file in a finally block in _writerepo
Augie Fackler <augie@google.com>
parents:
27187
diff
changeset
|
214 |
finally: |
6a1301e22bd7
bmstore: close file in a finally block in _writerepo
Augie Fackler <augie@google.com>
parents:
27187
diff
changeset
|
215 |
file_.close() |
17922
7f5dab94e48c
bookmarks: introduce a bmstore to manage bookmark persistence
Augie Fackler <raf@durin42.com>
parents:
17918
diff
changeset
|
216 |
|
27698
dad6404ccddb
bmstore: add handling of the active bookmark
Augie Fackler <augie@google.com>
parents:
27685
diff
changeset
|
217 |
def _writeactive(self): |
dad6404ccddb
bmstore: add handling of the active bookmark
Augie Fackler <augie@google.com>
parents:
27685
diff
changeset
|
218 |
if self._aclean: |
dad6404ccddb
bmstore: add handling of the active bookmark
Augie Fackler <augie@google.com>
parents:
27685
diff
changeset
|
219 |
return |
27800
1c5f2c2c046b
with: use context manager for wlock in _writeactive
Bryan O'Sullivan <bryano@fb.com>
parents:
27799
diff
changeset
|
220 |
with self._repo.wlock(): |
27698
dad6404ccddb
bmstore: add handling of the active bookmark
Augie Fackler <augie@google.com>
parents:
27685
diff
changeset
|
221 |
if self._active is not None: |
29300
f92afd23a099
bookmarks: make writing files out avoid ambiguity of file stat
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
29084
diff
changeset
|
222 |
f = self._repo.vfs('bookmarks.current', 'w', atomictemp=True, |
f92afd23a099
bookmarks: make writing files out avoid ambiguity of file stat
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
29084
diff
changeset
|
223 |
checkambig=True) |
27698
dad6404ccddb
bmstore: add handling of the active bookmark
Augie Fackler <augie@google.com>
parents:
27685
diff
changeset
|
224 |
try: |
dad6404ccddb
bmstore: add handling of the active bookmark
Augie Fackler <augie@google.com>
parents:
27685
diff
changeset
|
225 |
f.write(encoding.fromlocal(self._active)) |
dad6404ccddb
bmstore: add handling of the active bookmark
Augie Fackler <augie@google.com>
parents:
27685
diff
changeset
|
226 |
finally: |
dad6404ccddb
bmstore: add handling of the active bookmark
Augie Fackler <augie@google.com>
parents:
27685
diff
changeset
|
227 |
f.close() |
dad6404ccddb
bmstore: add handling of the active bookmark
Augie Fackler <augie@google.com>
parents:
27685
diff
changeset
|
228 |
else: |
31544 | 229 |
self._repo.vfs.tryunlink('bookmarks.current') |
27698
dad6404ccddb
bmstore: add handling of the active bookmark
Augie Fackler <augie@google.com>
parents:
27685
diff
changeset
|
230 |
self._aclean = True |
dad6404ccddb
bmstore: add handling of the active bookmark
Augie Fackler <augie@google.com>
parents:
27685
diff
changeset
|
231 |
|
22664
6bd685d2a2de
bookmarks: split bookmark serialization and file handling
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22659
diff
changeset
|
232 |
def _write(self, fp): |
37847
8256962e798c
bookmarks: hide dict behind bmstore class
Yuya Nishihara <yuya@tcha.org>
parents:
37641
diff
changeset
|
233 |
for name, node in sorted(self._refmap.iteritems()): |
22664
6bd685d2a2de
bookmarks: split bookmark serialization and file handling
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22659
diff
changeset
|
234 |
fp.write("%s %s\n" % (hex(node), encoding.fromlocal(name))) |
27187
d9dcc5c09d77
bmstore: add basic clean-state tracking
Augie Fackler <augie@google.com>
parents:
27186
diff
changeset
|
235 |
self._clean = True |
29066
e6f490e32863
bookmarks: properly invalidate volatile sets when writing bookmarks
Augie Fackler <augie@google.com>
parents:
28182
diff
changeset
|
236 |
self._repo.invalidatevolatilesets() |
22664
6bd685d2a2de
bookmarks: split bookmark serialization and file handling
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22659
diff
changeset
|
237 |
|
28182
e4fe4e903e97
bookmarks: add 'hg push -B .' for pushing the active bookmark (issue4917)
liscju <piotr.listkiewicz@gmail.com>
parents:
27800
diff
changeset
|
238 |
def expandname(self, bname): |
e4fe4e903e97
bookmarks: add 'hg push -B .' for pushing the active bookmark (issue4917)
liscju <piotr.listkiewicz@gmail.com>
parents:
27800
diff
changeset
|
239 |
if bname == '.': |
29354
af849596752c
bookmarks: abort 'push -B .' when no active bookmark
liscju <piotr.listkiewicz@gmail.com>
parents:
29300
diff
changeset
|
240 |
if self.active: |
af849596752c
bookmarks: abort 'push -B .' when no active bookmark
liscju <piotr.listkiewicz@gmail.com>
parents:
29300
diff
changeset
|
241 |
return self.active |
af849596752c
bookmarks: abort 'push -B .' when no active bookmark
liscju <piotr.listkiewicz@gmail.com>
parents:
29300
diff
changeset
|
242 |
else: |
39304
fc54a290b4b0
bookmarks: adjust exception type so present(bookmark(.)) works as expected
Yuya Nishihara <yuya@tcha.org>
parents:
38670
diff
changeset
|
243 |
raise error.RepoLookupError(_("no active bookmark")) |
28182
e4fe4e903e97
bookmarks: add 'hg push -B .' for pushing the active bookmark (issue4917)
liscju <piotr.listkiewicz@gmail.com>
parents:
27800
diff
changeset
|
244 |
return bname |
e4fe4e903e97
bookmarks: add 'hg push -B .' for pushing the active bookmark (issue4917)
liscju <piotr.listkiewicz@gmail.com>
parents:
27800
diff
changeset
|
245 |
|
32956
4f0a7f604449
commands: move checkconflict to bookmarks module
Sean Farley <sean@farley.io>
parents:
32955
diff
changeset
|
246 |
def checkconflict(self, mark, force=False, target=None): |
4f0a7f604449
commands: move checkconflict to bookmarks module
Sean Farley <sean@farley.io>
parents:
32955
diff
changeset
|
247 |
"""check repo for a potential clash of mark with an existing bookmark, |
4f0a7f604449
commands: move checkconflict to bookmarks module
Sean Farley <sean@farley.io>
parents:
32955
diff
changeset
|
248 |
branch, or hash |
4f0a7f604449
commands: move checkconflict to bookmarks module
Sean Farley <sean@farley.io>
parents:
32955
diff
changeset
|
249 |
|
4f0a7f604449
commands: move checkconflict to bookmarks module
Sean Farley <sean@farley.io>
parents:
32955
diff
changeset
|
250 |
If target is supplied, then check that we are moving the bookmark |
4f0a7f604449
commands: move checkconflict to bookmarks module
Sean Farley <sean@farley.io>
parents:
32955
diff
changeset
|
251 |
forward. |
4f0a7f604449
commands: move checkconflict to bookmarks module
Sean Farley <sean@farley.io>
parents:
32955
diff
changeset
|
252 |
|
4f0a7f604449
commands: move checkconflict to bookmarks module
Sean Farley <sean@farley.io>
parents:
32955
diff
changeset
|
253 |
If force is supplied, then forcibly move the bookmark to a new commit |
4f0a7f604449
commands: move checkconflict to bookmarks module
Sean Farley <sean@farley.io>
parents:
32955
diff
changeset
|
254 |
regardless if it is a move forward. |
33513
904894edb205
bookmark: use 'divergent2delete' in checkconflict
Boris Feld <boris.feld@octobus.net>
parents:
33512
diff
changeset
|
255 |
|
904894edb205
bookmark: use 'divergent2delete' in checkconflict
Boris Feld <boris.feld@octobus.net>
parents:
33512
diff
changeset
|
256 |
If divergent bookmark are to be deleted, they will be returned as list. |
32956
4f0a7f604449
commands: move checkconflict to bookmarks module
Sean Farley <sean@farley.io>
parents:
32955
diff
changeset
|
257 |
""" |
37301
a494cccb673e
bookmarks: switch from repo.changectx('.') to repo['.']
Martin von Zweigbergk <martinvonz@google.com>
parents:
36568
diff
changeset
|
258 |
cur = self._repo['.'].node() |
37847
8256962e798c
bookmarks: hide dict behind bmstore class
Yuya Nishihara <yuya@tcha.org>
parents:
37641
diff
changeset
|
259 |
if mark in self._refmap and not force: |
32956
4f0a7f604449
commands: move checkconflict to bookmarks module
Sean Farley <sean@farley.io>
parents:
32955
diff
changeset
|
260 |
if target: |
37847
8256962e798c
bookmarks: hide dict behind bmstore class
Yuya Nishihara <yuya@tcha.org>
parents:
37641
diff
changeset
|
261 |
if self._refmap[mark] == target and target == cur: |
32956
4f0a7f604449
commands: move checkconflict to bookmarks module
Sean Farley <sean@farley.io>
parents:
32955
diff
changeset
|
262 |
# re-activating a bookmark |
33513
904894edb205
bookmark: use 'divergent2delete' in checkconflict
Boris Feld <boris.feld@octobus.net>
parents:
33512
diff
changeset
|
263 |
return [] |
32956
4f0a7f604449
commands: move checkconflict to bookmarks module
Sean Farley <sean@farley.io>
parents:
32955
diff
changeset
|
264 |
rev = self._repo[target].rev() |
4f0a7f604449
commands: move checkconflict to bookmarks module
Sean Farley <sean@farley.io>
parents:
32955
diff
changeset
|
265 |
anc = self._repo.changelog.ancestors([rev]) |
37450
81d35d5d35f9
bookmarks: introduce a repo._bookmarks.changectx(mark) method and use it
Martin von Zweigbergk <martinvonz@google.com>
parents:
37397
diff
changeset
|
266 |
bmctx = self.changectx(mark) |
37847
8256962e798c
bookmarks: hide dict behind bmstore class
Yuya Nishihara <yuya@tcha.org>
parents:
37641
diff
changeset
|
267 |
divs = [self._refmap[b] for b in self._refmap |
32956
4f0a7f604449
commands: move checkconflict to bookmarks module
Sean Farley <sean@farley.io>
parents:
32955
diff
changeset
|
268 |
if b.split('@', 1)[0] == mark.split('@', 1)[0]] |
4f0a7f604449
commands: move checkconflict to bookmarks module
Sean Farley <sean@farley.io>
parents:
32955
diff
changeset
|
269 |
|
4f0a7f604449
commands: move checkconflict to bookmarks module
Sean Farley <sean@farley.io>
parents:
32955
diff
changeset
|
270 |
# allow resolving a single divergent bookmark even if moving |
4f0a7f604449
commands: move checkconflict to bookmarks module
Sean Farley <sean@farley.io>
parents:
32955
diff
changeset
|
271 |
# the bookmark across branches when a revision is specified |
4f0a7f604449
commands: move checkconflict to bookmarks module
Sean Farley <sean@farley.io>
parents:
32955
diff
changeset
|
272 |
# that contains a divergent bookmark |
4f0a7f604449
commands: move checkconflict to bookmarks module
Sean Farley <sean@farley.io>
parents:
32955
diff
changeset
|
273 |
if bmctx.rev() not in anc and target in divs: |
33513
904894edb205
bookmark: use 'divergent2delete' in checkconflict
Boris Feld <boris.feld@octobus.net>
parents:
33512
diff
changeset
|
274 |
return divergent2delete(self._repo, [target], mark) |
32956
4f0a7f604449
commands: move checkconflict to bookmarks module
Sean Farley <sean@farley.io>
parents:
32955
diff
changeset
|
275 |
|
4f0a7f604449
commands: move checkconflict to bookmarks module
Sean Farley <sean@farley.io>
parents:
32955
diff
changeset
|
276 |
deletefrom = [b for b in divs |
4f0a7f604449
commands: move checkconflict to bookmarks module
Sean Farley <sean@farley.io>
parents:
32955
diff
changeset
|
277 |
if self._repo[b].rev() in anc or b == target] |
33513
904894edb205
bookmark: use 'divergent2delete' in checkconflict
Boris Feld <boris.feld@octobus.net>
parents:
33512
diff
changeset
|
278 |
delbms = divergent2delete(self._repo, deletefrom, mark) |
32956
4f0a7f604449
commands: move checkconflict to bookmarks module
Sean Farley <sean@farley.io>
parents:
32955
diff
changeset
|
279 |
if validdest(self._repo, bmctx, self._repo[target]): |
4f0a7f604449
commands: move checkconflict to bookmarks module
Sean Farley <sean@farley.io>
parents:
32955
diff
changeset
|
280 |
self._repo.ui.status( |
4f0a7f604449
commands: move checkconflict to bookmarks module
Sean Farley <sean@farley.io>
parents:
32955
diff
changeset
|
281 |
_("moving bookmark '%s' forward from %s\n") % |
4f0a7f604449
commands: move checkconflict to bookmarks module
Sean Farley <sean@farley.io>
parents:
32955
diff
changeset
|
282 |
(mark, short(bmctx.node()))) |
33513
904894edb205
bookmark: use 'divergent2delete' in checkconflict
Boris Feld <boris.feld@octobus.net>
parents:
33512
diff
changeset
|
283 |
return delbms |
32956
4f0a7f604449
commands: move checkconflict to bookmarks module
Sean Farley <sean@farley.io>
parents:
32955
diff
changeset
|
284 |
raise error.Abort(_("bookmark '%s' already exists " |
4f0a7f604449
commands: move checkconflict to bookmarks module
Sean Farley <sean@farley.io>
parents:
32955
diff
changeset
|
285 |
"(use -f to force)") % mark) |
4f0a7f604449
commands: move checkconflict to bookmarks module
Sean Farley <sean@farley.io>
parents:
32955
diff
changeset
|
286 |
if ((mark in self._repo.branchmap() or |
4f0a7f604449
commands: move checkconflict to bookmarks module
Sean Farley <sean@farley.io>
parents:
32955
diff
changeset
|
287 |
mark == self._repo.dirstate.branch()) and not force): |
4f0a7f604449
commands: move checkconflict to bookmarks module
Sean Farley <sean@farley.io>
parents:
32955
diff
changeset
|
288 |
raise error.Abort( |
4f0a7f604449
commands: move checkconflict to bookmarks module
Sean Farley <sean@farley.io>
parents:
32955
diff
changeset
|
289 |
_("a bookmark cannot have the name of an existing branch")) |
4f0a7f604449
commands: move checkconflict to bookmarks module
Sean Farley <sean@farley.io>
parents:
32955
diff
changeset
|
290 |
if len(mark) > 3 and not force: |
4f0a7f604449
commands: move checkconflict to bookmarks module
Sean Farley <sean@farley.io>
parents:
32955
diff
changeset
|
291 |
try: |
37397
46d9f998c3ed
bookmarks: use isrevsymbol() for detecting collision with existing symbol
Martin von Zweigbergk <martinvonz@google.com>
parents:
37375
diff
changeset
|
292 |
shadowhash = scmutil.isrevsymbol(self._repo, mark) |
32956
4f0a7f604449
commands: move checkconflict to bookmarks module
Sean Farley <sean@farley.io>
parents:
32955
diff
changeset
|
293 |
except error.LookupError: # ambiguous identifier |
4f0a7f604449
commands: move checkconflict to bookmarks module
Sean Farley <sean@farley.io>
parents:
32955
diff
changeset
|
294 |
shadowhash = False |
4f0a7f604449
commands: move checkconflict to bookmarks module
Sean Farley <sean@farley.io>
parents:
32955
diff
changeset
|
295 |
if shadowhash: |
4f0a7f604449
commands: move checkconflict to bookmarks module
Sean Farley <sean@farley.io>
parents:
32955
diff
changeset
|
296 |
self._repo.ui.warn( |
4f0a7f604449
commands: move checkconflict to bookmarks module
Sean Farley <sean@farley.io>
parents:
32955
diff
changeset
|
297 |
_("bookmark %s matches a changeset hash\n" |
4f0a7f604449
commands: move checkconflict to bookmarks module
Sean Farley <sean@farley.io>
parents:
32955
diff
changeset
|
298 |
"(did you leave a -r out of an 'hg bookmark' " |
4f0a7f604449
commands: move checkconflict to bookmarks module
Sean Farley <sean@farley.io>
parents:
32955
diff
changeset
|
299 |
"command?)\n") |
4f0a7f604449
commands: move checkconflict to bookmarks module
Sean Farley <sean@farley.io>
parents:
32955
diff
changeset
|
300 |
% mark) |
33513
904894edb205
bookmark: use 'divergent2delete' in checkconflict
Boris Feld <boris.feld@octobus.net>
parents:
33512
diff
changeset
|
301 |
return [] |
32956
4f0a7f604449
commands: move checkconflict to bookmarks module
Sean Farley <sean@farley.io>
parents:
32955
diff
changeset
|
302 |
|
27698
dad6404ccddb
bmstore: add handling of the active bookmark
Augie Fackler <augie@google.com>
parents:
27685
diff
changeset
|
303 |
def _readactive(repo, marks): |
24946
c44534209a0a
bookmarks: rename readcurrent to readactive (API)
Ryan McElroy <rmcelroy@fb.com>
parents:
24945
diff
changeset
|
304 |
""" |
c44534209a0a
bookmarks: rename readcurrent to readactive (API)
Ryan McElroy <rmcelroy@fb.com>
parents:
24945
diff
changeset
|
305 |
Get the active bookmark. We can have an active bookmark that updates |
c44534209a0a
bookmarks: rename readcurrent to readactive (API)
Ryan McElroy <rmcelroy@fb.com>
parents:
24945
diff
changeset
|
306 |
itself as we commit. This function returns the name of that bookmark. |
c44534209a0a
bookmarks: rename readcurrent to readactive (API)
Ryan McElroy <rmcelroy@fb.com>
parents:
24945
diff
changeset
|
307 |
It is stored in .hg/bookmarks.current |
c44534209a0a
bookmarks: rename readcurrent to readactive (API)
Ryan McElroy <rmcelroy@fb.com>
parents:
24945
diff
changeset
|
308 |
""" |
13351
6c5368cd2df9
bookmarks: move read methods to core
Matt Mackall <mpm@selenic.com>
parents:
13350
diff
changeset
|
309 |
mark = None |
14027
78ab705a8147
bookmarks: be more restrictive in our Exception catching
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
14004
diff
changeset
|
310 |
try: |
23877
7cc77030c557
localrepo: remove all external users of localrepo.opener
Angel Ezquerra <angel.ezquerra@gmail.com>
parents:
23469
diff
changeset
|
311 |
file = repo.vfs('bookmarks.current') |
25660
328739ea70c3
global: mass rewrite to use modern exception syntax
Gregory Szorc <gregory.szorc@gmail.com>
parents:
25569
diff
changeset
|
312 |
except IOError as inst: |
14027
78ab705a8147
bookmarks: be more restrictive in our Exception catching
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
14004
diff
changeset
|
313 |
if inst.errno != errno.ENOENT: |
78ab705a8147
bookmarks: be more restrictive in our Exception catching
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
14004
diff
changeset
|
314 |
raise |
78ab705a8147
bookmarks: be more restrictive in our Exception catching
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
14004
diff
changeset
|
315 |
return None |
78ab705a8147
bookmarks: be more restrictive in our Exception catching
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
14004
diff
changeset
|
316 |
try: |
27685
9fbae70faf65
bookmarks: make _readactive safe when readlines raises ENOENT
Augie Fackler <augie@google.com>
parents:
27276
diff
changeset
|
317 |
# No readline() in osutil.posixfile, reading everything is |
9fbae70faf65
bookmarks: make _readactive safe when readlines raises ENOENT
Augie Fackler <augie@google.com>
parents:
27276
diff
changeset
|
318 |
# cheap. |
9fbae70faf65
bookmarks: make _readactive safe when readlines raises ENOENT
Augie Fackler <augie@google.com>
parents:
27276
diff
changeset
|
319 |
# Note that it's possible for readlines() here to raise |
9fbae70faf65
bookmarks: make _readactive safe when readlines raises ENOENT
Augie Fackler <augie@google.com>
parents:
27276
diff
changeset
|
320 |
# IOError, since we might be reading the active mark over |
9fbae70faf65
bookmarks: make _readactive safe when readlines raises ENOENT
Augie Fackler <augie@google.com>
parents:
27276
diff
changeset
|
321 |
# static-http which only tries to load the file when we try |
9fbae70faf65
bookmarks: make _readactive safe when readlines raises ENOENT
Augie Fackler <augie@google.com>
parents:
27276
diff
changeset
|
322 |
# to read from it. |
13381
d073468e3c5f
bookmarks: read current bookmark as utf-8 and convert it to local
David Soria Parra <dsp@php.net>
parents:
13354
diff
changeset
|
323 |
mark = encoding.tolocal((file.readlines() or [''])[0]) |
27698
dad6404ccddb
bmstore: add handling of the active bookmark
Augie Fackler <augie@google.com>
parents:
27685
diff
changeset
|
324 |
if mark == '' or mark not in marks: |
13351
6c5368cd2df9
bookmarks: move read methods to core
Matt Mackall <mpm@selenic.com>
parents:
13350
diff
changeset
|
325 |
mark = None |
27685
9fbae70faf65
bookmarks: make _readactive safe when readlines raises ENOENT
Augie Fackler <augie@google.com>
parents:
27276
diff
changeset
|
326 |
except IOError as inst: |
9fbae70faf65
bookmarks: make _readactive safe when readlines raises ENOENT
Augie Fackler <augie@google.com>
parents:
27276
diff
changeset
|
327 |
if inst.errno != errno.ENOENT: |
9fbae70faf65
bookmarks: make _readactive safe when readlines raises ENOENT
Augie Fackler <augie@google.com>
parents:
27276
diff
changeset
|
328 |
raise |
9fbae70faf65
bookmarks: make _readactive safe when readlines raises ENOENT
Augie Fackler <augie@google.com>
parents:
27276
diff
changeset
|
329 |
return None |
14027
78ab705a8147
bookmarks: be more restrictive in our Exception catching
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
14004
diff
changeset
|
330 |
finally: |
13351
6c5368cd2df9
bookmarks: move read methods to core
Matt Mackall <mpm@selenic.com>
parents:
13350
diff
changeset
|
331 |
file.close() |
6c5368cd2df9
bookmarks: move read methods to core
Matt Mackall <mpm@selenic.com>
parents:
13350
diff
changeset
|
332 |
return mark |
6c5368cd2df9
bookmarks: move read methods to core
Matt Mackall <mpm@selenic.com>
parents:
13350
diff
changeset
|
333 |
|
24945
e0b0fbd47491
bookmarks: rename setcurrent to activate (API)
Ryan McElroy <rmcelroy@fb.com>
parents:
24944
diff
changeset
|
334 |
def activate(repo, mark): |
e0b0fbd47491
bookmarks: rename setcurrent to activate (API)
Ryan McElroy <rmcelroy@fb.com>
parents:
24944
diff
changeset
|
335 |
""" |
e0b0fbd47491
bookmarks: rename setcurrent to activate (API)
Ryan McElroy <rmcelroy@fb.com>
parents:
24944
diff
changeset
|
336 |
Set the given bookmark to be 'active', meaning that this bookmark will |
e0b0fbd47491
bookmarks: rename setcurrent to activate (API)
Ryan McElroy <rmcelroy@fb.com>
parents:
24944
diff
changeset
|
337 |
follow new commits that are made. |
13350
a7376b92caaa
bookmarks: move basic io to core
Matt Mackall <mpm@selenic.com>
parents:
diff
changeset
|
338 |
The name is recorded in .hg/bookmarks.current |
24945
e0b0fbd47491
bookmarks: rename setcurrent to activate (API)
Ryan McElroy <rmcelroy@fb.com>
parents:
24944
diff
changeset
|
339 |
""" |
27698
dad6404ccddb
bmstore: add handling of the active bookmark
Augie Fackler <augie@google.com>
parents:
27685
diff
changeset
|
340 |
repo._bookmarks.active = mark |
dad6404ccddb
bmstore: add handling of the active bookmark
Augie Fackler <augie@google.com>
parents:
27685
diff
changeset
|
341 |
repo._bookmarks._writeactive() |
13352
f9cd37fca5ba
bookmarks: move update into core
Matt Mackall <mpm@selenic.com>
parents:
13351
diff
changeset
|
342 |
|
24944
08ec11e3ae4c
bookmarks: rename unsetcurrent to deactivate (API)
Ryan McElroy <rmcelroy@fb.com>
parents:
24832
diff
changeset
|
343 |
def deactivate(repo): |
08ec11e3ae4c
bookmarks: rename unsetcurrent to deactivate (API)
Ryan McElroy <rmcelroy@fb.com>
parents:
24832
diff
changeset
|
344 |
""" |
26781
1aee2ab0f902
spelling: trivial spell checking
Mads Kiilerich <madski@unity3d.com>
parents:
26520
diff
changeset
|
345 |
Unset the active bookmark in this repository. |
24944
08ec11e3ae4c
bookmarks: rename unsetcurrent to deactivate (API)
Ryan McElroy <rmcelroy@fb.com>
parents:
24832
diff
changeset
|
346 |
""" |
27698
dad6404ccddb
bmstore: add handling of the active bookmark
Augie Fackler <augie@google.com>
parents:
27685
diff
changeset
|
347 |
repo._bookmarks.active = None |
dad6404ccddb
bmstore: add handling of the active bookmark
Augie Fackler <augie@google.com>
parents:
27685
diff
changeset
|
348 |
repo._bookmarks._writeactive() |
16191
7c75924a6926
update: delete bookmarks.current when explicitly updating to a rev (issue3276)
Idan Kamara <idankk86@gmail.com>
parents:
15984
diff
changeset
|
349 |
|
24986
fb9b7b937b3e
bookmarks: simplify iscurrent to isactivewdirparent (API)
Ryan McElroy <rmcelroy@fb.com>
parents:
24962
diff
changeset
|
350 |
def isactivewdirparent(repo): |
fb9b7b937b3e
bookmarks: simplify iscurrent to isactivewdirparent (API)
Ryan McElroy <rmcelroy@fb.com>
parents:
24962
diff
changeset
|
351 |
""" |
fb9b7b937b3e
bookmarks: simplify iscurrent to isactivewdirparent (API)
Ryan McElroy <rmcelroy@fb.com>
parents:
24962
diff
changeset
|
352 |
Tell whether the 'active' bookmark (the one that follows new commits) |
fb9b7b937b3e
bookmarks: simplify iscurrent to isactivewdirparent (API)
Ryan McElroy <rmcelroy@fb.com>
parents:
24962
diff
changeset
|
353 |
points to one of the parents of the current working directory (wdir). |
18471
2096e025a728
update: update to current bookmark if it moved out from under us (issue3682)
Kevin Bullock <kbullock@ringworld.org>
parents:
18363
diff
changeset
|
354 |
|
24986
fb9b7b937b3e
bookmarks: simplify iscurrent to isactivewdirparent (API)
Ryan McElroy <rmcelroy@fb.com>
parents:
24962
diff
changeset
|
355 |
While this is normally the case, it can on occasion be false; for example, |
fb9b7b937b3e
bookmarks: simplify iscurrent to isactivewdirparent (API)
Ryan McElroy <rmcelroy@fb.com>
parents:
24962
diff
changeset
|
356 |
immediately after a pull, the active bookmark can be moved to point |
fb9b7b937b3e
bookmarks: simplify iscurrent to isactivewdirparent (API)
Ryan McElroy <rmcelroy@fb.com>
parents:
24962
diff
changeset
|
357 |
to a place different than the wdir. This is solved by running `hg update`. |
fb9b7b937b3e
bookmarks: simplify iscurrent to isactivewdirparent (API)
Ryan McElroy <rmcelroy@fb.com>
parents:
24962
diff
changeset
|
358 |
""" |
fb9b7b937b3e
bookmarks: simplify iscurrent to isactivewdirparent (API)
Ryan McElroy <rmcelroy@fb.com>
parents:
24962
diff
changeset
|
359 |
mark = repo._activebookmark |
18471
2096e025a728
update: update to current bookmark if it moved out from under us (issue3682)
Kevin Bullock <kbullock@ringworld.org>
parents:
18363
diff
changeset
|
360 |
marks = repo._bookmarks |
24986
fb9b7b937b3e
bookmarks: simplify iscurrent to isactivewdirparent (API)
Ryan McElroy <rmcelroy@fb.com>
parents:
24962
diff
changeset
|
361 |
parents = [p.node() for p in repo[None].parents()] |
18471
2096e025a728
update: update to current bookmark if it moved out from under us (issue3682)
Kevin Bullock <kbullock@ringworld.org>
parents:
18363
diff
changeset
|
362 |
return (mark in marks and marks[mark] in parents) |
2096e025a728
update: update to current bookmark if it moved out from under us (issue3682)
Kevin Bullock <kbullock@ringworld.org>
parents:
18363
diff
changeset
|
363 |
|
33510
07b556d1b74e
bookmark: split out target computation from 'deletedivergent'
Boris Feld <boris.feld@octobus.net>
parents:
33499
diff
changeset
|
364 |
def divergent2delete(repo, deletefrom, bm): |
07b556d1b74e
bookmark: split out target computation from 'deletedivergent'
Boris Feld <boris.feld@octobus.net>
parents:
33499
diff
changeset
|
365 |
"""find divergent versions of bm on nodes in deletefrom. |
07b556d1b74e
bookmark: split out target computation from 'deletedivergent'
Boris Feld <boris.feld@octobus.net>
parents:
33499
diff
changeset
|
366 |
|
07b556d1b74e
bookmark: split out target computation from 'deletedivergent'
Boris Feld <boris.feld@octobus.net>
parents:
33499
diff
changeset
|
367 |
the list of bookmark to delete.""" |
07b556d1b74e
bookmark: split out target computation from 'deletedivergent'
Boris Feld <boris.feld@octobus.net>
parents:
33499
diff
changeset
|
368 |
todelete = [] |
18513
37ce336ab2dd
bookmarks: factor out delete divergent code
Siddharth Agarwal <sid0@fb.com>
parents:
18496
diff
changeset
|
369 |
marks = repo._bookmarks |
37ce336ab2dd
bookmarks: factor out delete divergent code
Siddharth Agarwal <sid0@fb.com>
parents:
18496
diff
changeset
|
370 |
divergent = [b for b in marks if b.split('@', 1)[0] == bm.split('@', 1)[0]] |
37ce336ab2dd
bookmarks: factor out delete divergent code
Siddharth Agarwal <sid0@fb.com>
parents:
18496
diff
changeset
|
371 |
for mark in divergent: |
21843
92666a869ea4
bookmarks: avoid deleting primary bookmarks on rebase
Matt Mackall <mpm@selenic.com>
parents:
20352
diff
changeset
|
372 |
if mark == '@' or '@' not in mark: |
92666a869ea4
bookmarks: avoid deleting primary bookmarks on rebase
Matt Mackall <mpm@selenic.com>
parents:
20352
diff
changeset
|
373 |
# can't be divergent by definition |
92666a869ea4
bookmarks: avoid deleting primary bookmarks on rebase
Matt Mackall <mpm@selenic.com>
parents:
20352
diff
changeset
|
374 |
continue |
18513
37ce336ab2dd
bookmarks: factor out delete divergent code
Siddharth Agarwal <sid0@fb.com>
parents:
18496
diff
changeset
|
375 |
if mark and marks[mark] in deletefrom: |
37ce336ab2dd
bookmarks: factor out delete divergent code
Siddharth Agarwal <sid0@fb.com>
parents:
18496
diff
changeset
|
376 |
if mark != bm: |
33510
07b556d1b74e
bookmark: split out target computation from 'deletedivergent'
Boris Feld <boris.feld@octobus.net>
parents:
33499
diff
changeset
|
377 |
todelete.append(mark) |
07b556d1b74e
bookmark: split out target computation from 'deletedivergent'
Boris Feld <boris.feld@octobus.net>
parents:
33499
diff
changeset
|
378 |
return todelete |
18513
37ce336ab2dd
bookmarks: factor out delete divergent code
Siddharth Agarwal <sid0@fb.com>
parents:
18496
diff
changeset
|
379 |
|
32381
b9942bc6b292
localrepo: extract bookmarkheads method to bookmarks.py
Augie Fackler <augie@google.com>
parents:
31544
diff
changeset
|
380 |
def headsforactive(repo): |
b9942bc6b292
localrepo: extract bookmarkheads method to bookmarks.py
Augie Fackler <augie@google.com>
parents:
31544
diff
changeset
|
381 |
"""Given a repo with an active bookmark, return divergent bookmark nodes. |
b9942bc6b292
localrepo: extract bookmarkheads method to bookmarks.py
Augie Fackler <augie@google.com>
parents:
31544
diff
changeset
|
382 |
|
b9942bc6b292
localrepo: extract bookmarkheads method to bookmarks.py
Augie Fackler <augie@google.com>
parents:
31544
diff
changeset
|
383 |
Args: |
b9942bc6b292
localrepo: extract bookmarkheads method to bookmarks.py
Augie Fackler <augie@google.com>
parents:
31544
diff
changeset
|
384 |
repo: A repository with an active bookmark. |
b9942bc6b292
localrepo: extract bookmarkheads method to bookmarks.py
Augie Fackler <augie@google.com>
parents:
31544
diff
changeset
|
385 |
|
b9942bc6b292
localrepo: extract bookmarkheads method to bookmarks.py
Augie Fackler <augie@google.com>
parents:
31544
diff
changeset
|
386 |
Returns: |
b9942bc6b292
localrepo: extract bookmarkheads method to bookmarks.py
Augie Fackler <augie@google.com>
parents:
31544
diff
changeset
|
387 |
A list of binary node ids that is the full list of other |
b9942bc6b292
localrepo: extract bookmarkheads method to bookmarks.py
Augie Fackler <augie@google.com>
parents:
31544
diff
changeset
|
388 |
revisions with bookmarks divergent from the active bookmark. If |
b9942bc6b292
localrepo: extract bookmarkheads method to bookmarks.py
Augie Fackler <augie@google.com>
parents:
31544
diff
changeset
|
389 |
there were no divergent bookmarks, then this list will contain |
b9942bc6b292
localrepo: extract bookmarkheads method to bookmarks.py
Augie Fackler <augie@google.com>
parents:
31544
diff
changeset
|
390 |
only one entry. |
b9942bc6b292
localrepo: extract bookmarkheads method to bookmarks.py
Augie Fackler <augie@google.com>
parents:
31544
diff
changeset
|
391 |
""" |
b9942bc6b292
localrepo: extract bookmarkheads method to bookmarks.py
Augie Fackler <augie@google.com>
parents:
31544
diff
changeset
|
392 |
if not repo._activebookmark: |
b9942bc6b292
localrepo: extract bookmarkheads method to bookmarks.py
Augie Fackler <augie@google.com>
parents:
31544
diff
changeset
|
393 |
raise ValueError( |
b9942bc6b292
localrepo: extract bookmarkheads method to bookmarks.py
Augie Fackler <augie@google.com>
parents:
31544
diff
changeset
|
394 |
'headsforactive() only makes sense with an active bookmark') |
b9942bc6b292
localrepo: extract bookmarkheads method to bookmarks.py
Augie Fackler <augie@google.com>
parents:
31544
diff
changeset
|
395 |
name = repo._activebookmark.split('@', 1)[0] |
b9942bc6b292
localrepo: extract bookmarkheads method to bookmarks.py
Augie Fackler <augie@google.com>
parents:
31544
diff
changeset
|
396 |
heads = [] |
b9942bc6b292
localrepo: extract bookmarkheads method to bookmarks.py
Augie Fackler <augie@google.com>
parents:
31544
diff
changeset
|
397 |
for mark, n in repo._bookmarks.iteritems(): |
b9942bc6b292
localrepo: extract bookmarkheads method to bookmarks.py
Augie Fackler <augie@google.com>
parents:
31544
diff
changeset
|
398 |
if mark.split('@', 1)[0] == name: |
b9942bc6b292
localrepo: extract bookmarkheads method to bookmarks.py
Augie Fackler <augie@google.com>
parents:
31544
diff
changeset
|
399 |
heads.append(n) |
b9942bc6b292
localrepo: extract bookmarkheads method to bookmarks.py
Augie Fackler <augie@google.com>
parents:
31544
diff
changeset
|
400 |
return heads |
b9942bc6b292
localrepo: extract bookmarkheads method to bookmarks.py
Augie Fackler <augie@google.com>
parents:
31544
diff
changeset
|
401 |
|
37375
a973bb92ab71
bookmarks: drop always-None argument from calculateupdate()
Martin von Zweigbergk <martinvonz@google.com>
parents:
37359
diff
changeset
|
402 |
def calculateupdate(ui, repo): |
37359
e27298bf11dd
bookmarks: calculateupdate() returns a bookmark, not a rev
Martin von Zweigbergk <martinvonz@google.com>
parents:
37301
diff
changeset
|
403 |
'''Return a tuple (activemark, movemarkfrom) indicating the active bookmark |
e27298bf11dd
bookmarks: calculateupdate() returns a bookmark, not a rev
Martin von Zweigbergk <martinvonz@google.com>
parents:
37301
diff
changeset
|
404 |
and where to move the active bookmark from, if needed.''' |
37375
a973bb92ab71
bookmarks: drop always-None argument from calculateupdate()
Martin von Zweigbergk <martinvonz@google.com>
parents:
37359
diff
changeset
|
405 |
checkout, movemarkfrom = None, None |
a973bb92ab71
bookmarks: drop always-None argument from calculateupdate()
Martin von Zweigbergk <martinvonz@google.com>
parents:
37359
diff
changeset
|
406 |
activemark = repo._activebookmark |
a973bb92ab71
bookmarks: drop always-None argument from calculateupdate()
Martin von Zweigbergk <martinvonz@google.com>
parents:
37359
diff
changeset
|
407 |
if isactivewdirparent(repo): |
a973bb92ab71
bookmarks: drop always-None argument from calculateupdate()
Martin von Zweigbergk <martinvonz@google.com>
parents:
37359
diff
changeset
|
408 |
movemarkfrom = repo['.'].node() |
a973bb92ab71
bookmarks: drop always-None argument from calculateupdate()
Martin von Zweigbergk <martinvonz@google.com>
parents:
37359
diff
changeset
|
409 |
elif activemark: |
a973bb92ab71
bookmarks: drop always-None argument from calculateupdate()
Martin von Zweigbergk <martinvonz@google.com>
parents:
37359
diff
changeset
|
410 |
ui.status(_("updating to active bookmark %s\n") % activemark) |
a973bb92ab71
bookmarks: drop always-None argument from calculateupdate()
Martin von Zweigbergk <martinvonz@google.com>
parents:
37359
diff
changeset
|
411 |
checkout = activemark |
19523
f37b5a17e6a0
bookmarks: pull --update updates to active bookmark if it moved (issue4007)
Kevin Bullock <kbullock@ringworld.org>
parents:
19110
diff
changeset
|
412 |
return (checkout, movemarkfrom) |
f37b5a17e6a0
bookmarks: pull --update updates to active bookmark if it moved (issue4007)
Kevin Bullock <kbullock@ringworld.org>
parents:
19110
diff
changeset
|
413 |
|
13352
f9cd37fca5ba
bookmarks: move update into core
Matt Mackall <mpm@selenic.com>
parents:
13351
diff
changeset
|
414 |
def update(repo, parents, node): |
19110
741d94aa92e4
bookmarks: resolve divergent bookmarks when moving active bookmark forward
Sean Farley <sean.michael.farley@gmail.com>
parents:
18984
diff
changeset
|
415 |
deletefrom = parents |
13352
f9cd37fca5ba
bookmarks: move update into core
Matt Mackall <mpm@selenic.com>
parents:
13351
diff
changeset
|
416 |
marks = repo._bookmarks |
27698
dad6404ccddb
bmstore: add handling of the active bookmark
Augie Fackler <augie@google.com>
parents:
27685
diff
changeset
|
417 |
active = marks.active |
25100
d6e7ac651973
bookmarks: rename current to active in variables and comments
Ryan McElroy <rmcelroy@fb.com>
parents:
25081
diff
changeset
|
418 |
if not active: |
16706
a270ec977ba6
bookmarks: delete divergent bookmarks on merge
David Soria Parra <dsp@php.net>
parents:
16697
diff
changeset
|
419 |
return False |
a270ec977ba6
bookmarks: delete divergent bookmarks on merge
David Soria Parra <dsp@php.net>
parents:
16697
diff
changeset
|
420 |
|
33491
1adcb594eb6b
bookmarks: use 'applychanges' for bookmark update
Boris Feld <boris.feld@octobus.net>
parents:
33485
diff
changeset
|
421 |
bmchanges = [] |
25100
d6e7ac651973
bookmarks: rename current to active in variables and comments
Ryan McElroy <rmcelroy@fb.com>
parents:
25081
diff
changeset
|
422 |
if marks[active] in parents: |
18513
37ce336ab2dd
bookmarks: factor out delete divergent code
Siddharth Agarwal <sid0@fb.com>
parents:
18496
diff
changeset
|
423 |
new = repo[node] |
37450
81d35d5d35f9
bookmarks: introduce a repo._bookmarks.changectx(mark) method and use it
Martin von Zweigbergk <martinvonz@google.com>
parents:
37397
diff
changeset
|
424 |
divs = [marks.changectx(b) for b in marks |
25100
d6e7ac651973
bookmarks: rename current to active in variables and comments
Ryan McElroy <rmcelroy@fb.com>
parents:
25081
diff
changeset
|
425 |
if b.split('@', 1)[0] == active.split('@', 1)[0]] |
19110
741d94aa92e4
bookmarks: resolve divergent bookmarks when moving active bookmark forward
Sean Farley <sean.michael.farley@gmail.com>
parents:
18984
diff
changeset
|
426 |
anc = repo.changelog.ancestors([new.rev()]) |
741d94aa92e4
bookmarks: resolve divergent bookmarks when moving active bookmark forward
Sean Farley <sean.michael.farley@gmail.com>
parents:
18984
diff
changeset
|
427 |
deletefrom = [b.node() for b in divs if b.rev() in anc or b == new] |
37450
81d35d5d35f9
bookmarks: introduce a repo._bookmarks.changectx(mark) method and use it
Martin von Zweigbergk <martinvonz@google.com>
parents:
37397
diff
changeset
|
428 |
if validdest(repo, marks.changectx(active), new): |
33491
1adcb594eb6b
bookmarks: use 'applychanges' for bookmark update
Boris Feld <boris.feld@octobus.net>
parents:
33485
diff
changeset
|
429 |
bmchanges.append((active, new.node())) |
18513
37ce336ab2dd
bookmarks: factor out delete divergent code
Siddharth Agarwal <sid0@fb.com>
parents:
18496
diff
changeset
|
430 |
|
33512
1424a769f31b
bookmark: use 'divergent2delete' when updating a bookmark
Boris Feld <boris.feld@octobus.net>
parents:
33510
diff
changeset
|
431 |
for bm in divergent2delete(repo, deletefrom, active): |
1424a769f31b
bookmark: use 'divergent2delete' when updating a bookmark
Boris Feld <boris.feld@octobus.net>
parents:
33510
diff
changeset
|
432 |
bmchanges.append((bm, None)) |
18513
37ce336ab2dd
bookmarks: factor out delete divergent code
Siddharth Agarwal <sid0@fb.com>
parents:
18496
diff
changeset
|
433 |
|
33512
1424a769f31b
bookmark: use 'divergent2delete' when updating a bookmark
Boris Feld <boris.feld@octobus.net>
parents:
33510
diff
changeset
|
434 |
if bmchanges: |
35576
b9a0de08110e
bookmarks: use context managers for lock and transaction in update()
Martin von Zweigbergk <martinvonz@google.com>
parents:
35257
diff
changeset
|
435 |
with repo.lock(), repo.transaction('bookmark') as tr: |
33491
1adcb594eb6b
bookmarks: use 'applychanges' for bookmark update
Boris Feld <boris.feld@octobus.net>
parents:
33485
diff
changeset
|
436 |
marks.applychanges(repo, tr, bmchanges) |
33512
1424a769f31b
bookmark: use 'divergent2delete' when updating a bookmark
Boris Feld <boris.feld@octobus.net>
parents:
33510
diff
changeset
|
437 |
return bool(bmchanges) |
13353
689bf32b3bbd
bookmarks: move pushkey functions into core
Matt Mackall <mpm@selenic.com>
parents:
13352
diff
changeset
|
438 |
|
30481
0a3b11a7489a
bookmarks: introduce listbinbookmarks()
Stanislau Hlebik <stash@fb.com>
parents:
29354
diff
changeset
|
439 |
def listbinbookmarks(repo): |
0a3b11a7489a
bookmarks: introduce listbinbookmarks()
Stanislau Hlebik <stash@fb.com>
parents:
29354
diff
changeset
|
440 |
# We may try to list bookmarks on a repo type that does not |
0a3b11a7489a
bookmarks: introduce listbinbookmarks()
Stanislau Hlebik <stash@fb.com>
parents:
29354
diff
changeset
|
441 |
# support it (e.g., statichttprepository). |
0a3b11a7489a
bookmarks: introduce listbinbookmarks()
Stanislau Hlebik <stash@fb.com>
parents:
29354
diff
changeset
|
442 |
marks = getattr(repo, '_bookmarks', {}) |
0a3b11a7489a
bookmarks: introduce listbinbookmarks()
Stanislau Hlebik <stash@fb.com>
parents:
29354
diff
changeset
|
443 |
|
0a3b11a7489a
bookmarks: introduce listbinbookmarks()
Stanislau Hlebik <stash@fb.com>
parents:
29354
diff
changeset
|
444 |
hasnode = repo.changelog.hasnode |
0a3b11a7489a
bookmarks: introduce listbinbookmarks()
Stanislau Hlebik <stash@fb.com>
parents:
29354
diff
changeset
|
445 |
for k, v in marks.iteritems(): |
0a3b11a7489a
bookmarks: introduce listbinbookmarks()
Stanislau Hlebik <stash@fb.com>
parents:
29354
diff
changeset
|
446 |
# don't expose local divergent bookmarks |
0a3b11a7489a
bookmarks: introduce listbinbookmarks()
Stanislau Hlebik <stash@fb.com>
parents:
29354
diff
changeset
|
447 |
if hasnode(v) and ('@' not in k or k.endswith('@')): |
0a3b11a7489a
bookmarks: introduce listbinbookmarks()
Stanislau Hlebik <stash@fb.com>
parents:
29354
diff
changeset
|
448 |
yield k, v |
0a3b11a7489a
bookmarks: introduce listbinbookmarks()
Stanislau Hlebik <stash@fb.com>
parents:
29354
diff
changeset
|
449 |
|
13353
689bf32b3bbd
bookmarks: move pushkey functions into core
Matt Mackall <mpm@selenic.com>
parents:
13352
diff
changeset
|
450 |
def listbookmarks(repo): |
689bf32b3bbd
bookmarks: move pushkey functions into core
Matt Mackall <mpm@selenic.com>
parents:
13352
diff
changeset
|
451 |
d = {} |
30482
55ec13c82ea0
bookmarks: use listbinbookmarks() in listbookmarks()
Stanislau Hlebik <stash@fb.com>
parents:
30481
diff
changeset
|
452 |
for book, node in listbinbookmarks(repo): |
55ec13c82ea0
bookmarks: use listbinbookmarks() in listbookmarks()
Stanislau Hlebik <stash@fb.com>
parents:
30481
diff
changeset
|
453 |
d[book] = hex(node) |
13353
689bf32b3bbd
bookmarks: move pushkey functions into core
Matt Mackall <mpm@selenic.com>
parents:
13352
diff
changeset
|
454 |
return d |
689bf32b3bbd
bookmarks: move pushkey functions into core
Matt Mackall <mpm@selenic.com>
parents:
13352
diff
changeset
|
455 |
|
689bf32b3bbd
bookmarks: move pushkey functions into core
Matt Mackall <mpm@selenic.com>
parents:
13352
diff
changeset
|
456 |
def pushbookmark(repo, key, old, new): |
35577
ac7ee75ee664
bookmarks: use context managers for locks and transaction in pushbookmark()
Martin von Zweigbergk <martinvonz@google.com>
parents:
35576
diff
changeset
|
457 |
with repo.wlock(), repo.lock(), repo.transaction('bookmarks') as tr: |
13353
689bf32b3bbd
bookmarks: move pushkey functions into core
Matt Mackall <mpm@selenic.com>
parents:
13352
diff
changeset
|
458 |
marks = repo._bookmarks |
22364
5c153c69fdb2
bookmarks: allow pushkey if new equals current
Durham Goode <durham@fb.com>
parents:
21843
diff
changeset
|
459 |
existing = hex(marks.get(key, '')) |
5c153c69fdb2
bookmarks: allow pushkey if new equals current
Durham Goode <durham@fb.com>
parents:
21843
diff
changeset
|
460 |
if existing != old and existing != new: |
13353
689bf32b3bbd
bookmarks: move pushkey functions into core
Matt Mackall <mpm@selenic.com>
parents:
13352
diff
changeset
|
461 |
return False |
689bf32b3bbd
bookmarks: move pushkey functions into core
Matt Mackall <mpm@selenic.com>
parents:
13352
diff
changeset
|
462 |
if new == '': |
33485
505021482541
bookmark: use 'applychanges' when updating a bookmark through pushkey
Boris Feld <boris.feld@octobus.net>
parents:
33484
diff
changeset
|
463 |
changes = [(key, None)] |
13353
689bf32b3bbd
bookmarks: move pushkey functions into core
Matt Mackall <mpm@selenic.com>
parents:
13352
diff
changeset
|
464 |
else: |
689bf32b3bbd
bookmarks: move pushkey functions into core
Matt Mackall <mpm@selenic.com>
parents:
13352
diff
changeset
|
465 |
if new not in repo: |
689bf32b3bbd
bookmarks: move pushkey functions into core
Matt Mackall <mpm@selenic.com>
parents:
13352
diff
changeset
|
466 |
return False |
33485
505021482541
bookmark: use 'applychanges' when updating a bookmark through pushkey
Boris Feld <boris.feld@octobus.net>
parents:
33484
diff
changeset
|
467 |
changes = [(key, repo[new].node())] |
505021482541
bookmark: use 'applychanges' when updating a bookmark through pushkey
Boris Feld <boris.feld@octobus.net>
parents:
33484
diff
changeset
|
468 |
marks.applychanges(repo, tr, changes) |
13353
689bf32b3bbd
bookmarks: move pushkey functions into core
Matt Mackall <mpm@selenic.com>
parents:
13352
diff
changeset
|
469 |
return True |
13354
4e1ba6ead69c
bookmarks: move diff to core
Matt Mackall <mpm@selenic.com>
parents:
13353
diff
changeset
|
470 |
|
30583
8f8211903b83
bookmarks: make bookmarks.comparebookmarks accept binary nodes (API)
Stanislau Hlebik <stash@fb.com>
parents:
30582
diff
changeset
|
471 |
def comparebookmarks(repo, srcmarks, dstmarks, targets=None): |
20024
059b695150c2
bookmarks: add function to centralize the logic to compare bookmarks
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
19951
diff
changeset
|
472 |
'''Compare bookmarks between srcmarks and dstmarks |
059b695150c2
bookmarks: add function to centralize the logic to compare bookmarks
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
19951
diff
changeset
|
473 |
|
059b695150c2
bookmarks: add function to centralize the logic to compare bookmarks
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
19951
diff
changeset
|
474 |
This returns tuple "(addsrc, adddst, advsrc, advdst, diverge, |
059b695150c2
bookmarks: add function to centralize the logic to compare bookmarks
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
19951
diff
changeset
|
475 |
differ, invalid)", each are list of bookmarks below: |
059b695150c2
bookmarks: add function to centralize the logic to compare bookmarks
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
19951
diff
changeset
|
476 |
|
059b695150c2
bookmarks: add function to centralize the logic to compare bookmarks
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
19951
diff
changeset
|
477 |
:addsrc: added on src side (removed on dst side, perhaps) |
059b695150c2
bookmarks: add function to centralize the logic to compare bookmarks
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
19951
diff
changeset
|
478 |
:adddst: added on dst side (removed on src side, perhaps) |
059b695150c2
bookmarks: add function to centralize the logic to compare bookmarks
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
19951
diff
changeset
|
479 |
:advsrc: advanced on src side |
059b695150c2
bookmarks: add function to centralize the logic to compare bookmarks
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
19951
diff
changeset
|
480 |
:advdst: advanced on dst side |
059b695150c2
bookmarks: add function to centralize the logic to compare bookmarks
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
19951
diff
changeset
|
481 |
:diverge: diverge |
059b695150c2
bookmarks: add function to centralize the logic to compare bookmarks
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
19951
diff
changeset
|
482 |
:differ: changed, but changeset referred on src is unknown on dst |
059b695150c2
bookmarks: add function to centralize the logic to compare bookmarks
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
19951
diff
changeset
|
483 |
:invalid: unknown on both side |
23081
e62c330a044f
bookmarks: explicitly track identical bookmarks
Gregory Szorc <gregory.szorc@gmail.com>
parents:
22941
diff
changeset
|
484 |
:same: same on both side |
20024
059b695150c2
bookmarks: add function to centralize the logic to compare bookmarks
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
19951
diff
changeset
|
485 |
|
059b695150c2
bookmarks: add function to centralize the logic to compare bookmarks
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
19951
diff
changeset
|
486 |
Each elements of lists in result tuple is tuple "(bookmark name, |
059b695150c2
bookmarks: add function to centralize the logic to compare bookmarks
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
19951
diff
changeset
|
487 |
changeset ID on source side, changeset ID on destination |
059b695150c2
bookmarks: add function to centralize the logic to compare bookmarks
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
19951
diff
changeset
|
488 |
side)". Each changeset IDs are 40 hexadecimal digit string or |
059b695150c2
bookmarks: add function to centralize the logic to compare bookmarks
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
19951
diff
changeset
|
489 |
None. |
059b695150c2
bookmarks: add function to centralize the logic to compare bookmarks
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
19951
diff
changeset
|
490 |
|
059b695150c2
bookmarks: add function to centralize the logic to compare bookmarks
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
19951
diff
changeset
|
491 |
Changeset IDs of tuples in "addsrc", "adddst", "differ" or |
059b695150c2
bookmarks: add function to centralize the logic to compare bookmarks
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
19951
diff
changeset
|
492 |
"invalid" list may be unknown for repo. |
059b695150c2
bookmarks: add function to centralize the logic to compare bookmarks
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
19951
diff
changeset
|
493 |
|
059b695150c2
bookmarks: add function to centralize the logic to compare bookmarks
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
19951
diff
changeset
|
494 |
If "targets" is specified, only bookmarks listed in it are |
059b695150c2
bookmarks: add function to centralize the logic to compare bookmarks
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
19951
diff
changeset
|
495 |
examined. |
059b695150c2
bookmarks: add function to centralize the logic to compare bookmarks
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
19951
diff
changeset
|
496 |
''' |
059b695150c2
bookmarks: add function to centralize the logic to compare bookmarks
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
19951
diff
changeset
|
497 |
|
059b695150c2
bookmarks: add function to centralize the logic to compare bookmarks
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
19951
diff
changeset
|
498 |
if targets: |
059b695150c2
bookmarks: add function to centralize the logic to compare bookmarks
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
19951
diff
changeset
|
499 |
bset = set(targets) |
059b695150c2
bookmarks: add function to centralize the logic to compare bookmarks
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
19951
diff
changeset
|
500 |
else: |
059b695150c2
bookmarks: add function to centralize the logic to compare bookmarks
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
19951
diff
changeset
|
501 |
srcmarkset = set(srcmarks) |
059b695150c2
bookmarks: add function to centralize the logic to compare bookmarks
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
19951
diff
changeset
|
502 |
dstmarkset = set(dstmarks) |
23081
e62c330a044f
bookmarks: explicitly track identical bookmarks
Gregory Szorc <gregory.szorc@gmail.com>
parents:
22941
diff
changeset
|
503 |
bset = srcmarkset | dstmarkset |
20024
059b695150c2
bookmarks: add function to centralize the logic to compare bookmarks
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
19951
diff
changeset
|
504 |
|
23081
e62c330a044f
bookmarks: explicitly track identical bookmarks
Gregory Szorc <gregory.szorc@gmail.com>
parents:
22941
diff
changeset
|
505 |
results = ([], [], [], [], [], [], [], []) |
20024
059b695150c2
bookmarks: add function to centralize the logic to compare bookmarks
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
19951
diff
changeset
|
506 |
addsrc = results[0].append |
059b695150c2
bookmarks: add function to centralize the logic to compare bookmarks
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
19951
diff
changeset
|
507 |
adddst = results[1].append |
059b695150c2
bookmarks: add function to centralize the logic to compare bookmarks
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
19951
diff
changeset
|
508 |
advsrc = results[2].append |
059b695150c2
bookmarks: add function to centralize the logic to compare bookmarks
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
19951
diff
changeset
|
509 |
advdst = results[3].append |
059b695150c2
bookmarks: add function to centralize the logic to compare bookmarks
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
19951
diff
changeset
|
510 |
diverge = results[4].append |
059b695150c2
bookmarks: add function to centralize the logic to compare bookmarks
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
19951
diff
changeset
|
511 |
differ = results[5].append |
059b695150c2
bookmarks: add function to centralize the logic to compare bookmarks
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
19951
diff
changeset
|
512 |
invalid = results[6].append |
23081
e62c330a044f
bookmarks: explicitly track identical bookmarks
Gregory Szorc <gregory.szorc@gmail.com>
parents:
22941
diff
changeset
|
513 |
same = results[7].append |
20024
059b695150c2
bookmarks: add function to centralize the logic to compare bookmarks
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
19951
diff
changeset
|
514 |
|
059b695150c2
bookmarks: add function to centralize the logic to compare bookmarks
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
19951
diff
changeset
|
515 |
for b in sorted(bset): |
059b695150c2
bookmarks: add function to centralize the logic to compare bookmarks
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
19951
diff
changeset
|
516 |
if b not in srcmarks: |
059b695150c2
bookmarks: add function to centralize the logic to compare bookmarks
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
19951
diff
changeset
|
517 |
if b in dstmarks: |
30583
8f8211903b83
bookmarks: make bookmarks.comparebookmarks accept binary nodes (API)
Stanislau Hlebik <stash@fb.com>
parents:
30582
diff
changeset
|
518 |
adddst((b, None, dstmarks[b])) |
20024
059b695150c2
bookmarks: add function to centralize the logic to compare bookmarks
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
19951
diff
changeset
|
519 |
else: |
059b695150c2
bookmarks: add function to centralize the logic to compare bookmarks
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
19951
diff
changeset
|
520 |
invalid((b, None, None)) |
059b695150c2
bookmarks: add function to centralize the logic to compare bookmarks
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
19951
diff
changeset
|
521 |
elif b not in dstmarks: |
30583
8f8211903b83
bookmarks: make bookmarks.comparebookmarks accept binary nodes (API)
Stanislau Hlebik <stash@fb.com>
parents:
30582
diff
changeset
|
522 |
addsrc((b, srcmarks[b], None)) |
20024
059b695150c2
bookmarks: add function to centralize the logic to compare bookmarks
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
19951
diff
changeset
|
523 |
else: |
30583
8f8211903b83
bookmarks: make bookmarks.comparebookmarks accept binary nodes (API)
Stanislau Hlebik <stash@fb.com>
parents:
30582
diff
changeset
|
524 |
scid = srcmarks[b] |
8f8211903b83
bookmarks: make bookmarks.comparebookmarks accept binary nodes (API)
Stanislau Hlebik <stash@fb.com>
parents:
30582
diff
changeset
|
525 |
dcid = dstmarks[b] |
23081
e62c330a044f
bookmarks: explicitly track identical bookmarks
Gregory Szorc <gregory.szorc@gmail.com>
parents:
22941
diff
changeset
|
526 |
if scid == dcid: |
e62c330a044f
bookmarks: explicitly track identical bookmarks
Gregory Szorc <gregory.szorc@gmail.com>
parents:
22941
diff
changeset
|
527 |
same((b, scid, dcid)) |
e62c330a044f
bookmarks: explicitly track identical bookmarks
Gregory Szorc <gregory.szorc@gmail.com>
parents:
22941
diff
changeset
|
528 |
elif scid in repo and dcid in repo: |
20024
059b695150c2
bookmarks: add function to centralize the logic to compare bookmarks
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
19951
diff
changeset
|
529 |
sctx = repo[scid] |
059b695150c2
bookmarks: add function to centralize the logic to compare bookmarks
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
19951
diff
changeset
|
530 |
dctx = repo[dcid] |
059b695150c2
bookmarks: add function to centralize the logic to compare bookmarks
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
19951
diff
changeset
|
531 |
if sctx.rev() < dctx.rev(): |
059b695150c2
bookmarks: add function to centralize the logic to compare bookmarks
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
19951
diff
changeset
|
532 |
if validdest(repo, sctx, dctx): |
059b695150c2
bookmarks: add function to centralize the logic to compare bookmarks
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
19951
diff
changeset
|
533 |
advdst((b, scid, dcid)) |
059b695150c2
bookmarks: add function to centralize the logic to compare bookmarks
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
19951
diff
changeset
|
534 |
else: |
059b695150c2
bookmarks: add function to centralize the logic to compare bookmarks
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
19951
diff
changeset
|
535 |
diverge((b, scid, dcid)) |
059b695150c2
bookmarks: add function to centralize the logic to compare bookmarks
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
19951
diff
changeset
|
536 |
else: |
059b695150c2
bookmarks: add function to centralize the logic to compare bookmarks
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
19951
diff
changeset
|
537 |
if validdest(repo, dctx, sctx): |
059b695150c2
bookmarks: add function to centralize the logic to compare bookmarks
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
19951
diff
changeset
|
538 |
advsrc((b, scid, dcid)) |
059b695150c2
bookmarks: add function to centralize the logic to compare bookmarks
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
19951
diff
changeset
|
539 |
else: |
059b695150c2
bookmarks: add function to centralize the logic to compare bookmarks
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
19951
diff
changeset
|
540 |
diverge((b, scid, dcid)) |
059b695150c2
bookmarks: add function to centralize the logic to compare bookmarks
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
19951
diff
changeset
|
541 |
else: |
059b695150c2
bookmarks: add function to centralize the logic to compare bookmarks
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
19951
diff
changeset
|
542 |
# it is too expensive to examine in detail, in this case |
059b695150c2
bookmarks: add function to centralize the logic to compare bookmarks
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
19951
diff
changeset
|
543 |
differ((b, scid, dcid)) |
059b695150c2
bookmarks: add function to centralize the logic to compare bookmarks
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
19951
diff
changeset
|
544 |
|
059b695150c2
bookmarks: add function to centralize the logic to compare bookmarks
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
19951
diff
changeset
|
545 |
return results |
059b695150c2
bookmarks: add function to centralize the logic to compare bookmarks
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
19951
diff
changeset
|
546 |
|
24355
ca4b89683078
bookmarks: reuse @number bookmark, if it refers changeset referred remotely
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
24354
diff
changeset
|
547 |
def _diverge(ui, b, path, localmarks, remotenode): |
24353
3f6bf9f29e7b
bookmarks: prevent divergent bookmark from being updated unexpectedly
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
24306
diff
changeset
|
548 |
'''Return appropriate diverged bookmark for specified ``path`` |
3f6bf9f29e7b
bookmarks: prevent divergent bookmark from being updated unexpectedly
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
24306
diff
changeset
|
549 |
|
3f6bf9f29e7b
bookmarks: prevent divergent bookmark from being updated unexpectedly
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
24306
diff
changeset
|
550 |
This returns None, if it is failed to assign any divergent |
3f6bf9f29e7b
bookmarks: prevent divergent bookmark from being updated unexpectedly
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
24306
diff
changeset
|
551 |
bookmark name. |
24355
ca4b89683078
bookmarks: reuse @number bookmark, if it refers changeset referred remotely
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
24354
diff
changeset
|
552 |
|
ca4b89683078
bookmarks: reuse @number bookmark, if it refers changeset referred remotely
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
24354
diff
changeset
|
553 |
This reuses already existing one with "@number" suffix, if it |
ca4b89683078
bookmarks: reuse @number bookmark, if it refers changeset referred remotely
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
24354
diff
changeset
|
554 |
refers ``remotenode``. |
24353
3f6bf9f29e7b
bookmarks: prevent divergent bookmark from being updated unexpectedly
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
24306
diff
changeset
|
555 |
''' |
20025
e8a11791abfc
bookmarks: rewrite "updatefromremote()" by "compare()"
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
20024
diff
changeset
|
556 |
if b == '@': |
e8a11791abfc
bookmarks: rewrite "updatefromremote()" by "compare()"
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
20024
diff
changeset
|
557 |
b = '' |
e8a11791abfc
bookmarks: rewrite "updatefromremote()" by "compare()"
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
20024
diff
changeset
|
558 |
# try to use an @pathalias suffix |
e8a11791abfc
bookmarks: rewrite "updatefromremote()" by "compare()"
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
20024
diff
changeset
|
559 |
# if an @pathalias already exists, we overwrite (update) it |
22629
b3f74b405c20
bookmarks: fix divergent bookmark path normalization
Matt Mackall <mpm@selenic.com>
parents:
22627
diff
changeset
|
560 |
if path.startswith("file:"): |
b3f74b405c20
bookmarks: fix divergent bookmark path normalization
Matt Mackall <mpm@selenic.com>
parents:
22627
diff
changeset
|
561 |
path = util.url(path).path |
20025
e8a11791abfc
bookmarks: rewrite "updatefromremote()" by "compare()"
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
20024
diff
changeset
|
562 |
for p, u in ui.configitems("paths"): |
22629
b3f74b405c20
bookmarks: fix divergent bookmark path normalization
Matt Mackall <mpm@selenic.com>
parents:
22627
diff
changeset
|
563 |
if u.startswith("file:"): |
b3f74b405c20
bookmarks: fix divergent bookmark path normalization
Matt Mackall <mpm@selenic.com>
parents:
22627
diff
changeset
|
564 |
u = util.url(u).path |
20025
e8a11791abfc
bookmarks: rewrite "updatefromremote()" by "compare()"
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
20024
diff
changeset
|
565 |
if path == u: |
24354
194e1e3ebc29
bookmarks: check @pathalias suffix before available @number for efficiency
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
24353
diff
changeset
|
566 |
return '%s@%s' % (b, p) |
194e1e3ebc29
bookmarks: check @pathalias suffix before available @number for efficiency
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
24353
diff
changeset
|
567 |
|
194e1e3ebc29
bookmarks: check @pathalias suffix before available @number for efficiency
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
24353
diff
changeset
|
568 |
# assign a unique "@number" suffix newly |
194e1e3ebc29
bookmarks: check @pathalias suffix before available @number for efficiency
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
24353
diff
changeset
|
569 |
for x in range(1, 100): |
194e1e3ebc29
bookmarks: check @pathalias suffix before available @number for efficiency
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
24353
diff
changeset
|
570 |
n = '%s@%d' % (b, x) |
24355
ca4b89683078
bookmarks: reuse @number bookmark, if it refers changeset referred remotely
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
24354
diff
changeset
|
571 |
if n not in localmarks or localmarks[n] == remotenode: |
24354
194e1e3ebc29
bookmarks: check @pathalias suffix before available @number for efficiency
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
24353
diff
changeset
|
572 |
return n |
194e1e3ebc29
bookmarks: check @pathalias suffix before available @number for efficiency
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
24353
diff
changeset
|
573 |
|
194e1e3ebc29
bookmarks: check @pathalias suffix before available @number for efficiency
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
24353
diff
changeset
|
574 |
return None |
20025
e8a11791abfc
bookmarks: rewrite "updatefromremote()" by "compare()"
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
20024
diff
changeset
|
575 |
|
30583
8f8211903b83
bookmarks: make bookmarks.comparebookmarks accept binary nodes (API)
Stanislau Hlebik <stash@fb.com>
parents:
30582
diff
changeset
|
576 |
def unhexlifybookmarks(marks): |
8f8211903b83
bookmarks: make bookmarks.comparebookmarks accept binary nodes (API)
Stanislau Hlebik <stash@fb.com>
parents:
30582
diff
changeset
|
577 |
binremotemarks = {} |
8f8211903b83
bookmarks: make bookmarks.comparebookmarks accept binary nodes (API)
Stanislau Hlebik <stash@fb.com>
parents:
30582
diff
changeset
|
578 |
for name, node in marks.items(): |
8f8211903b83
bookmarks: make bookmarks.comparebookmarks accept binary nodes (API)
Stanislau Hlebik <stash@fb.com>
parents:
30582
diff
changeset
|
579 |
binremotemarks[name] = bin(node) |
8f8211903b83
bookmarks: make bookmarks.comparebookmarks accept binary nodes (API)
Stanislau Hlebik <stash@fb.com>
parents:
30582
diff
changeset
|
580 |
return binremotemarks |
8f8211903b83
bookmarks: make bookmarks.comparebookmarks accept binary nodes (API)
Stanislau Hlebik <stash@fb.com>
parents:
30582
diff
changeset
|
581 |
|
35257
3340d46a5c3f
bookmark: add methods to binary encode and decode bookmark values
Boris Feld <boris.feld@octobus.net>
parents:
34708
diff
changeset
|
582 |
_binaryentry = struct.Struct('>20sH') |
3340d46a5c3f
bookmark: add methods to binary encode and decode bookmark values
Boris Feld <boris.feld@octobus.net>
parents:
34708
diff
changeset
|
583 |
|
3340d46a5c3f
bookmark: add methods to binary encode and decode bookmark values
Boris Feld <boris.feld@octobus.net>
parents:
34708
diff
changeset
|
584 |
def binaryencode(bookmarks): |
3340d46a5c3f
bookmark: add methods to binary encode and decode bookmark values
Boris Feld <boris.feld@octobus.net>
parents:
34708
diff
changeset
|
585 |
"""encode a '(bookmark, node)' iterable into a binary stream |
3340d46a5c3f
bookmark: add methods to binary encode and decode bookmark values
Boris Feld <boris.feld@octobus.net>
parents:
34708
diff
changeset
|
586 |
|
3340d46a5c3f
bookmark: add methods to binary encode and decode bookmark values
Boris Feld <boris.feld@octobus.net>
parents:
34708
diff
changeset
|
587 |
the binary format is: |
3340d46a5c3f
bookmark: add methods to binary encode and decode bookmark values
Boris Feld <boris.feld@octobus.net>
parents:
34708
diff
changeset
|
588 |
|
3340d46a5c3f
bookmark: add methods to binary encode and decode bookmark values
Boris Feld <boris.feld@octobus.net>
parents:
34708
diff
changeset
|
589 |
<node><bookmark-length><bookmark-name> |
3340d46a5c3f
bookmark: add methods to binary encode and decode bookmark values
Boris Feld <boris.feld@octobus.net>
parents:
34708
diff
changeset
|
590 |
|
3340d46a5c3f
bookmark: add methods to binary encode and decode bookmark values
Boris Feld <boris.feld@octobus.net>
parents:
34708
diff
changeset
|
591 |
:node: is a 20 bytes binary node, |
3340d46a5c3f
bookmark: add methods to binary encode and decode bookmark values
Boris Feld <boris.feld@octobus.net>
parents:
34708
diff
changeset
|
592 |
:bookmark-length: an unsigned short, |
3340d46a5c3f
bookmark: add methods to binary encode and decode bookmark values
Boris Feld <boris.feld@octobus.net>
parents:
34708
diff
changeset
|
593 |
:bookmark-name: the name of the bookmark (of length <bookmark-length>) |
3340d46a5c3f
bookmark: add methods to binary encode and decode bookmark values
Boris Feld <boris.feld@octobus.net>
parents:
34708
diff
changeset
|
594 |
|
3340d46a5c3f
bookmark: add methods to binary encode and decode bookmark values
Boris Feld <boris.feld@octobus.net>
parents:
34708
diff
changeset
|
595 |
wdirid (all bits set) will be used as a special value for "missing" |
3340d46a5c3f
bookmark: add methods to binary encode and decode bookmark values
Boris Feld <boris.feld@octobus.net>
parents:
34708
diff
changeset
|
596 |
""" |
3340d46a5c3f
bookmark: add methods to binary encode and decode bookmark values
Boris Feld <boris.feld@octobus.net>
parents:
34708
diff
changeset
|
597 |
binarydata = [] |
3340d46a5c3f
bookmark: add methods to binary encode and decode bookmark values
Boris Feld <boris.feld@octobus.net>
parents:
34708
diff
changeset
|
598 |
for book, node in bookmarks: |
3340d46a5c3f
bookmark: add methods to binary encode and decode bookmark values
Boris Feld <boris.feld@octobus.net>
parents:
34708
diff
changeset
|
599 |
if not node: # None or '' |
3340d46a5c3f
bookmark: add methods to binary encode and decode bookmark values
Boris Feld <boris.feld@octobus.net>
parents:
34708
diff
changeset
|
600 |
node = wdirid |
3340d46a5c3f
bookmark: add methods to binary encode and decode bookmark values
Boris Feld <boris.feld@octobus.net>
parents:
34708
diff
changeset
|
601 |
binarydata.append(_binaryentry.pack(node, len(book))) |
3340d46a5c3f
bookmark: add methods to binary encode and decode bookmark values
Boris Feld <boris.feld@octobus.net>
parents:
34708
diff
changeset
|
602 |
binarydata.append(book) |
3340d46a5c3f
bookmark: add methods to binary encode and decode bookmark values
Boris Feld <boris.feld@octobus.net>
parents:
34708
diff
changeset
|
603 |
return ''.join(binarydata) |
3340d46a5c3f
bookmark: add methods to binary encode and decode bookmark values
Boris Feld <boris.feld@octobus.net>
parents:
34708
diff
changeset
|
604 |
|
3340d46a5c3f
bookmark: add methods to binary encode and decode bookmark values
Boris Feld <boris.feld@octobus.net>
parents:
34708
diff
changeset
|
605 |
def binarydecode(stream): |
3340d46a5c3f
bookmark: add methods to binary encode and decode bookmark values
Boris Feld <boris.feld@octobus.net>
parents:
34708
diff
changeset
|
606 |
"""decode a binary stream into an '(bookmark, node)' iterable |
3340d46a5c3f
bookmark: add methods to binary encode and decode bookmark values
Boris Feld <boris.feld@octobus.net>
parents:
34708
diff
changeset
|
607 |
|
3340d46a5c3f
bookmark: add methods to binary encode and decode bookmark values
Boris Feld <boris.feld@octobus.net>
parents:
34708
diff
changeset
|
608 |
the binary format is: |
3340d46a5c3f
bookmark: add methods to binary encode and decode bookmark values
Boris Feld <boris.feld@octobus.net>
parents:
34708
diff
changeset
|
609 |
|
3340d46a5c3f
bookmark: add methods to binary encode and decode bookmark values
Boris Feld <boris.feld@octobus.net>
parents:
34708
diff
changeset
|
610 |
<node><bookmark-length><bookmark-name> |
3340d46a5c3f
bookmark: add methods to binary encode and decode bookmark values
Boris Feld <boris.feld@octobus.net>
parents:
34708
diff
changeset
|
611 |
|
3340d46a5c3f
bookmark: add methods to binary encode and decode bookmark values
Boris Feld <boris.feld@octobus.net>
parents:
34708
diff
changeset
|
612 |
:node: is a 20 bytes binary node, |
3340d46a5c3f
bookmark: add methods to binary encode and decode bookmark values
Boris Feld <boris.feld@octobus.net>
parents:
34708
diff
changeset
|
613 |
:bookmark-length: an unsigned short, |
3340d46a5c3f
bookmark: add methods to binary encode and decode bookmark values
Boris Feld <boris.feld@octobus.net>
parents:
34708
diff
changeset
|
614 |
:bookmark-name: the name of the bookmark (of length <bookmark-length>)) |
3340d46a5c3f
bookmark: add methods to binary encode and decode bookmark values
Boris Feld <boris.feld@octobus.net>
parents:
34708
diff
changeset
|
615 |
|
3340d46a5c3f
bookmark: add methods to binary encode and decode bookmark values
Boris Feld <boris.feld@octobus.net>
parents:
34708
diff
changeset
|
616 |
wdirid (all bits set) will be used as a special value for "missing" |
3340d46a5c3f
bookmark: add methods to binary encode and decode bookmark values
Boris Feld <boris.feld@octobus.net>
parents:
34708
diff
changeset
|
617 |
""" |
3340d46a5c3f
bookmark: add methods to binary encode and decode bookmark values
Boris Feld <boris.feld@octobus.net>
parents:
34708
diff
changeset
|
618 |
entrysize = _binaryentry.size |
3340d46a5c3f
bookmark: add methods to binary encode and decode bookmark values
Boris Feld <boris.feld@octobus.net>
parents:
34708
diff
changeset
|
619 |
books = [] |
3340d46a5c3f
bookmark: add methods to binary encode and decode bookmark values
Boris Feld <boris.feld@octobus.net>
parents:
34708
diff
changeset
|
620 |
while True: |
3340d46a5c3f
bookmark: add methods to binary encode and decode bookmark values
Boris Feld <boris.feld@octobus.net>
parents:
34708
diff
changeset
|
621 |
entry = stream.read(entrysize) |
3340d46a5c3f
bookmark: add methods to binary encode and decode bookmark values
Boris Feld <boris.feld@octobus.net>
parents:
34708
diff
changeset
|
622 |
if len(entry) < entrysize: |
3340d46a5c3f
bookmark: add methods to binary encode and decode bookmark values
Boris Feld <boris.feld@octobus.net>
parents:
34708
diff
changeset
|
623 |
if entry: |
3340d46a5c3f
bookmark: add methods to binary encode and decode bookmark values
Boris Feld <boris.feld@octobus.net>
parents:
34708
diff
changeset
|
624 |
raise error.Abort(_('bad bookmark stream')) |
3340d46a5c3f
bookmark: add methods to binary encode and decode bookmark values
Boris Feld <boris.feld@octobus.net>
parents:
34708
diff
changeset
|
625 |
break |
3340d46a5c3f
bookmark: add methods to binary encode and decode bookmark values
Boris Feld <boris.feld@octobus.net>
parents:
34708
diff
changeset
|
626 |
node, length = _binaryentry.unpack(entry) |
3340d46a5c3f
bookmark: add methods to binary encode and decode bookmark values
Boris Feld <boris.feld@octobus.net>
parents:
34708
diff
changeset
|
627 |
bookmark = stream.read(length) |
3340d46a5c3f
bookmark: add methods to binary encode and decode bookmark values
Boris Feld <boris.feld@octobus.net>
parents:
34708
diff
changeset
|
628 |
if len(bookmark) < length: |
3340d46a5c3f
bookmark: add methods to binary encode and decode bookmark values
Boris Feld <boris.feld@octobus.net>
parents:
34708
diff
changeset
|
629 |
if entry: |
3340d46a5c3f
bookmark: add methods to binary encode and decode bookmark values
Boris Feld <boris.feld@octobus.net>
parents:
34708
diff
changeset
|
630 |
raise error.Abort(_('bad bookmark stream')) |
3340d46a5c3f
bookmark: add methods to binary encode and decode bookmark values
Boris Feld <boris.feld@octobus.net>
parents:
34708
diff
changeset
|
631 |
if node == wdirid: |
3340d46a5c3f
bookmark: add methods to binary encode and decode bookmark values
Boris Feld <boris.feld@octobus.net>
parents:
34708
diff
changeset
|
632 |
node = None |
3340d46a5c3f
bookmark: add methods to binary encode and decode bookmark values
Boris Feld <boris.feld@octobus.net>
parents:
34708
diff
changeset
|
633 |
books.append((bookmark, node)) |
3340d46a5c3f
bookmark: add methods to binary encode and decode bookmark values
Boris Feld <boris.feld@octobus.net>
parents:
34708
diff
changeset
|
634 |
return books |
3340d46a5c3f
bookmark: add methods to binary encode and decode bookmark values
Boris Feld <boris.feld@octobus.net>
parents:
34708
diff
changeset
|
635 |
|
22666
0f8120c1ecf5
pull: perform bookmark updates in the transaction
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22665
diff
changeset
|
636 |
def updatefromremote(ui, repo, remotemarks, path, trfunc, explicit=()): |
13646
31eac42d9123
bookmarks: separate bookmarks update code from localrepo's pull.
David Soria Parra <dsp@php.net>
parents:
13627
diff
changeset
|
637 |
ui.debug("checking for updated bookmarks\n") |
17922
7f5dab94e48c
bookmarks: introduce a bmstore to manage bookmark persistence
Augie Fackler <raf@durin42.com>
parents:
17918
diff
changeset
|
638 |
localmarks = repo._bookmarks |
23081
e62c330a044f
bookmarks: explicitly track identical bookmarks
Gregory Szorc <gregory.szorc@gmail.com>
parents:
22941
diff
changeset
|
639 |
(addsrc, adddst, advsrc, advdst, diverge, differ, invalid, same |
30583
8f8211903b83
bookmarks: make bookmarks.comparebookmarks accept binary nodes (API)
Stanislau Hlebik <stash@fb.com>
parents:
30582
diff
changeset
|
640 |
) = comparebookmarks(repo, remotemarks, localmarks) |
15614
260a6449d83a
bookmarks: mark divergent bookmarks with book@pathalias when source in [paths]
Matt Mackall <mpm@selenic.com>
parents:
15613
diff
changeset
|
641 |
|
22644
1ec7cdaf898f
bookmarks: allow `updatefromremote` to be quiet
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22629
diff
changeset
|
642 |
status = ui.status |
1ec7cdaf898f
bookmarks: allow `updatefromremote` to be quiet
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22629
diff
changeset
|
643 |
warn = ui.warn |
33499
0407a51b9d8c
codemod: register core configitems using a script
Jun Wu <quark@fb.com>
parents:
33491
diff
changeset
|
644 |
if ui.configbool('ui', 'quietbookmarkmove'): |
22644
1ec7cdaf898f
bookmarks: allow `updatefromremote` to be quiet
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22629
diff
changeset
|
645 |
status = warn = ui.debug |
1ec7cdaf898f
bookmarks: allow `updatefromremote` to be quiet
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22629
diff
changeset
|
646 |
|
22659
798185707833
pull: merge bookmark updates and imports
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22658
diff
changeset
|
647 |
explicit = set(explicit) |
20025
e8a11791abfc
bookmarks: rewrite "updatefromremote()" by "compare()"
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
20024
diff
changeset
|
648 |
changed = [] |
e8a11791abfc
bookmarks: rewrite "updatefromremote()" by "compare()"
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
20024
diff
changeset
|
649 |
for b, scid, dcid in addsrc: |
e8a11791abfc
bookmarks: rewrite "updatefromremote()" by "compare()"
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
20024
diff
changeset
|
650 |
if scid in repo: # add remote bookmarks for changes we already have |
30583
8f8211903b83
bookmarks: make bookmarks.comparebookmarks accept binary nodes (API)
Stanislau Hlebik <stash@fb.com>
parents:
30582
diff
changeset
|
651 |
changed.append((b, scid, status, |
20025
e8a11791abfc
bookmarks: rewrite "updatefromremote()" by "compare()"
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
20024
diff
changeset
|
652 |
_("adding remote bookmark %s\n") % (b))) |
25564
847fce27effc
bookmark: informs of failure to upgrade a bookmark
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
25100
diff
changeset
|
653 |
elif b in explicit: |
847fce27effc
bookmark: informs of failure to upgrade a bookmark
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
25100
diff
changeset
|
654 |
explicit.remove(b) |
847fce27effc
bookmark: informs of failure to upgrade a bookmark
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
25100
diff
changeset
|
655 |
ui.warn(_("remote bookmark %s points to locally missing %s\n") |
30583
8f8211903b83
bookmarks: make bookmarks.comparebookmarks accept binary nodes (API)
Stanislau Hlebik <stash@fb.com>
parents:
30582
diff
changeset
|
656 |
% (b, hex(scid)[:12])) |
25564
847fce27effc
bookmark: informs of failure to upgrade a bookmark
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
25100
diff
changeset
|
657 |
|
20025
e8a11791abfc
bookmarks: rewrite "updatefromremote()" by "compare()"
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
20024
diff
changeset
|
658 |
for b, scid, dcid in advsrc: |
30583
8f8211903b83
bookmarks: make bookmarks.comparebookmarks accept binary nodes (API)
Stanislau Hlebik <stash@fb.com>
parents:
30582
diff
changeset
|
659 |
changed.append((b, scid, status, |
20025
e8a11791abfc
bookmarks: rewrite "updatefromremote()" by "compare()"
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
20024
diff
changeset
|
660 |
_("updating bookmark %s\n") % (b))) |
22659
798185707833
pull: merge bookmark updates and imports
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22658
diff
changeset
|
661 |
# remove normal movement from explicit set |
798185707833
pull: merge bookmark updates and imports
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22658
diff
changeset
|
662 |
explicit.difference_update(d[0] for d in changed) |
798185707833
pull: merge bookmark updates and imports
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22658
diff
changeset
|
663 |
|
20025
e8a11791abfc
bookmarks: rewrite "updatefromremote()" by "compare()"
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
20024
diff
changeset
|
664 |
for b, scid, dcid in diverge: |
22659
798185707833
pull: merge bookmark updates and imports
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22658
diff
changeset
|
665 |
if b in explicit: |
798185707833
pull: merge bookmark updates and imports
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22658
diff
changeset
|
666 |
explicit.discard(b) |
30583
8f8211903b83
bookmarks: make bookmarks.comparebookmarks accept binary nodes (API)
Stanislau Hlebik <stash@fb.com>
parents:
30582
diff
changeset
|
667 |
changed.append((b, scid, status, |
23199
c35ffa4249ca
bookmarks: fix formatting of exchange message (issue4439)
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
23081
diff
changeset
|
668 |
_("importing bookmark %s\n") % (b))) |
22659
798185707833
pull: merge bookmark updates and imports
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22658
diff
changeset
|
669 |
else: |
30583
8f8211903b83
bookmarks: make bookmarks.comparebookmarks accept binary nodes (API)
Stanislau Hlebik <stash@fb.com>
parents:
30582
diff
changeset
|
670 |
db = _diverge(ui, b, path, localmarks, scid) |
24353
3f6bf9f29e7b
bookmarks: prevent divergent bookmark from being updated unexpectedly
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
24306
diff
changeset
|
671 |
if db: |
30583
8f8211903b83
bookmarks: make bookmarks.comparebookmarks accept binary nodes (API)
Stanislau Hlebik <stash@fb.com>
parents:
30582
diff
changeset
|
672 |
changed.append((db, scid, warn, |
24353
3f6bf9f29e7b
bookmarks: prevent divergent bookmark from being updated unexpectedly
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
24306
diff
changeset
|
673 |
_("divergent bookmark %s stored as %s\n") % |
3f6bf9f29e7b
bookmarks: prevent divergent bookmark from being updated unexpectedly
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
24306
diff
changeset
|
674 |
(b, db))) |
3f6bf9f29e7b
bookmarks: prevent divergent bookmark from being updated unexpectedly
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
24306
diff
changeset
|
675 |
else: |
3f6bf9f29e7b
bookmarks: prevent divergent bookmark from being updated unexpectedly
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
24306
diff
changeset
|
676 |
warn(_("warning: failed to assign numbered name " |
3f6bf9f29e7b
bookmarks: prevent divergent bookmark from being updated unexpectedly
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
24306
diff
changeset
|
677 |
"to divergent bookmark %s\n") % (b)) |
22659
798185707833
pull: merge bookmark updates and imports
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22658
diff
changeset
|
678 |
for b, scid, dcid in adddst + advdst: |
798185707833
pull: merge bookmark updates and imports
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22658
diff
changeset
|
679 |
if b in explicit: |
798185707833
pull: merge bookmark updates and imports
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22658
diff
changeset
|
680 |
explicit.discard(b) |
30583
8f8211903b83
bookmarks: make bookmarks.comparebookmarks accept binary nodes (API)
Stanislau Hlebik <stash@fb.com>
parents:
30582
diff
changeset
|
681 |
changed.append((b, scid, status, |
23199
c35ffa4249ca
bookmarks: fix formatting of exchange message (issue4439)
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
23081
diff
changeset
|
682 |
_("importing bookmark %s\n") % (b))) |
25564
847fce27effc
bookmark: informs of failure to upgrade a bookmark
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
25100
diff
changeset
|
683 |
for b, scid, dcid in differ: |
847fce27effc
bookmark: informs of failure to upgrade a bookmark
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
25100
diff
changeset
|
684 |
if b in explicit: |
847fce27effc
bookmark: informs of failure to upgrade a bookmark
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
25100
diff
changeset
|
685 |
explicit.remove(b) |
847fce27effc
bookmark: informs of failure to upgrade a bookmark
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
25100
diff
changeset
|
686 |
ui.warn(_("remote bookmark %s points to locally missing %s\n") |
30583
8f8211903b83
bookmarks: make bookmarks.comparebookmarks accept binary nodes (API)
Stanislau Hlebik <stash@fb.com>
parents:
30582
diff
changeset
|
687 |
% (b, hex(scid)[:12])) |
22659
798185707833
pull: merge bookmark updates and imports
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22658
diff
changeset
|
688 |
|
13646
31eac42d9123
bookmarks: separate bookmarks update code from localrepo's pull.
David Soria Parra <dsp@php.net>
parents:
13627
diff
changeset
|
689 |
if changed: |
22666
0f8120c1ecf5
pull: perform bookmark updates in the transaction
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
22665
diff
changeset
|
690 |
tr = trfunc() |
33484
2a8ce4e79a47
bookmark: use 'applychanges' when updating from a remote
Boris Feld <boris.feld@octobus.net>
parents:
33483
diff
changeset
|
691 |
changes = [] |
20025
e8a11791abfc
bookmarks: rewrite "updatefromremote()" by "compare()"
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
20024
diff
changeset
|
692 |
for b, node, writer, msg in sorted(changed): |
33484
2a8ce4e79a47
bookmark: use 'applychanges' when updating from a remote
Boris Feld <boris.feld@octobus.net>
parents:
33483
diff
changeset
|
693 |
changes.append((b, node)) |
20025
e8a11791abfc
bookmarks: rewrite "updatefromremote()" by "compare()"
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
20024
diff
changeset
|
694 |
writer(msg) |
33484
2a8ce4e79a47
bookmark: use 'applychanges' when updating from a remote
Boris Feld <boris.feld@octobus.net>
parents:
33483
diff
changeset
|
695 |
localmarks.applychanges(repo, tr, changes) |
13646
31eac42d9123
bookmarks: separate bookmarks update code from localrepo's pull.
David Soria Parra <dsp@php.net>
parents:
13627
diff
changeset
|
696 |
|
37641
add129811176
bookmarks: use command executor for wire protocol commands
Gregory Szorc <gregory.szorc@gmail.com>
parents:
37450
diff
changeset
|
697 |
def incoming(ui, repo, peer): |
24397
d0ea2028e8e6
bookmarks: add incoming() to replace diff() for incoming bookmarks
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
24355
diff
changeset
|
698 |
'''Show bookmarks incoming from other to repo |
d0ea2028e8e6
bookmarks: add incoming() to replace diff() for incoming bookmarks
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
24355
diff
changeset
|
699 |
''' |
d0ea2028e8e6
bookmarks: add incoming() to replace diff() for incoming bookmarks
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
24355
diff
changeset
|
700 |
ui.status(_("searching for changed bookmarks\n")) |
d0ea2028e8e6
bookmarks: add incoming() to replace diff() for incoming bookmarks
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
24355
diff
changeset
|
701 |
|
37641
add129811176
bookmarks: use command executor for wire protocol commands
Gregory Szorc <gregory.szorc@gmail.com>
parents:
37450
diff
changeset
|
702 |
with peer.commandexecutor() as e: |
add129811176
bookmarks: use command executor for wire protocol commands
Gregory Szorc <gregory.szorc@gmail.com>
parents:
37450
diff
changeset
|
703 |
remotemarks = unhexlifybookmarks(e.callcommand('listkeys', { |
add129811176
bookmarks: use command executor for wire protocol commands
Gregory Szorc <gregory.szorc@gmail.com>
parents:
37450
diff
changeset
|
704 |
'namespace': 'bookmarks', |
add129811176
bookmarks: use command executor for wire protocol commands
Gregory Szorc <gregory.szorc@gmail.com>
parents:
37450
diff
changeset
|
705 |
}).result()) |
add129811176
bookmarks: use command executor for wire protocol commands
Gregory Szorc <gregory.szorc@gmail.com>
parents:
37450
diff
changeset
|
706 |
|
30583
8f8211903b83
bookmarks: make bookmarks.comparebookmarks accept binary nodes (API)
Stanislau Hlebik <stash@fb.com>
parents:
30582
diff
changeset
|
707 |
r = comparebookmarks(repo, remotemarks, repo._bookmarks) |
24397
d0ea2028e8e6
bookmarks: add incoming() to replace diff() for incoming bookmarks
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
24355
diff
changeset
|
708 |
addsrc, adddst, advsrc, advdst, diverge, differ, invalid, same = r |
d0ea2028e8e6
bookmarks: add incoming() to replace diff() for incoming bookmarks
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
24355
diff
changeset
|
709 |
|
d0ea2028e8e6
bookmarks: add incoming() to replace diff() for incoming bookmarks
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
24355
diff
changeset
|
710 |
incomings = [] |
d0ea2028e8e6
bookmarks: add incoming() to replace diff() for incoming bookmarks
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
24355
diff
changeset
|
711 |
if ui.debugflag: |
d0ea2028e8e6
bookmarks: add incoming() to replace diff() for incoming bookmarks
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
24355
diff
changeset
|
712 |
getid = lambda id: id |
d0ea2028e8e6
bookmarks: add incoming() to replace diff() for incoming bookmarks
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
24355
diff
changeset
|
713 |
else: |
d0ea2028e8e6
bookmarks: add incoming() to replace diff() for incoming bookmarks
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
24355
diff
changeset
|
714 |
getid = lambda id: id[:12] |
24660
bf13b44bbb0a
bookmarks: show detailed status about incoming bookmarks
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
24658
diff
changeset
|
715 |
if ui.verbose: |
bf13b44bbb0a
bookmarks: show detailed status about incoming bookmarks
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
24658
diff
changeset
|
716 |
def add(b, id, st): |
bf13b44bbb0a
bookmarks: show detailed status about incoming bookmarks
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
24658
diff
changeset
|
717 |
incomings.append(" %-25s %s %s\n" % (b, getid(id), st)) |
bf13b44bbb0a
bookmarks: show detailed status about incoming bookmarks
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
24658
diff
changeset
|
718 |
else: |
bf13b44bbb0a
bookmarks: show detailed status about incoming bookmarks
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
24658
diff
changeset
|
719 |
def add(b, id, st): |
bf13b44bbb0a
bookmarks: show detailed status about incoming bookmarks
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
24658
diff
changeset
|
720 |
incomings.append(" %-25s %s\n" % (b, getid(id))) |
24397
d0ea2028e8e6
bookmarks: add incoming() to replace diff() for incoming bookmarks
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
24355
diff
changeset
|
721 |
for b, scid, dcid in addsrc: |
24832
5947a68fa271
bookmarks: add i18n hints to bookmark sync states
Wagner Bruna <wbruna@yahoo.com>
parents:
24661
diff
changeset
|
722 |
# i18n: "added" refers to a bookmark |
30583
8f8211903b83
bookmarks: make bookmarks.comparebookmarks accept binary nodes (API)
Stanislau Hlebik <stash@fb.com>
parents:
30582
diff
changeset
|
723 |
add(b, hex(scid), _('added')) |
24657
3d7c512b258d
bookmarks: show incoming bookmarks more exactly
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
24400
diff
changeset
|
724 |
for b, scid, dcid in advsrc: |
24832
5947a68fa271
bookmarks: add i18n hints to bookmark sync states
Wagner Bruna <wbruna@yahoo.com>
parents:
24661
diff
changeset
|
725 |
# i18n: "advanced" refers to a bookmark |
30583
8f8211903b83
bookmarks: make bookmarks.comparebookmarks accept binary nodes (API)
Stanislau Hlebik <stash@fb.com>
parents:
30582
diff
changeset
|
726 |
add(b, hex(scid), _('advanced')) |
24657
3d7c512b258d
bookmarks: show incoming bookmarks more exactly
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
24400
diff
changeset
|
727 |
for b, scid, dcid in diverge: |
24832
5947a68fa271
bookmarks: add i18n hints to bookmark sync states
Wagner Bruna <wbruna@yahoo.com>
parents:
24661
diff
changeset
|
728 |
# i18n: "diverged" refers to a bookmark |
30583
8f8211903b83
bookmarks: make bookmarks.comparebookmarks accept binary nodes (API)
Stanislau Hlebik <stash@fb.com>
parents:
30582
diff
changeset
|
729 |
add(b, hex(scid), _('diverged')) |
24657
3d7c512b258d
bookmarks: show incoming bookmarks more exactly
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
24400
diff
changeset
|
730 |
for b, scid, dcid in differ: |
24832
5947a68fa271
bookmarks: add i18n hints to bookmark sync states
Wagner Bruna <wbruna@yahoo.com>
parents:
24661
diff
changeset
|
731 |
# i18n: "changed" refers to a bookmark |
30583
8f8211903b83
bookmarks: make bookmarks.comparebookmarks accept binary nodes (API)
Stanislau Hlebik <stash@fb.com>
parents:
30582
diff
changeset
|
732 |
add(b, hex(scid), _('changed')) |
24397
d0ea2028e8e6
bookmarks: add incoming() to replace diff() for incoming bookmarks
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
24355
diff
changeset
|
733 |
|
d0ea2028e8e6
bookmarks: add incoming() to replace diff() for incoming bookmarks
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
24355
diff
changeset
|
734 |
if not incomings: |
d0ea2028e8e6
bookmarks: add incoming() to replace diff() for incoming bookmarks
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
24355
diff
changeset
|
735 |
ui.status(_("no changed bookmarks found\n")) |
d0ea2028e8e6
bookmarks: add incoming() to replace diff() for incoming bookmarks
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
24355
diff
changeset
|
736 |
return 1 |
d0ea2028e8e6
bookmarks: add incoming() to replace diff() for incoming bookmarks
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
24355
diff
changeset
|
737 |
|
d0ea2028e8e6
bookmarks: add incoming() to replace diff() for incoming bookmarks
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
24355
diff
changeset
|
738 |
for s in sorted(incomings): |
d0ea2028e8e6
bookmarks: add incoming() to replace diff() for incoming bookmarks
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
24355
diff
changeset
|
739 |
ui.write(s) |
d0ea2028e8e6
bookmarks: add incoming() to replace diff() for incoming bookmarks
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
24355
diff
changeset
|
740 |
|
d0ea2028e8e6
bookmarks: add incoming() to replace diff() for incoming bookmarks
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
24355
diff
changeset
|
741 |
return 0 |
d0ea2028e8e6
bookmarks: add incoming() to replace diff() for incoming bookmarks
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
24355
diff
changeset
|
742 |
|
24398
c0096a2bd3ff
bookmarks: add outgoing() to replace diff() for outgoing bookmarks
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
24397
diff
changeset
|
743 |
def outgoing(ui, repo, other): |
c0096a2bd3ff
bookmarks: add outgoing() to replace diff() for outgoing bookmarks
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
24397
diff
changeset
|
744 |
'''Show bookmarks outgoing from repo to other |
c0096a2bd3ff
bookmarks: add outgoing() to replace diff() for outgoing bookmarks
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
24397
diff
changeset
|
745 |
''' |
c0096a2bd3ff
bookmarks: add outgoing() to replace diff() for outgoing bookmarks
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
24397
diff
changeset
|
746 |
ui.status(_("searching for changed bookmarks\n")) |
c0096a2bd3ff
bookmarks: add outgoing() to replace diff() for outgoing bookmarks
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
24397
diff
changeset
|
747 |
|
30583
8f8211903b83
bookmarks: make bookmarks.comparebookmarks accept binary nodes (API)
Stanislau Hlebik <stash@fb.com>
parents:
30582
diff
changeset
|
748 |
remotemarks = unhexlifybookmarks(other.listkeys('bookmarks')) |
8f8211903b83
bookmarks: make bookmarks.comparebookmarks accept binary nodes (API)
Stanislau Hlebik <stash@fb.com>
parents:
30582
diff
changeset
|
749 |
r = comparebookmarks(repo, repo._bookmarks, remotemarks) |
24398
c0096a2bd3ff
bookmarks: add outgoing() to replace diff() for outgoing bookmarks
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
24397
diff
changeset
|
750 |
addsrc, adddst, advsrc, advdst, diverge, differ, invalid, same = r |
c0096a2bd3ff
bookmarks: add outgoing() to replace diff() for outgoing bookmarks
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
24397
diff
changeset
|
751 |
|
c0096a2bd3ff
bookmarks: add outgoing() to replace diff() for outgoing bookmarks
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
24397
diff
changeset
|
752 |
outgoings = [] |
c0096a2bd3ff
bookmarks: add outgoing() to replace diff() for outgoing bookmarks
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
24397
diff
changeset
|
753 |
if ui.debugflag: |
c0096a2bd3ff
bookmarks: add outgoing() to replace diff() for outgoing bookmarks
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
24397
diff
changeset
|
754 |
getid = lambda id: id |
c0096a2bd3ff
bookmarks: add outgoing() to replace diff() for outgoing bookmarks
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
24397
diff
changeset
|
755 |
else: |
c0096a2bd3ff
bookmarks: add outgoing() to replace diff() for outgoing bookmarks
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
24397
diff
changeset
|
756 |
getid = lambda id: id[:12] |
24661
8cf70c97a6e1
bookmarks: show detailed status about outgoing bookmarks
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
24660
diff
changeset
|
757 |
if ui.verbose: |
8cf70c97a6e1
bookmarks: show detailed status about outgoing bookmarks
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
24660
diff
changeset
|
758 |
def add(b, id, st): |
8cf70c97a6e1
bookmarks: show detailed status about outgoing bookmarks
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
24660
diff
changeset
|
759 |
outgoings.append(" %-25s %s %s\n" % (b, getid(id), st)) |
8cf70c97a6e1
bookmarks: show detailed status about outgoing bookmarks
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
24660
diff
changeset
|
760 |
else: |
8cf70c97a6e1
bookmarks: show detailed status about outgoing bookmarks
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
24660
diff
changeset
|
761 |
def add(b, id, st): |
8cf70c97a6e1
bookmarks: show detailed status about outgoing bookmarks
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
24660
diff
changeset
|
762 |
outgoings.append(" %-25s %s\n" % (b, getid(id))) |
24398
c0096a2bd3ff
bookmarks: add outgoing() to replace diff() for outgoing bookmarks
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
24397
diff
changeset
|
763 |
for b, scid, dcid in addsrc: |
24832
5947a68fa271
bookmarks: add i18n hints to bookmark sync states
Wagner Bruna <wbruna@yahoo.com>
parents:
24661
diff
changeset
|
764 |
# i18n: "added refers to a bookmark |
30583
8f8211903b83
bookmarks: make bookmarks.comparebookmarks accept binary nodes (API)
Stanislau Hlebik <stash@fb.com>
parents:
30582
diff
changeset
|
765 |
add(b, hex(scid), _('added')) |
24658
8ea893ab0572
bookmarks: show outgoing bookmarks more exactly
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
24657
diff
changeset
|
766 |
for b, scid, dcid in adddst: |
24832
5947a68fa271
bookmarks: add i18n hints to bookmark sync states
Wagner Bruna <wbruna@yahoo.com>
parents:
24661
diff
changeset
|
767 |
# i18n: "deleted" refers to a bookmark |
24661
8cf70c97a6e1
bookmarks: show detailed status about outgoing bookmarks
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
24660
diff
changeset
|
768 |
add(b, ' ' * 40, _('deleted')) |
24658
8ea893ab0572
bookmarks: show outgoing bookmarks more exactly
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
24657
diff
changeset
|
769 |
for b, scid, dcid in advsrc: |
24832
5947a68fa271
bookmarks: add i18n hints to bookmark sync states
Wagner Bruna <wbruna@yahoo.com>
parents:
24661
diff
changeset
|
770 |
# i18n: "advanced" refers to a bookmark |
30583
8f8211903b83
bookmarks: make bookmarks.comparebookmarks accept binary nodes (API)
Stanislau Hlebik <stash@fb.com>
parents:
30582
diff
changeset
|
771 |
add(b, hex(scid), _('advanced')) |
24658
8ea893ab0572
bookmarks: show outgoing bookmarks more exactly
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
24657
diff
changeset
|
772 |
for b, scid, dcid in diverge: |
24832
5947a68fa271
bookmarks: add i18n hints to bookmark sync states
Wagner Bruna <wbruna@yahoo.com>
parents:
24661
diff
changeset
|
773 |
# i18n: "diverged" refers to a bookmark |
30583
8f8211903b83
bookmarks: make bookmarks.comparebookmarks accept binary nodes (API)
Stanislau Hlebik <stash@fb.com>
parents:
30582
diff
changeset
|
774 |
add(b, hex(scid), _('diverged')) |
24658
8ea893ab0572
bookmarks: show outgoing bookmarks more exactly
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
24657
diff
changeset
|
775 |
for b, scid, dcid in differ: |
24832
5947a68fa271
bookmarks: add i18n hints to bookmark sync states
Wagner Bruna <wbruna@yahoo.com>
parents:
24661
diff
changeset
|
776 |
# i18n: "changed" refers to a bookmark |
30583
8f8211903b83
bookmarks: make bookmarks.comparebookmarks accept binary nodes (API)
Stanislau Hlebik <stash@fb.com>
parents:
30582
diff
changeset
|
777 |
add(b, hex(scid), _('changed')) |
24398
c0096a2bd3ff
bookmarks: add outgoing() to replace diff() for outgoing bookmarks
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
24397
diff
changeset
|
778 |
|
c0096a2bd3ff
bookmarks: add outgoing() to replace diff() for outgoing bookmarks
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
24397
diff
changeset
|
779 |
if not outgoings: |
c0096a2bd3ff
bookmarks: add outgoing() to replace diff() for outgoing bookmarks
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
24397
diff
changeset
|
780 |
ui.status(_("no changed bookmarks found\n")) |
c0096a2bd3ff
bookmarks: add outgoing() to replace diff() for outgoing bookmarks
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
24397
diff
changeset
|
781 |
return 1 |
c0096a2bd3ff
bookmarks: add outgoing() to replace diff() for outgoing bookmarks
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
24397
diff
changeset
|
782 |
|
c0096a2bd3ff
bookmarks: add outgoing() to replace diff() for outgoing bookmarks
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
24397
diff
changeset
|
783 |
for s in sorted(outgoings): |
c0096a2bd3ff
bookmarks: add outgoing() to replace diff() for outgoing bookmarks
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
24397
diff
changeset
|
784 |
ui.write(s) |
c0096a2bd3ff
bookmarks: add outgoing() to replace diff() for outgoing bookmarks
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
24397
diff
changeset
|
785 |
|
c0096a2bd3ff
bookmarks: add outgoing() to replace diff() for outgoing bookmarks
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
24397
diff
changeset
|
786 |
return 0 |
c0096a2bd3ff
bookmarks: add outgoing() to replace diff() for outgoing bookmarks
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
24397
diff
changeset
|
787 |
|
37641
add129811176
bookmarks: use command executor for wire protocol commands
Gregory Szorc <gregory.szorc@gmail.com>
parents:
37450
diff
changeset
|
788 |
def summary(repo, peer): |
24400
03c84c966ef5
bookmarks: rewrite comparing bookmarks in commands.summary() by compare()
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
24399
diff
changeset
|
789 |
'''Compare bookmarks between repo and other for "hg summary" output |
03c84c966ef5
bookmarks: rewrite comparing bookmarks in commands.summary() by compare()
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
24399
diff
changeset
|
790 |
|
03c84c966ef5
bookmarks: rewrite comparing bookmarks in commands.summary() by compare()
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
24399
diff
changeset
|
791 |
This returns "(# of incoming, # of outgoing)" tuple. |
03c84c966ef5
bookmarks: rewrite comparing bookmarks in commands.summary() by compare()
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
24399
diff
changeset
|
792 |
''' |
37641
add129811176
bookmarks: use command executor for wire protocol commands
Gregory Szorc <gregory.szorc@gmail.com>
parents:
37450
diff
changeset
|
793 |
with peer.commandexecutor() as e: |
add129811176
bookmarks: use command executor for wire protocol commands
Gregory Szorc <gregory.szorc@gmail.com>
parents:
37450
diff
changeset
|
794 |
remotemarks = unhexlifybookmarks(e.callcommand('listkeys', { |
add129811176
bookmarks: use command executor for wire protocol commands
Gregory Szorc <gregory.szorc@gmail.com>
parents:
37450
diff
changeset
|
795 |
'namespace': 'bookmarks', |
add129811176
bookmarks: use command executor for wire protocol commands
Gregory Szorc <gregory.szorc@gmail.com>
parents:
37450
diff
changeset
|
796 |
}).result()) |
add129811176
bookmarks: use command executor for wire protocol commands
Gregory Szorc <gregory.szorc@gmail.com>
parents:
37450
diff
changeset
|
797 |
|
30583
8f8211903b83
bookmarks: make bookmarks.comparebookmarks accept binary nodes (API)
Stanislau Hlebik <stash@fb.com>
parents:
30582
diff
changeset
|
798 |
r = comparebookmarks(repo, remotemarks, repo._bookmarks) |
24400
03c84c966ef5
bookmarks: rewrite comparing bookmarks in commands.summary() by compare()
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
24399
diff
changeset
|
799 |
addsrc, adddst, advsrc, advdst, diverge, differ, invalid, same = r |
03c84c966ef5
bookmarks: rewrite comparing bookmarks in commands.summary() by compare()
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
24399
diff
changeset
|
800 |
return (len(addsrc), len(adddst)) |
03c84c966ef5
bookmarks: rewrite comparing bookmarks in commands.summary() by compare()
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
24399
diff
changeset
|
801 |
|
17550
fc530080013b
bookmarks: extract valid destination logic in a dedicated function
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
17425
diff
changeset
|
802 |
def validdest(repo, old, new): |
fc530080013b
bookmarks: extract valid destination logic in a dedicated function
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
17425
diff
changeset
|
803 |
"""Is the new bookmark destination a valid update from the old one""" |
18008
cf91b36f368c
clfilter: `bookmark.validdest` should run on unfiltered repo
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
17922
diff
changeset
|
804 |
repo = repo.unfiltered() |
17551
a7b3fdaf768d
bookmark: take successors into account when updating (issue3561)
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
17550
diff
changeset
|
805 |
if old == new: |
a7b3fdaf768d
bookmark: take successors into account when updating (issue3561)
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
17550
diff
changeset
|
806 |
# Old == new -> nothing to update. |
17625
b83c18204c36
bookmarks: avoid redundant creation/assignment of "validdests" in "validdest()"
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
17551
diff
changeset
|
807 |
return False |
17551
a7b3fdaf768d
bookmark: take successors into account when updating (issue3561)
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
17550
diff
changeset
|
808 |
elif not old: |
a7b3fdaf768d
bookmark: take successors into account when updating (issue3561)
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
17550
diff
changeset
|
809 |
# old is nullrev, anything is valid. |
a7b3fdaf768d
bookmark: take successors into account when updating (issue3561)
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
17550
diff
changeset
|
810 |
# (new != nullrev has been excluded by the previous check) |
17625
b83c18204c36
bookmarks: avoid redundant creation/assignment of "validdests" in "validdest()"
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
17551
diff
changeset
|
811 |
return True |
17551
a7b3fdaf768d
bookmark: take successors into account when updating (issue3561)
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
17550
diff
changeset
|
812 |
elif repo.obsstore: |
33146
7017567ebdf2
obsutil: move 'foreground' to the new modules
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
33092
diff
changeset
|
813 |
return new.node() in obsutil.foreground(repo, [old.node()]) |
17551
a7b3fdaf768d
bookmark: take successors into account when updating (issue3561)
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
17550
diff
changeset
|
814 |
else: |
24180
d8e0c591781c
spelling: fixes from proofreading of spell checker issues
Mads Kiilerich <madski@unity3d.com>
parents:
23877
diff
changeset
|
815 |
# still an independent clause as it is lazier (and therefore faster) |
38670
fbec9c0b32d3
context: rename descendant() to isancestorof()
Martin von Zweigbergk <martinvonz@google.com>
parents:
38538
diff
changeset
|
816 |
return old.isancestorof(new) |
32955
70661eeb8ddb
commands: move checkformat to bookmarks module
Sean Farley <sean@farley.io>
parents:
32794
diff
changeset
|
817 |
|
70661eeb8ddb
commands: move checkformat to bookmarks module
Sean Farley <sean@farley.io>
parents:
32794
diff
changeset
|
818 |
def checkformat(repo, mark): |
70661eeb8ddb
commands: move checkformat to bookmarks module
Sean Farley <sean@farley.io>
parents:
32794
diff
changeset
|
819 |
"""return a valid version of a potential bookmark name |
70661eeb8ddb
commands: move checkformat to bookmarks module
Sean Farley <sean@farley.io>
parents:
32794
diff
changeset
|
820 |
|
70661eeb8ddb
commands: move checkformat to bookmarks module
Sean Farley <sean@farley.io>
parents:
32794
diff
changeset
|
821 |
Raises an abort error if the bookmark name is not valid. |
70661eeb8ddb
commands: move checkformat to bookmarks module
Sean Farley <sean@farley.io>
parents:
32794
diff
changeset
|
822 |
""" |
70661eeb8ddb
commands: move checkformat to bookmarks module
Sean Farley <sean@farley.io>
parents:
32794
diff
changeset
|
823 |
mark = mark.strip() |
70661eeb8ddb
commands: move checkformat to bookmarks module
Sean Farley <sean@farley.io>
parents:
32794
diff
changeset
|
824 |
if not mark: |
70661eeb8ddb
commands: move checkformat to bookmarks module
Sean Farley <sean@farley.io>
parents:
32794
diff
changeset
|
825 |
raise error.Abort(_("bookmark names cannot consist entirely of " |
70661eeb8ddb
commands: move checkformat to bookmarks module
Sean Farley <sean@farley.io>
parents:
32794
diff
changeset
|
826 |
"whitespace")) |
70661eeb8ddb
commands: move checkformat to bookmarks module
Sean Farley <sean@farley.io>
parents:
32794
diff
changeset
|
827 |
scmutil.checknewlabel(repo, mark, 'bookmark') |
70661eeb8ddb
commands: move checkformat to bookmarks module
Sean Farley <sean@farley.io>
parents:
32794
diff
changeset
|
828 |
return mark |
33005
9343fce87789
bookmarks: factor out delete logic from commands
Sean Farley <sean@farley.io>
parents:
32956
diff
changeset
|
829 |
|
9343fce87789
bookmarks: factor out delete logic from commands
Sean Farley <sean@farley.io>
parents:
32956
diff
changeset
|
830 |
def delete(repo, tr, names): |
9343fce87789
bookmarks: factor out delete logic from commands
Sean Farley <sean@farley.io>
parents:
32956
diff
changeset
|
831 |
"""remove a mark from the bookmark store |
9343fce87789
bookmarks: factor out delete logic from commands
Sean Farley <sean@farley.io>
parents:
32956
diff
changeset
|
832 |
|
9343fce87789
bookmarks: factor out delete logic from commands
Sean Farley <sean@farley.io>
parents:
32956
diff
changeset
|
833 |
Raises an abort error if mark does not exist. |
9343fce87789
bookmarks: factor out delete logic from commands
Sean Farley <sean@farley.io>
parents:
32956
diff
changeset
|
834 |
""" |
9343fce87789
bookmarks: factor out delete logic from commands
Sean Farley <sean@farley.io>
parents:
32956
diff
changeset
|
835 |
marks = repo._bookmarks |
33481
67b5f81f17cf
bookmark: use 'applychanges' for bookmark deletion
Boris Feld <boris.feld@octobus.net>
parents:
33480
diff
changeset
|
836 |
changes = [] |
33005
9343fce87789
bookmarks: factor out delete logic from commands
Sean Farley <sean@farley.io>
parents:
32956
diff
changeset
|
837 |
for mark in names: |
9343fce87789
bookmarks: factor out delete logic from commands
Sean Farley <sean@farley.io>
parents:
32956
diff
changeset
|
838 |
if mark not in marks: |
9343fce87789
bookmarks: factor out delete logic from commands
Sean Farley <sean@farley.io>
parents:
32956
diff
changeset
|
839 |
raise error.Abort(_("bookmark '%s' does not exist") % mark) |
9343fce87789
bookmarks: factor out delete logic from commands
Sean Farley <sean@farley.io>
parents:
32956
diff
changeset
|
840 |
if mark == repo._activebookmark: |
9343fce87789
bookmarks: factor out delete logic from commands
Sean Farley <sean@farley.io>
parents:
32956
diff
changeset
|
841 |
deactivate(repo) |
33481
67b5f81f17cf
bookmark: use 'applychanges' for bookmark deletion
Boris Feld <boris.feld@octobus.net>
parents:
33480
diff
changeset
|
842 |
changes.append((mark, None)) |
67b5f81f17cf
bookmark: use 'applychanges' for bookmark deletion
Boris Feld <boris.feld@octobus.net>
parents:
33480
diff
changeset
|
843 |
marks.applychanges(repo, tr, changes) |
33006
e0a8dd6c87c7
bookmarks: factor out rename logic from commands
Sean Farley <sean@farley.io>
parents:
33005
diff
changeset
|
844 |
|
e0a8dd6c87c7
bookmarks: factor out rename logic from commands
Sean Farley <sean@farley.io>
parents:
33005
diff
changeset
|
845 |
def rename(repo, tr, old, new, force=False, inactive=False): |
e0a8dd6c87c7
bookmarks: factor out rename logic from commands
Sean Farley <sean@farley.io>
parents:
33005
diff
changeset
|
846 |
"""rename a bookmark from old to new |
e0a8dd6c87c7
bookmarks: factor out rename logic from commands
Sean Farley <sean@farley.io>
parents:
33005
diff
changeset
|
847 |
|
e0a8dd6c87c7
bookmarks: factor out rename logic from commands
Sean Farley <sean@farley.io>
parents:
33005
diff
changeset
|
848 |
If force is specified, then the new name can overwrite an existing |
e0a8dd6c87c7
bookmarks: factor out rename logic from commands
Sean Farley <sean@farley.io>
parents:
33005
diff
changeset
|
849 |
bookmark. |
e0a8dd6c87c7
bookmarks: factor out rename logic from commands
Sean Farley <sean@farley.io>
parents:
33005
diff
changeset
|
850 |
|
e0a8dd6c87c7
bookmarks: factor out rename logic from commands
Sean Farley <sean@farley.io>
parents:
33005
diff
changeset
|
851 |
If inactive is specified, then do not activate the new bookmark. |
e0a8dd6c87c7
bookmarks: factor out rename logic from commands
Sean Farley <sean@farley.io>
parents:
33005
diff
changeset
|
852 |
|
e0a8dd6c87c7
bookmarks: factor out rename logic from commands
Sean Farley <sean@farley.io>
parents:
33005
diff
changeset
|
853 |
Raises an abort error if old is not in the bookmark store. |
e0a8dd6c87c7
bookmarks: factor out rename logic from commands
Sean Farley <sean@farley.io>
parents:
33005
diff
changeset
|
854 |
""" |
e0a8dd6c87c7
bookmarks: factor out rename logic from commands
Sean Farley <sean@farley.io>
parents:
33005
diff
changeset
|
855 |
marks = repo._bookmarks |
e0a8dd6c87c7
bookmarks: factor out rename logic from commands
Sean Farley <sean@farley.io>
parents:
33005
diff
changeset
|
856 |
mark = checkformat(repo, new) |
e0a8dd6c87c7
bookmarks: factor out rename logic from commands
Sean Farley <sean@farley.io>
parents:
33005
diff
changeset
|
857 |
if old not in marks: |
e0a8dd6c87c7
bookmarks: factor out rename logic from commands
Sean Farley <sean@farley.io>
parents:
33005
diff
changeset
|
858 |
raise error.Abort(_("bookmark '%s' does not exist") % old) |
33513
904894edb205
bookmark: use 'divergent2delete' in checkconflict
Boris Feld <boris.feld@octobus.net>
parents:
33512
diff
changeset
|
859 |
changes = [] |
904894edb205
bookmark: use 'divergent2delete' in checkconflict
Boris Feld <boris.feld@octobus.net>
parents:
33512
diff
changeset
|
860 |
for bm in marks.checkconflict(mark, force): |
904894edb205
bookmark: use 'divergent2delete' in checkconflict
Boris Feld <boris.feld@octobus.net>
parents:
33512
diff
changeset
|
861 |
changes.append((bm, None)) |
904894edb205
bookmark: use 'divergent2delete' in checkconflict
Boris Feld <boris.feld@octobus.net>
parents:
33512
diff
changeset
|
862 |
changes.extend([(mark, marks[old]), (old, None)]) |
33482
916d4cde530e
bookmark: use 'applychanges' for bookmark renaming
Boris Feld <boris.feld@octobus.net>
parents:
33481
diff
changeset
|
863 |
marks.applychanges(repo, tr, changes) |
33006
e0a8dd6c87c7
bookmarks: factor out rename logic from commands
Sean Farley <sean@farley.io>
parents:
33005
diff
changeset
|
864 |
if repo._activebookmark == old and not inactive: |
e0a8dd6c87c7
bookmarks: factor out rename logic from commands
Sean Farley <sean@farley.io>
parents:
33005
diff
changeset
|
865 |
activate(repo, mark) |
33007
ee081f91b179
bookmarks: factor out adding a list of bookmarks logic from commands
Sean Farley <sean@farley.io>
parents:
33006
diff
changeset
|
866 |
|
ee081f91b179
bookmarks: factor out adding a list of bookmarks logic from commands
Sean Farley <sean@farley.io>
parents:
33006
diff
changeset
|
867 |
def addbookmarks(repo, tr, names, rev=None, force=False, inactive=False): |
ee081f91b179
bookmarks: factor out adding a list of bookmarks logic from commands
Sean Farley <sean@farley.io>
parents:
33006
diff
changeset
|
868 |
"""add a list of bookmarks |
ee081f91b179
bookmarks: factor out adding a list of bookmarks logic from commands
Sean Farley <sean@farley.io>
parents:
33006
diff
changeset
|
869 |
|
ee081f91b179
bookmarks: factor out adding a list of bookmarks logic from commands
Sean Farley <sean@farley.io>
parents:
33006
diff
changeset
|
870 |
If force is specified, then the new name can overwrite an existing |
ee081f91b179
bookmarks: factor out adding a list of bookmarks logic from commands
Sean Farley <sean@farley.io>
parents:
33006
diff
changeset
|
871 |
bookmark. |
ee081f91b179
bookmarks: factor out adding a list of bookmarks logic from commands
Sean Farley <sean@farley.io>
parents:
33006
diff
changeset
|
872 |
|
ee081f91b179
bookmarks: factor out adding a list of bookmarks logic from commands
Sean Farley <sean@farley.io>
parents:
33006
diff
changeset
|
873 |
If inactive is specified, then do not activate any bookmark. Otherwise, the |
ee081f91b179
bookmarks: factor out adding a list of bookmarks logic from commands
Sean Farley <sean@farley.io>
parents:
33006
diff
changeset
|
874 |
first bookmark is activated. |
ee081f91b179
bookmarks: factor out adding a list of bookmarks logic from commands
Sean Farley <sean@farley.io>
parents:
33006
diff
changeset
|
875 |
|
ee081f91b179
bookmarks: factor out adding a list of bookmarks logic from commands
Sean Farley <sean@farley.io>
parents:
33006
diff
changeset
|
876 |
Raises an abort error if old is not in the bookmark store. |
ee081f91b179
bookmarks: factor out adding a list of bookmarks logic from commands
Sean Farley <sean@farley.io>
parents:
33006
diff
changeset
|
877 |
""" |
ee081f91b179
bookmarks: factor out adding a list of bookmarks logic from commands
Sean Farley <sean@farley.io>
parents:
33006
diff
changeset
|
878 |
marks = repo._bookmarks |
37301
a494cccb673e
bookmarks: switch from repo.changectx('.') to repo['.']
Martin von Zweigbergk <martinvonz@google.com>
parents:
36568
diff
changeset
|
879 |
cur = repo['.'].node() |
33007
ee081f91b179
bookmarks: factor out adding a list of bookmarks logic from commands
Sean Farley <sean@farley.io>
parents:
33006
diff
changeset
|
880 |
newact = None |
33483
146c0371eadf
bookmark: use 'applychanges' for adding new bookmark
Boris Feld <boris.feld@octobus.net>
parents:
33482
diff
changeset
|
881 |
changes = [] |
35647
fc39e2bfcd70
bookmarks: calculate visibility exceptions only once
Pulkit Goyal <7895pulkit@gmail.com>
parents:
35611
diff
changeset
|
882 |
hiddenrev = None |
fc39e2bfcd70
bookmarks: calculate visibility exceptions only once
Pulkit Goyal <7895pulkit@gmail.com>
parents:
35611
diff
changeset
|
883 |
|
fc39e2bfcd70
bookmarks: calculate visibility exceptions only once
Pulkit Goyal <7895pulkit@gmail.com>
parents:
35611
diff
changeset
|
884 |
# unhide revs if any |
fc39e2bfcd70
bookmarks: calculate visibility exceptions only once
Pulkit Goyal <7895pulkit@gmail.com>
parents:
35611
diff
changeset
|
885 |
if rev: |
fc39e2bfcd70
bookmarks: calculate visibility exceptions only once
Pulkit Goyal <7895pulkit@gmail.com>
parents:
35611
diff
changeset
|
886 |
repo = scmutil.unhidehashlikerevs(repo, [rev], 'nowarn') |
fc39e2bfcd70
bookmarks: calculate visibility exceptions only once
Pulkit Goyal <7895pulkit@gmail.com>
parents:
35611
diff
changeset
|
887 |
|
33007
ee081f91b179
bookmarks: factor out adding a list of bookmarks logic from commands
Sean Farley <sean@farley.io>
parents:
33006
diff
changeset
|
888 |
for mark in names: |
ee081f91b179
bookmarks: factor out adding a list of bookmarks logic from commands
Sean Farley <sean@farley.io>
parents:
33006
diff
changeset
|
889 |
mark = checkformat(repo, mark) |
ee081f91b179
bookmarks: factor out adding a list of bookmarks logic from commands
Sean Farley <sean@farley.io>
parents:
33006
diff
changeset
|
890 |
if newact is None: |
ee081f91b179
bookmarks: factor out adding a list of bookmarks logic from commands
Sean Farley <sean@farley.io>
parents:
33006
diff
changeset
|
891 |
newact = mark |
ee081f91b179
bookmarks: factor out adding a list of bookmarks logic from commands
Sean Farley <sean@farley.io>
parents:
33006
diff
changeset
|
892 |
if inactive and mark == repo._activebookmark: |
ee081f91b179
bookmarks: factor out adding a list of bookmarks logic from commands
Sean Farley <sean@farley.io>
parents:
33006
diff
changeset
|
893 |
deactivate(repo) |
ee081f91b179
bookmarks: factor out adding a list of bookmarks logic from commands
Sean Farley <sean@farley.io>
parents:
33006
diff
changeset
|
894 |
return |
ee081f91b179
bookmarks: factor out adding a list of bookmarks logic from commands
Sean Farley <sean@farley.io>
parents:
33006
diff
changeset
|
895 |
tgt = cur |
ee081f91b179
bookmarks: factor out adding a list of bookmarks logic from commands
Sean Farley <sean@farley.io>
parents:
33006
diff
changeset
|
896 |
if rev: |
35611
7336ac5e786e
bookmarks: add bookmarks to hidden revs if directaccess config is set
Pulkit Goyal <7895pulkit@gmail.com>
parents:
35577
diff
changeset
|
897 |
ctx = scmutil.revsingle(repo, rev) |
7336ac5e786e
bookmarks: add bookmarks to hidden revs if directaccess config is set
Pulkit Goyal <7895pulkit@gmail.com>
parents:
35577
diff
changeset
|
898 |
if ctx.hidden(): |
35647
fc39e2bfcd70
bookmarks: calculate visibility exceptions only once
Pulkit Goyal <7895pulkit@gmail.com>
parents:
35611
diff
changeset
|
899 |
hiddenrev = ctx.hex()[:12] |
35611
7336ac5e786e
bookmarks: add bookmarks to hidden revs if directaccess config is set
Pulkit Goyal <7895pulkit@gmail.com>
parents:
35577
diff
changeset
|
900 |
tgt = ctx.node() |
33513
904894edb205
bookmark: use 'divergent2delete' in checkconflict
Boris Feld <boris.feld@octobus.net>
parents:
33512
diff
changeset
|
901 |
for bm in marks.checkconflict(mark, force, tgt): |
904894edb205
bookmark: use 'divergent2delete' in checkconflict
Boris Feld <boris.feld@octobus.net>
parents:
33512
diff
changeset
|
902 |
changes.append((bm, None)) |
33483
146c0371eadf
bookmark: use 'applychanges' for adding new bookmark
Boris Feld <boris.feld@octobus.net>
parents:
33482
diff
changeset
|
903 |
changes.append((mark, tgt)) |
35647
fc39e2bfcd70
bookmarks: calculate visibility exceptions only once
Pulkit Goyal <7895pulkit@gmail.com>
parents:
35611
diff
changeset
|
904 |
|
fc39e2bfcd70
bookmarks: calculate visibility exceptions only once
Pulkit Goyal <7895pulkit@gmail.com>
parents:
35611
diff
changeset
|
905 |
if hiddenrev: |
fc39e2bfcd70
bookmarks: calculate visibility exceptions only once
Pulkit Goyal <7895pulkit@gmail.com>
parents:
35611
diff
changeset
|
906 |
repo.ui.warn(_("bookmarking hidden changeset %s\n") % hiddenrev) |
35712
a1a5c3842b6f
bookmarks: display the obsfate of hidden revision we create a bookmark on
Boris Feld <boris.feld@octobus.net>
parents:
35679
diff
changeset
|
907 |
|
a1a5c3842b6f
bookmarks: display the obsfate of hidden revision we create a bookmark on
Boris Feld <boris.feld@octobus.net>
parents:
35679
diff
changeset
|
908 |
if ctx.obsolete(): |
a1a5c3842b6f
bookmarks: display the obsfate of hidden revision we create a bookmark on
Boris Feld <boris.feld@octobus.net>
parents:
35679
diff
changeset
|
909 |
msg = obsutil._getfilteredreason(repo, "%s" % hiddenrev, ctx) |
a1a5c3842b6f
bookmarks: display the obsfate of hidden revision we create a bookmark on
Boris Feld <boris.feld@octobus.net>
parents:
35679
diff
changeset
|
910 |
repo.ui.warn("(%s)\n" % msg) |
a1a5c3842b6f
bookmarks: display the obsfate of hidden revision we create a bookmark on
Boris Feld <boris.feld@octobus.net>
parents:
35679
diff
changeset
|
911 |
|
33483
146c0371eadf
bookmark: use 'applychanges' for adding new bookmark
Boris Feld <boris.feld@octobus.net>
parents:
33482
diff
changeset
|
912 |
marks.applychanges(repo, tr, changes) |
33007
ee081f91b179
bookmarks: factor out adding a list of bookmarks logic from commands
Sean Farley <sean@farley.io>
parents:
33006
diff
changeset
|
913 |
if not inactive and cur == marks[newact] and not rev: |
ee081f91b179
bookmarks: factor out adding a list of bookmarks logic from commands
Sean Farley <sean@farley.io>
parents:
33006
diff
changeset
|
914 |
activate(repo, newact) |
ee081f91b179
bookmarks: factor out adding a list of bookmarks logic from commands
Sean Farley <sean@farley.io>
parents:
33006
diff
changeset
|
915 |
elif cur != tgt and newact == repo._activebookmark: |
ee081f91b179
bookmarks: factor out adding a list of bookmarks logic from commands
Sean Farley <sean@farley.io>
parents:
33006
diff
changeset
|
916 |
deactivate(repo) |
33010
f5f4c72de71a
bookmarks: factor out bookmark printing from commands
Sean Farley <sean@farley.io>
parents:
33009
diff
changeset
|
917 |
|
33011
8299eb9b08c7
bookmarks: factor method _printer out of for loop in printbookmarks
Sean Farley <sean@farley.io>
parents:
33010
diff
changeset
|
918 |
def _printbookmarks(ui, repo, bmarks, **opts): |
8299eb9b08c7
bookmarks: factor method _printer out of for loop in printbookmarks
Sean Farley <sean@farley.io>
parents:
33010
diff
changeset
|
919 |
"""private method to print bookmarks |
8299eb9b08c7
bookmarks: factor method _printer out of for loop in printbookmarks
Sean Farley <sean@farley.io>
parents:
33010
diff
changeset
|
920 |
|
8299eb9b08c7
bookmarks: factor method _printer out of for loop in printbookmarks
Sean Farley <sean@farley.io>
parents:
33010
diff
changeset
|
921 |
Provides a way for extensions to control how bookmarks are printed (e.g. |
8299eb9b08c7
bookmarks: factor method _printer out of for loop in printbookmarks
Sean Farley <sean@farley.io>
parents:
33010
diff
changeset
|
922 |
prepend or postpend names) |
8299eb9b08c7
bookmarks: factor method _printer out of for loop in printbookmarks
Sean Farley <sean@farley.io>
parents:
33010
diff
changeset
|
923 |
""" |
33092
d170f59f6f55
py3: fix kwargs handling for `hg bookmarks`
Pulkit Goyal <7895pulkit@gmail.com>
parents:
33011
diff
changeset
|
924 |
opts = pycompat.byteskwargs(opts) |
33011
8299eb9b08c7
bookmarks: factor method _printer out of for loop in printbookmarks
Sean Farley <sean@farley.io>
parents:
33010
diff
changeset
|
925 |
fm = ui.formatter('bookmarks', opts) |
38538
2f7104984857
bookmarks: add support for log-like template keywords and functions
Yuya Nishihara <yuya@tcha.org>
parents:
37850
diff
changeset
|
926 |
contexthint = fm.contexthint('bookmark rev node active') |
33011
8299eb9b08c7
bookmarks: factor method _printer out of for loop in printbookmarks
Sean Farley <sean@farley.io>
parents:
33010
diff
changeset
|
927 |
hexfn = fm.hexfunc |
8299eb9b08c7
bookmarks: factor method _printer out of for loop in printbookmarks
Sean Farley <sean@farley.io>
parents:
33010
diff
changeset
|
928 |
if len(bmarks) == 0 and fm.isplain(): |
8299eb9b08c7
bookmarks: factor method _printer out of for loop in printbookmarks
Sean Farley <sean@farley.io>
parents:
33010
diff
changeset
|
929 |
ui.status(_("no bookmarks set\n")) |
8299eb9b08c7
bookmarks: factor method _printer out of for loop in printbookmarks
Sean Farley <sean@farley.io>
parents:
33010
diff
changeset
|
930 |
for bmark, (n, prefix, label) in sorted(bmarks.iteritems()): |
8299eb9b08c7
bookmarks: factor method _printer out of for loop in printbookmarks
Sean Farley <sean@farley.io>
parents:
33010
diff
changeset
|
931 |
fm.startitem() |
38538
2f7104984857
bookmarks: add support for log-like template keywords and functions
Yuya Nishihara <yuya@tcha.org>
parents:
37850
diff
changeset
|
932 |
if 'ctx' in contexthint: |
2f7104984857
bookmarks: add support for log-like template keywords and functions
Yuya Nishihara <yuya@tcha.org>
parents:
37850
diff
changeset
|
933 |
fm.context(ctx=repo[n]) |
33011
8299eb9b08c7
bookmarks: factor method _printer out of for loop in printbookmarks
Sean Farley <sean@farley.io>
parents:
33010
diff
changeset
|
934 |
if not ui.quiet: |
8299eb9b08c7
bookmarks: factor method _printer out of for loop in printbookmarks
Sean Farley <sean@farley.io>
parents:
33010
diff
changeset
|
935 |
fm.plain(' %s ' % prefix, label=label) |
8299eb9b08c7
bookmarks: factor method _printer out of for loop in printbookmarks
Sean Farley <sean@farley.io>
parents:
33010
diff
changeset
|
936 |
fm.write('bookmark', '%s', bmark, label=label) |
8299eb9b08c7
bookmarks: factor method _printer out of for loop in printbookmarks
Sean Farley <sean@farley.io>
parents:
33010
diff
changeset
|
937 |
pad = " " * (25 - encoding.colwidth(bmark)) |
8299eb9b08c7
bookmarks: factor method _printer out of for loop in printbookmarks
Sean Farley <sean@farley.io>
parents:
33010
diff
changeset
|
938 |
fm.condwrite(not ui.quiet, 'rev node', pad + ' %d:%s', |
8299eb9b08c7
bookmarks: factor method _printer out of for loop in printbookmarks
Sean Farley <sean@farley.io>
parents:
33010
diff
changeset
|
939 |
repo.changelog.rev(n), hexfn(n), label=label) |
8299eb9b08c7
bookmarks: factor method _printer out of for loop in printbookmarks
Sean Farley <sean@farley.io>
parents:
33010
diff
changeset
|
940 |
fm.data(active=(activebookmarklabel in label)) |
8299eb9b08c7
bookmarks: factor method _printer out of for loop in printbookmarks
Sean Farley <sean@farley.io>
parents:
33010
diff
changeset
|
941 |
fm.plain('\n') |
8299eb9b08c7
bookmarks: factor method _printer out of for loop in printbookmarks
Sean Farley <sean@farley.io>
parents:
33010
diff
changeset
|
942 |
fm.end() |
8299eb9b08c7
bookmarks: factor method _printer out of for loop in printbookmarks
Sean Farley <sean@farley.io>
parents:
33010
diff
changeset
|
943 |
|
33010
f5f4c72de71a
bookmarks: factor out bookmark printing from commands
Sean Farley <sean@farley.io>
parents:
33009
diff
changeset
|
944 |
def printbookmarks(ui, repo, **opts): |
f5f4c72de71a
bookmarks: factor out bookmark printing from commands
Sean Farley <sean@farley.io>
parents:
33009
diff
changeset
|
945 |
"""print bookmarks to a formatter |
f5f4c72de71a
bookmarks: factor out bookmark printing from commands
Sean Farley <sean@farley.io>
parents:
33009
diff
changeset
|
946 |
|
f5f4c72de71a
bookmarks: factor out bookmark printing from commands
Sean Farley <sean@farley.io>
parents:
33009
diff
changeset
|
947 |
Provides a way for extensions to control how bookmarks are printed. |
f5f4c72de71a
bookmarks: factor out bookmark printing from commands
Sean Farley <sean@farley.io>
parents:
33009
diff
changeset
|
948 |
""" |
f5f4c72de71a
bookmarks: factor out bookmark printing from commands
Sean Farley <sean@farley.io>
parents:
33009
diff
changeset
|
949 |
marks = repo._bookmarks |
33011
8299eb9b08c7
bookmarks: factor method _printer out of for loop in printbookmarks
Sean Farley <sean@farley.io>
parents:
33010
diff
changeset
|
950 |
bmarks = {} |
33010
f5f4c72de71a
bookmarks: factor out bookmark printing from commands
Sean Farley <sean@farley.io>
parents:
33009
diff
changeset
|
951 |
for bmark, n in sorted(marks.iteritems()): |
f5f4c72de71a
bookmarks: factor out bookmark printing from commands
Sean Farley <sean@farley.io>
parents:
33009
diff
changeset
|
952 |
active = repo._activebookmark |
f5f4c72de71a
bookmarks: factor out bookmark printing from commands
Sean Farley <sean@farley.io>
parents:
33009
diff
changeset
|
953 |
if bmark == active: |
f5f4c72de71a
bookmarks: factor out bookmark printing from commands
Sean Farley <sean@farley.io>
parents:
33009
diff
changeset
|
954 |
prefix, label = '*', activebookmarklabel |
f5f4c72de71a
bookmarks: factor out bookmark printing from commands
Sean Farley <sean@farley.io>
parents:
33009
diff
changeset
|
955 |
else: |
f5f4c72de71a
bookmarks: factor out bookmark printing from commands
Sean Farley <sean@farley.io>
parents:
33009
diff
changeset
|
956 |
prefix, label = ' ', '' |
f5f4c72de71a
bookmarks: factor out bookmark printing from commands
Sean Farley <sean@farley.io>
parents:
33009
diff
changeset
|
957 |
|
33011
8299eb9b08c7
bookmarks: factor method _printer out of for loop in printbookmarks
Sean Farley <sean@farley.io>
parents:
33010
diff
changeset
|
958 |
bmarks[bmark] = (n, prefix, label) |
8299eb9b08c7
bookmarks: factor method _printer out of for loop in printbookmarks
Sean Farley <sean@farley.io>
parents:
33010
diff
changeset
|
959 |
_printbookmarks(ui, repo, bmarks, **opts) |
34708
ee5f0d047b41
bookmark: add a dedicated txnclose-bookmark hook
Boris Feld <boris.feld@octobus.net>
parents:
33518
diff
changeset
|
960 |
|
ee5f0d047b41
bookmark: add a dedicated txnclose-bookmark hook
Boris Feld <boris.feld@octobus.net>
parents:
33518
diff
changeset
|
961 |
def preparehookargs(name, old, new): |
ee5f0d047b41
bookmark: add a dedicated txnclose-bookmark hook
Boris Feld <boris.feld@octobus.net>
parents:
33518
diff
changeset
|
962 |
if new is None: |
ee5f0d047b41
bookmark: add a dedicated txnclose-bookmark hook
Boris Feld <boris.feld@octobus.net>
parents:
33518
diff
changeset
|
963 |
new = '' |
ee5f0d047b41
bookmark: add a dedicated txnclose-bookmark hook
Boris Feld <boris.feld@octobus.net>
parents:
33518
diff
changeset
|
964 |
if old is None: |
ee5f0d047b41
bookmark: add a dedicated txnclose-bookmark hook
Boris Feld <boris.feld@octobus.net>
parents:
33518
diff
changeset
|
965 |
old = '' |
ee5f0d047b41
bookmark: add a dedicated txnclose-bookmark hook
Boris Feld <boris.feld@octobus.net>
parents:
33518
diff
changeset
|
966 |
return {'bookmark': name, |
ee5f0d047b41
bookmark: add a dedicated txnclose-bookmark hook
Boris Feld <boris.feld@octobus.net>
parents:
33518
diff
changeset
|
967 |
'node': hex(new), |
ee5f0d047b41
bookmark: add a dedicated txnclose-bookmark hook
Boris Feld <boris.feld@octobus.net>
parents:
33518
diff
changeset
|
968 |
'oldnode': hex(old)} |