Mercurial > public > mercurial-scm > hg
annotate mercurial/hg.py @ 813:80fd2958235a
Adapt commit to use file matching code.
The code is slightly complicated by the need to commit all outstanding
changes in the repository if no file names are given (other commands
operate on the current directory and its subdirectories in this case).
localrepository.changes has acquired an optional match parameter, to let
it filter out include/exclude options.
| author | Bryan O'Sullivan <bos@serpentine.com> |
|---|---|
| date | Fri, 29 Jul 2005 15:02:27 -0800 |
| parents | 902b12d55751 |
| children | 0902ffece4b4 |
| rev | line source |
|---|---|
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
1 # hg.py - repository classes for mercurial |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
2 # |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
3 # Copyright 2005 Matt Mackall <mpm@selenic.com> |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
4 # |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
5 # This software may be used and distributed according to the terms |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
6 # of the GNU General Public License, incorporated herein by reference. |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
7 |
| 249 | 8 import sys, struct, os |
|
419
28511fc21073
[PATCH] file seperator handling for the other 'OS'
mpm@selenic.com
parents:
418
diff
changeset
|
9 import util |
| 262 | 10 from revlog import * |
| 11 from demandload import * | |
| 12 demandload(globals(), "re lock urllib urllib2 transaction time socket") | |
| 765 | 13 demandload(globals(), "tempfile httprangereader bdiff urlparse") |
|
646
342927da4f4c
Show remote client output with "remote:"
Matt Mackall <mpm@selenic.com>
parents:
644
diff
changeset
|
14 demandload(globals(), "bisect select") |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
15 |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
16 class filelog(revlog): |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
17 def __init__(self, opener, path): |
|
144
ea9188538222
Fix transaction handling bug by reverting fileopener change
mpm@selenic.com
parents:
140
diff
changeset
|
18 revlog.__init__(self, opener, |
|
786
902b12d55751
Fix the directory and revlog collision problem
mpm@selenic.com
parents:
785
diff
changeset
|
19 os.path.join("data", self.encodedir(path + ".i")), |
|
902b12d55751
Fix the directory and revlog collision problem
mpm@selenic.com
parents:
785
diff
changeset
|
20 os.path.join("data", self.encodedir(path + ".d"))) |
|
902b12d55751
Fix the directory and revlog collision problem
mpm@selenic.com
parents:
785
diff
changeset
|
21 |
|
902b12d55751
Fix the directory and revlog collision problem
mpm@selenic.com
parents:
785
diff
changeset
|
22 # This avoids a collision between a file named foo and a dir named |
|
902b12d55751
Fix the directory and revlog collision problem
mpm@selenic.com
parents:
785
diff
changeset
|
23 # foo.i or foo.d |
|
902b12d55751
Fix the directory and revlog collision problem
mpm@selenic.com
parents:
785
diff
changeset
|
24 def encodedir(self, path): |
|
902b12d55751
Fix the directory and revlog collision problem
mpm@selenic.com
parents:
785
diff
changeset
|
25 path.replace(".hg/", ".hg.hg/") |
|
902b12d55751
Fix the directory and revlog collision problem
mpm@selenic.com
parents:
785
diff
changeset
|
26 path.replace(".i/", ".i.hg/") |
|
902b12d55751
Fix the directory and revlog collision problem
mpm@selenic.com
parents:
785
diff
changeset
|
27 path.replace(".d/", ".i.hg/") |
|
902b12d55751
Fix the directory and revlog collision problem
mpm@selenic.com
parents:
785
diff
changeset
|
28 return path |
|
902b12d55751
Fix the directory and revlog collision problem
mpm@selenic.com
parents:
785
diff
changeset
|
29 |
|
902b12d55751
Fix the directory and revlog collision problem
mpm@selenic.com
parents:
785
diff
changeset
|
30 def decodedir(self, path): |
|
902b12d55751
Fix the directory and revlog collision problem
mpm@selenic.com
parents:
785
diff
changeset
|
31 path.replace(".d.hg/", ".d/") |
|
902b12d55751
Fix the directory and revlog collision problem
mpm@selenic.com
parents:
785
diff
changeset
|
32 path.replace(".i.hg/", ".i/") |
|
902b12d55751
Fix the directory and revlog collision problem
mpm@selenic.com
parents:
785
diff
changeset
|
33 path.replace(".hg.hg/", ".hg/") |
|
902b12d55751
Fix the directory and revlog collision problem
mpm@selenic.com
parents:
785
diff
changeset
|
34 return path |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
35 |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
36 def read(self, node): |
| 360 | 37 t = self.revision(node) |
|
686
d7d68d27ebe5
Reapply startswith() changes that got lost with stale edit
Matt Mackall <mpm@selenic.com>
parents:
681
diff
changeset
|
38 if not t.startswith('\1\n'): |
| 360 | 39 return t |
| 40 s = t.find('\1\n', 2) | |
| 41 return t[s+2:] | |
| 42 | |
| 43 def readmeta(self, node): | |
| 44 t = self.revision(node) | |
|
686
d7d68d27ebe5
Reapply startswith() changes that got lost with stale edit
Matt Mackall <mpm@selenic.com>
parents:
681
diff
changeset
|
45 if not t.startswith('\1\n'): |
| 360 | 46 return t |
| 47 s = t.find('\1\n', 2) | |
| 48 mt = t[2:s] | |
| 49 for l in mt.splitlines(): | |
| 50 k, v = l.split(": ", 1) | |
| 51 m[k] = v | |
| 52 return m | |
| 53 | |
| 54 def add(self, text, meta, transaction, link, p1=None, p2=None): | |
|
686
d7d68d27ebe5
Reapply startswith() changes that got lost with stale edit
Matt Mackall <mpm@selenic.com>
parents:
681
diff
changeset
|
55 if meta or text.startswith('\1\n'): |
| 360 | 56 mt = "" |
| 57 if meta: | |
| 58 mt = [ "%s: %s\n" % (k, v) for k,v in meta.items() ] | |
| 59 text = "\1\n" + "".join(mt) + "\1\n" + text | |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
60 return self.addrevision(text, transaction, link, p1, p2) |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
61 |
| 79 | 62 def annotate(self, node): |
| 199 | 63 |
| 64 def decorate(text, rev): | |
| 436 | 65 return ([rev] * len(text.splitlines()), text) |
| 199 | 66 |
| 67 def pair(parent, child): | |
| 436 | 68 for a1, a2, b1, b2 in bdiff.blocks(parent[1], child[1]): |
| 471 | 69 child[0][b1:b2] = parent[0][a1:a2] |
| 70 return child | |
| 199 | 71 |
| 200 | 72 # find all ancestors |
|
216
201115f2859b
hg annotate: actually annotate the given version
mpm@selenic.com
parents:
210
diff
changeset
|
73 needed = {node:1} |
| 199 | 74 visit = [node] |
| 75 while visit: | |
| 76 n = visit.pop(0) | |
| 77 for p in self.parents(n): | |
| 78 if p not in needed: | |
| 79 needed[p] = 1 | |
| 80 visit.append(p) | |
| 200 | 81 else: |
| 82 # count how many times we'll use this | |
| 83 needed[p] += 1 | |
| 199 | 84 |
| 200 | 85 # sort by revision which is a topological order |
| 471 | 86 visit = [ (self.rev(n), n) for n in needed.keys() ] |
| 199 | 87 visit.sort() |
| 88 hist = {} | |
| 89 | |
| 471 | 90 for r,n in visit: |
| 199 | 91 curr = decorate(self.read(n), self.linkrev(n)) |
| 92 for p in self.parents(n): | |
| 93 if p != nullid: | |
| 94 curr = pair(hist[p], curr) | |
| 200 | 95 # trim the history of unneeded revs |
| 96 needed[p] -= 1 | |
| 97 if not needed[p]: | |
| 98 del hist[p] | |
| 199 | 99 hist[n] = curr |
| 100 | |
| 436 | 101 return zip(hist[n][0], hist[n][1].splitlines(1)) |
| 79 | 102 |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
103 class manifest(revlog): |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
104 def __init__(self, opener): |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
105 self.mapcache = None |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
106 self.listcache = None |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
107 self.addlist = None |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
108 revlog.__init__(self, opener, "00manifest.i", "00manifest.d") |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
109 |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
110 def read(self, node): |
| 313 | 111 if node == nullid: return {} # don't upset local cache |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
112 if self.mapcache and self.mapcache[0] == node: |
| 561 | 113 return self.mapcache[1] |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
114 text = self.revision(node) |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
115 map = {} |
| 276 | 116 flag = {} |
|
25
daa724b27300
Fix corruption from manifest.listcache optimization
mpm@selenic.com
parents:
20
diff
changeset
|
117 self.listcache = (text, text.splitlines(1)) |
|
daa724b27300
Fix corruption from manifest.listcache optimization
mpm@selenic.com
parents:
20
diff
changeset
|
118 for l in self.listcache[1]: |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
119 (f, n) = l.split('\0') |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
120 map[f] = bin(n[:40]) |
| 276 | 121 flag[f] = (n[40:-1] == "x") |
| 122 self.mapcache = (node, map, flag) | |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
123 return map |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
124 |
| 276 | 125 def readflags(self, node): |
| 313 | 126 if node == nullid: return {} # don't upset local cache |
|
358
9f4077d7ef6f
[PATCH] manifest.readflags performance buglet
mpm@selenic.com
parents:
350
diff
changeset
|
127 if not self.mapcache or self.mapcache[0] != node: |
| 276 | 128 self.read(node) |
| 129 return self.mapcache[2] | |
| 130 | |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
131 def diff(self, a, b): |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
132 # this is sneaky, as we're not actually using a and b |
| 140 | 133 if self.listcache and self.addlist and self.listcache[0] == a: |
| 98 | 134 d = mdiff.diff(self.listcache[1], self.addlist, 1) |
| 135 if mdiff.patch(a, d) != b: | |
| 136 sys.stderr.write("*** sortdiff failed, falling back ***\n") | |
| 137 return mdiff.textdiff(a, b) | |
| 138 return d | |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
139 else: |
| 44 | 140 return mdiff.textdiff(a, b) |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
141 |
| 741 | 142 def add(self, map, flags, transaction, link, p1=None, p2=None, |
| 143 changed=None): | |
| 644 | 144 # directly generate the mdiff delta from the data collected during |
| 145 # the bisect loop below | |
| 146 def gendelta(delta): | |
| 147 i = 0 | |
| 148 result = [] | |
| 149 while i < len(delta): | |
| 150 start = delta[i][2] | |
| 151 end = delta[i][3] | |
| 152 l = delta[i][4] | |
| 153 if l == None: | |
| 154 l = "" | |
| 741 | 155 while i < len(delta) - 1 and start <= delta[i+1][2] \ |
| 156 and end >= delta[i+1][2]: | |
| 644 | 157 if delta[i+1][3] > end: |
| 158 end = delta[i+1][3] | |
| 159 if delta[i+1][4]: | |
| 160 l += delta[i+1][4] | |
| 161 i += 1 | |
| 162 result.append(struct.pack(">lll", start, end, len(l)) + l) | |
| 163 i += 1 | |
| 164 return result | |
| 165 | |
| 166 # apply the changes collected during the bisect loop to our addlist | |
| 167 def addlistdelta(addlist, delta): | |
| 168 # apply the deltas to the addlist. start from the bottom up | |
| 169 # so changes to the offsets don't mess things up. | |
| 170 i = len(delta) | |
| 171 while i > 0: | |
| 172 i -= 1 | |
| 173 start = delta[i][0] | |
| 174 end = delta[i][1] | |
| 175 if delta[i][4]: | |
| 176 addlist[start:end] = [delta[i][4]] | |
| 177 else: | |
| 178 del addlist[start:end] | |
| 179 return addlist | |
| 180 | |
| 181 # calculate the byte offset of the start of each line in the | |
| 182 # manifest | |
| 183 def calcoffsets(addlist): | |
| 184 offsets = [0] * (len(addlist) + 1) | |
| 185 offset = 0 | |
| 186 i = 0 | |
| 187 while i < len(addlist): | |
| 188 offsets[i] = offset | |
| 189 offset += len(addlist[i]) | |
| 190 i += 1 | |
| 191 offsets[i] = offset | |
| 192 return offsets | |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
193 |
| 644 | 194 # if we're using the listcache, make sure it is valid and |
| 195 # parented by the same node we're diffing against | |
| 741 | 196 if not changed or not self.listcache or not p1 or \ |
| 197 self.mapcache[0] != p1: | |
| 644 | 198 files = map.keys() |
| 199 files.sort() | |
| 200 | |
| 201 self.addlist = ["%s\000%s%s\n" % | |
| 202 (f, hex(map[f]), flags[f] and "x" or '') | |
| 203 for f in files] | |
| 204 cachedelta = None | |
| 205 else: | |
| 206 addlist = self.listcache[1] | |
| 207 | |
| 208 # find the starting offset for each line in the add list | |
| 209 offsets = calcoffsets(addlist) | |
| 210 | |
| 211 # combine the changed lists into one list for sorting | |
| 212 work = [[x, 0] for x in changed[0]] | |
| 213 work[len(work):] = [[x, 1] for x in changed[1]] | |
| 214 work.sort() | |
| 215 | |
| 216 delta = [] | |
| 217 bs = 0 | |
| 218 | |
| 219 for w in work: | |
| 220 f = w[0] | |
| 741 | 221 # bs will either be the index of the item or the insert point |
| 644 | 222 bs = bisect.bisect(addlist, f, bs) |
| 223 if bs < len(addlist): | |
| 224 fn = addlist[bs][:addlist[bs].index('\0')] | |
| 225 else: | |
| 226 fn = None | |
| 227 if w[1] == 0: | |
| 741 | 228 l = "%s\000%s%s\n" % (f, hex(map[f]), |
| 229 flags[f] and "x" or '') | |
| 644 | 230 else: |
| 231 l = None | |
| 232 start = bs | |
| 233 if fn != f: | |
| 234 # item not found, insert a new one | |
| 659 | 235 end = bs |
| 644 | 236 if w[1] == 1: |
|
713
7c385bd5f993
Added missing newline after two error messages.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
705
diff
changeset
|
237 sys.stderr.write("failed to remove %s from manifest\n" |
|
7c385bd5f993
Added missing newline after two error messages.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
705
diff
changeset
|
238 % f) |
| 644 | 239 sys.exit(1) |
| 240 else: | |
| 241 # item is found, replace/delete the existing line | |
| 242 end = bs + 1 | |
| 243 delta.append([start, end, offsets[start], offsets[end], l]) | |
| 244 | |
| 245 self.addlist = addlistdelta(addlist, delta) | |
| 246 if self.mapcache[0] == self.tip(): | |
| 247 cachedelta = "".join(gendelta(delta)) | |
| 248 else: | |
| 249 cachedelta = None | |
| 250 | |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
251 text = "".join(self.addlist) |
| 644 | 252 if cachedelta and mdiff.patch(self.listcache[0], cachedelta) != text: |
|
713
7c385bd5f993
Added missing newline after two error messages.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
705
diff
changeset
|
253 sys.stderr.write("manifest delta failure\n") |
| 644 | 254 sys.exit(1) |
| 255 n = self.addrevision(text, transaction, link, p1, p2, cachedelta) | |
| 302 | 256 self.mapcache = (n, map, flags) |
|
25
daa724b27300
Fix corruption from manifest.listcache optimization
mpm@selenic.com
parents:
20
diff
changeset
|
257 self.listcache = (text, self.addlist) |
| 140 | 258 self.addlist = None |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
259 |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
260 return n |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
261 |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
262 class changelog(revlog): |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
263 def __init__(self, opener): |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
264 revlog.__init__(self, opener, "00changelog.i", "00changelog.d") |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
265 |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
266 def extract(self, text): |
| 37 | 267 if not text: |
| 40 | 268 return (nullid, "", "0", [], "") |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
269 last = text.index("\n\n") |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
270 desc = text[last + 2:] |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
271 l = text[:last].splitlines() |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
272 manifest = bin(l[0]) |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
273 user = l[1] |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
274 date = l[2] |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
275 files = l[3:] |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
276 return (manifest, user, date, files, desc) |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
277 |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
278 def read(self, node): |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
279 return self.extract(self.revision(node)) |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
280 |
| 203 | 281 def add(self, manifest, list, desc, transaction, p1=None, p2=None, |
| 282 user=None, date=None): | |
| 283 date = date or "%d %d" % (time.time(), time.timezone) | |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
284 list.sort() |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
285 l = [hex(manifest), user, date] + list + ["", desc] |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
286 text = "\n".join(l) |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
287 return self.addrevision(text, transaction, self.count(), p1, p2) |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
288 |
| 220 | 289 class dirstate: |
| 244 | 290 def __init__(self, opener, ui, root): |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
291 self.opener = opener |
| 244 | 292 self.root = root |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
293 self.dirty = 0 |
| 20 | 294 self.ui = ui |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
295 self.map = None |
| 227 | 296 self.pl = None |
| 363 | 297 self.copies = {} |
| 723 | 298 self.ignorefunc = None |
| 299 | |
| 300 def wjoin(self, f): | |
| 301 return os.path.join(self.root, f) | |
| 302 | |
| 303 def ignore(self, f): | |
| 304 if not self.ignorefunc: | |
| 305 bigpat = [] | |
| 306 try: | |
| 307 l = file(self.wjoin(".hgignore")) | |
| 308 for pat in l: | |
| 309 if pat != "\n": | |
| 310 p = util.pconvert(pat[:-1]) | |
| 311 try: | |
| 312 r = re.compile(p) | |
| 313 except: | |
| 314 self.ui.warn("ignoring invalid ignore" | |
| 315 + " regular expression '%s'\n" % p) | |
| 316 else: | |
| 317 bigpat.append(util.pconvert(pat[:-1])) | |
| 318 except IOError: pass | |
| 319 | |
|
735
3433b228bbb3
An empty .hgignore file must cause us to ignore nothing, not everything!
Bryan O'Sullivan <bos@serpentine.com>
parents:
730
diff
changeset
|
320 if bigpat: |
|
3433b228bbb3
An empty .hgignore file must cause us to ignore nothing, not everything!
Bryan O'Sullivan <bos@serpentine.com>
parents:
730
diff
changeset
|
321 s = "(?:%s)" % (")|(?:".join(bigpat)) |
|
3433b228bbb3
An empty .hgignore file must cause us to ignore nothing, not everything!
Bryan O'Sullivan <bos@serpentine.com>
parents:
730
diff
changeset
|
322 r = re.compile(s) |
|
3433b228bbb3
An empty .hgignore file must cause us to ignore nothing, not everything!
Bryan O'Sullivan <bos@serpentine.com>
parents:
730
diff
changeset
|
323 self.ignorefunc = r.search |
|
3433b228bbb3
An empty .hgignore file must cause us to ignore nothing, not everything!
Bryan O'Sullivan <bos@serpentine.com>
parents:
730
diff
changeset
|
324 else: |
|
3433b228bbb3
An empty .hgignore file must cause us to ignore nothing, not everything!
Bryan O'Sullivan <bos@serpentine.com>
parents:
730
diff
changeset
|
325 self.ignorefunc = util.never |
| 723 | 326 |
| 327 return self.ignorefunc(f) | |
| 220 | 328 |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
329 def __del__(self): |
| 220 | 330 if self.dirty: |
| 331 self.write() | |
| 332 | |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
333 def __getitem__(self, key): |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
334 try: |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
335 return self.map[key] |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
336 except TypeError: |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
337 self.read() |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
338 return self[key] |
| 220 | 339 |
| 340 def __contains__(self, key): | |
| 341 if not self.map: self.read() | |
| 342 return key in self.map | |
| 343 | |
| 227 | 344 def parents(self): |
| 345 if not self.pl: | |
| 346 self.read() | |
| 347 return self.pl | |
| 348 | |
| 723 | 349 def markdirty(self): |
| 350 if not self.dirty: | |
| 351 self.dirty = 1 | |
| 352 | |
| 227 | 353 def setparents(self, p1, p2 = nullid): |
| 723 | 354 self.markdirty() |
| 227 | 355 self.pl = p1, p2 |
| 356 | |
| 220 | 357 def state(self, key): |
| 358 try: | |
| 359 return self[key][0] | |
| 360 except KeyError: | |
| 361 return "?" | |
| 362 | |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
363 def read(self): |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
364 if self.map is not None: return self.map |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
365 |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
366 self.map = {} |
| 227 | 367 self.pl = [nullid, nullid] |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
368 try: |
| 220 | 369 st = self.opener("dirstate").read() |
| 311 | 370 if not st: return |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
371 except: return |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
372 |
| 227 | 373 self.pl = [st[:20], st[20: 40]] |
| 374 | |
| 375 pos = 40 | |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
376 while pos < len(st): |
| 220 | 377 e = struct.unpack(">cllll", st[pos:pos+17]) |
| 378 l = e[4] | |
| 379 pos += 17 | |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
380 f = st[pos:pos + l] |
| 515 | 381 if '\0' in f: |
| 363 | 382 f, c = f.split('\0') |
| 383 self.copies[f] = c | |
| 220 | 384 self.map[f] = e[:4] |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
385 pos += l |
| 363 | 386 |
| 387 def copy(self, source, dest): | |
| 388 self.read() | |
| 723 | 389 self.markdirty() |
| 363 | 390 self.copies[dest] = source |
| 391 | |
| 392 def copied(self, file): | |
| 393 return self.copies.get(file, None) | |
| 515 | 394 |
| 220 | 395 def update(self, files, state): |
| 396 ''' current states: | |
| 397 n normal | |
| 231 | 398 m needs merging |
| 220 | 399 r marked for removal |
| 400 a marked for addition''' | |
| 401 | |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
402 if not files: return |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
403 self.read() |
| 723 | 404 self.markdirty() |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
405 for f in files: |
| 220 | 406 if state == "r": |
| 407 self.map[f] = ('r', 0, 0, 0) | |
| 408 else: | |
| 253 | 409 s = os.stat(os.path.join(self.root, f)) |
| 410 self.map[f] = (state, s.st_mode, s.st_size, s.st_mtime) | |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
411 |
| 220 | 412 def forget(self, files): |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
413 if not files: return |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
414 self.read() |
| 723 | 415 self.markdirty() |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
416 for f in files: |
| 20 | 417 try: |
| 418 del self.map[f] | |
| 419 except KeyError: | |
| 220 | 420 self.ui.warn("not in dirstate: %s!\n" % f) |
| 20 | 421 pass |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
422 |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
423 def clear(self): |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
424 self.map = {} |
| 723 | 425 self.markdirty() |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
426 |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
427 def write(self): |
| 220 | 428 st = self.opener("dirstate", "w") |
| 227 | 429 st.write("".join(self.pl)) |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
430 for f, e in self.map.items(): |
| 363 | 431 c = self.copied(f) |
| 432 if c: | |
| 433 f = f + "\0" + c | |
| 220 | 434 e = struct.pack(">cllll", e[0], e[1], e[2], e[3], len(f)) |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
435 st.write(e + f) |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
436 self.dirty = 0 |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
437 |
|
724
1c0c413cccdd
Get add and locate to use new repo and dirstate walk code.
Bryan O'Sullivan <bos@serpentine.com>
parents:
723
diff
changeset
|
438 def walk(self, files = None, match = util.always): |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
439 self.read() |
| 536 | 440 dc = self.map.copy() |
| 723 | 441 # walk all files by default |
| 536 | 442 if not files: files = [self.root] |
| 723 | 443 def traverse(): |
| 556 | 444 for f in util.unique(files): |
| 537 | 445 f = os.path.join(self.root, f) |
| 536 | 446 if os.path.isdir(f): |
| 447 for dir, subdirs, fl in os.walk(f): | |
| 448 d = dir[len(self.root) + 1:] | |
| 723 | 449 if d == '.hg': |
| 450 subdirs[:] = [] | |
| 451 continue | |
|
669
8aa2a282eda4
.hgignore speedups patch incorporating Matt's feedback.
mwilli2@localhost.localdomain
parents:
667
diff
changeset
|
452 for sd in subdirs: |
| 723 | 453 ds = os.path.join(d, sd +'/') |
| 454 if self.ignore(ds) or not match(ds): | |
|
669
8aa2a282eda4
.hgignore speedups patch incorporating Matt's feedback.
mwilli2@localhost.localdomain
parents:
667
diff
changeset
|
455 subdirs.remove(sd) |
| 536 | 456 for fn in fl: |
| 457 fn = util.pconvert(os.path.join(d, fn)) | |
|
726
809a870a0e73
Add a source designator to the walk methods.
Bryan O'Sullivan <bos@serpentine.com>
parents:
725
diff
changeset
|
458 yield 'f', fn |
| 536 | 459 else: |
|
726
809a870a0e73
Add a source designator to the walk methods.
Bryan O'Sullivan <bos@serpentine.com>
parents:
725
diff
changeset
|
460 yield 'f', f[len(self.root) + 1:] |
| 536 | 461 |
|
669
8aa2a282eda4
.hgignore speedups patch incorporating Matt's feedback.
mwilli2@localhost.localdomain
parents:
667
diff
changeset
|
462 for k in dc.keys(): |
|
726
809a870a0e73
Add a source designator to the walk methods.
Bryan O'Sullivan <bos@serpentine.com>
parents:
725
diff
changeset
|
463 yield 'm', k |
|
669
8aa2a282eda4
.hgignore speedups patch incorporating Matt's feedback.
mwilli2@localhost.localdomain
parents:
667
diff
changeset
|
464 |
| 723 | 465 # yield only files that match: all in dirstate, others only if |
| 466 # not in .hgignore | |
|
669
8aa2a282eda4
.hgignore speedups patch incorporating Matt's feedback.
mwilli2@localhost.localdomain
parents:
667
diff
changeset
|
467 |
|
726
809a870a0e73
Add a source designator to the walk methods.
Bryan O'Sullivan <bos@serpentine.com>
parents:
725
diff
changeset
|
468 for src, fn in util.unique(traverse()): |
| 723 | 469 if fn in dc: |
| 470 del dc[fn] | |
| 471 elif self.ignore(fn): | |
| 472 continue | |
| 473 if match(fn): | |
|
726
809a870a0e73
Add a source designator to the walk methods.
Bryan O'Sullivan <bos@serpentine.com>
parents:
725
diff
changeset
|
474 yield src, fn |
| 723 | 475 |
|
724
1c0c413cccdd
Get add and locate to use new repo and dirstate walk code.
Bryan O'Sullivan <bos@serpentine.com>
parents:
723
diff
changeset
|
476 def changes(self, files = None, match = util.always): |
| 723 | 477 self.read() |
| 478 dc = self.map.copy() | |
| 479 lookup, changed, added, unknown = [], [], [], [] | |
| 480 | |
|
726
809a870a0e73
Add a source designator to the walk methods.
Bryan O'Sullivan <bos@serpentine.com>
parents:
725
diff
changeset
|
481 for src, fn in self.walk(files, match): |
| 536 | 482 try: s = os.stat(os.path.join(self.root, fn)) |
| 483 except: continue | |
| 484 | |
| 485 if fn in dc: | |
| 486 c = dc[fn] | |
| 487 del dc[fn] | |
| 488 | |
| 489 if c[0] == 'm': | |
| 490 changed.append(fn) | |
| 491 elif c[0] == 'a': | |
| 492 added.append(fn) | |
| 493 elif c[0] == 'r': | |
| 494 unknown.append(fn) | |
| 495 elif c[2] != s.st_size or (c[1] ^ s.st_mode) & 0100: | |
| 496 changed.append(fn) | |
| 497 elif c[1] != s.st_mode or c[3] != s.st_mtime: | |
| 498 lookup.append(fn) | |
| 499 else: | |
| 723 | 500 if match(fn): unknown.append(fn) |
| 536 | 501 |
|
730
d2dc7663d512
Only walk over files that match our criteria.
Bryan O'Sullivan <bos@serpentine.com>
parents:
726
diff
changeset
|
502 return (lookup, changed, added, filter(match, dc.keys()), unknown) |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
503 |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
504 # used to avoid circular references so destructors work |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
505 def opener(base): |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
506 p = base |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
507 def o(path, mode="r"): |
|
686
d7d68d27ebe5
Reapply startswith() changes that got lost with stale edit
Matt Mackall <mpm@selenic.com>
parents:
681
diff
changeset
|
508 if p.startswith("http://"): |
|
15
6daf7757e92b
Fix network pull of repo files with "%" in their base64 encoding.
mpm@selenic.com
parents:
10
diff
changeset
|
509 f = os.path.join(p, urllib.quote(path)) |
| 372 | 510 return httprangereader.httprangereader(f) |
|
15
6daf7757e92b
Fix network pull of repo files with "%" in their base64 encoding.
mpm@selenic.com
parents:
10
diff
changeset
|
511 |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
512 f = os.path.join(p, path) |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
513 |
| 292 | 514 mode += "b" # for that other OS |
| 515 | |
| 516 if mode[0] != "r": | |
|
110
c37c7f784ee3
Move hg from storing files in data with base64 encoding to full
mpm@selenic.com
parents:
109
diff
changeset
|
517 try: |
|
c37c7f784ee3
Move hg from storing files in data with base64 encoding to full
mpm@selenic.com
parents:
109
diff
changeset
|
518 s = os.stat(f) |
|
c37c7f784ee3
Move hg from storing files in data with base64 encoding to full
mpm@selenic.com
parents:
109
diff
changeset
|
519 except OSError: |
|
c37c7f784ee3
Move hg from storing files in data with base64 encoding to full
mpm@selenic.com
parents:
109
diff
changeset
|
520 d = os.path.dirname(f) |
|
c37c7f784ee3
Move hg from storing files in data with base64 encoding to full
mpm@selenic.com
parents:
109
diff
changeset
|
521 if not os.path.isdir(d): |
|
c37c7f784ee3
Move hg from storing files in data with base64 encoding to full
mpm@selenic.com
parents:
109
diff
changeset
|
522 os.makedirs(d) |
|
c37c7f784ee3
Move hg from storing files in data with base64 encoding to full
mpm@selenic.com
parents:
109
diff
changeset
|
523 else: |
|
c37c7f784ee3
Move hg from storing files in data with base64 encoding to full
mpm@selenic.com
parents:
109
diff
changeset
|
524 if s.st_nlink > 1: |
| 417 | 525 file(f + ".tmp", "wb").write(file(f, "rb").read()) |
| 421 | 526 util.rename(f+".tmp", f) |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
527 |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
528 return file(f, mode) |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
529 |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
530 return o |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
531 |
| 499 | 532 class RepoError(Exception): pass |
| 533 | |
| 60 | 534 class localrepository: |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
535 def __init__(self, ui, path=None, create=0): |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
536 self.remote = 0 |
|
686
d7d68d27ebe5
Reapply startswith() changes that got lost with stale edit
Matt Mackall <mpm@selenic.com>
parents:
681
diff
changeset
|
537 if path and path.startswith("http://"): |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
538 self.remote = 1 |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
539 self.path = path |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
540 else: |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
541 if not path: |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
542 p = os.getcwd() |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
543 while not os.path.isdir(os.path.join(p, ".hg")): |
|
420
dbe86d465e09
[PATCH] Repo locator fix for the other `OS'
mpm@selenic.com
parents:
419
diff
changeset
|
544 oldp = p |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
545 p = os.path.dirname(p) |
| 499 | 546 if p == oldp: raise RepoError("no repo found") |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
547 path = p |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
548 self.path = os.path.join(path, ".hg") |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
549 |
| 405 | 550 if not create and not os.path.isdir(self.path): |
| 499 | 551 raise RepoError("repository %s not found" % self.path) |
| 405 | 552 |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
553 self.root = path |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
554 self.ui = ui |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
555 |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
556 if create: |
| 515 | 557 os.mkdir(self.path) |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
558 os.mkdir(self.join("data")) |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
559 |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
560 self.opener = opener(self.path) |
|
291
2c4f2be05587
Add wopener for opening files in the working directory
mpm@selenic.com
parents:
288
diff
changeset
|
561 self.wopener = opener(self.root) |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
562 self.manifest = manifest(self.opener) |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
563 self.changelog = changelog(self.opener) |
| 343 | 564 self.tagscache = None |
| 565 self.nodetagscache = None | |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
566 |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
567 if not self.remote: |
| 244 | 568 self.dirstate = dirstate(self.opener, ui, self.root) |
| 337 | 569 try: |
| 570 self.ui.readconfig(self.opener("hgrc")) | |
| 571 except IOError: pass | |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
572 |
| 487 | 573 def hook(self, name, **args): |
| 574 s = self.ui.config("hooks", name) | |
| 575 if s: | |
| 576 self.ui.note("running hook %s: %s\n" % (name, s)) | |
| 577 old = {} | |
| 578 for k, v in args.items(): | |
| 579 k = k.upper() | |
| 580 old[k] = os.environ.get(k, None) | |
| 581 os.environ[k] = v | |
| 582 | |
| 583 r = os.system(s) | |
| 584 | |
| 585 for k, v in old.items(): | |
| 586 if v != None: | |
| 587 os.environ[k] = v | |
| 588 else: | |
| 589 del os.environ[k] | |
| 590 | |
| 591 if r: | |
| 592 self.ui.warn("abort: %s hook failed with status %d!\n" % | |
| 593 (name, r)) | |
| 594 return False | |
| 595 return True | |
| 596 | |
| 343 | 597 def tags(self): |
| 598 '''return a mapping of tag to node''' | |
|
477
520540fd6b64
Handle errors in .hgtags or hgrc [tags] section more gracefully.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
471
diff
changeset
|
599 if not self.tagscache: |
| 343 | 600 self.tagscache = {} |
|
609
2acf1f5df2e6
[PATCH] hg tag: local tag support in file .hg/localtags
Matt Mackall <mpm@selenic.com>
parents:
608
diff
changeset
|
601 def addtag(self, k, n): |
|
2acf1f5df2e6
[PATCH] hg tag: local tag support in file .hg/localtags
Matt Mackall <mpm@selenic.com>
parents:
608
diff
changeset
|
602 try: |
|
2acf1f5df2e6
[PATCH] hg tag: local tag support in file .hg/localtags
Matt Mackall <mpm@selenic.com>
parents:
608
diff
changeset
|
603 bin_n = bin(n) |
|
2acf1f5df2e6
[PATCH] hg tag: local tag support in file .hg/localtags
Matt Mackall <mpm@selenic.com>
parents:
608
diff
changeset
|
604 except TypeError: |
|
2acf1f5df2e6
[PATCH] hg tag: local tag support in file .hg/localtags
Matt Mackall <mpm@selenic.com>
parents:
608
diff
changeset
|
605 bin_n = '' |
|
2acf1f5df2e6
[PATCH] hg tag: local tag support in file .hg/localtags
Matt Mackall <mpm@selenic.com>
parents:
608
diff
changeset
|
606 self.tagscache[k.strip()] = bin_n |
| 659 | 607 |
| 67 | 608 try: |
| 254 | 609 # read each head of the tags file, ending with the tip |
| 610 # and add each tag found to the map, with "newer" ones | |
| 611 # taking precedence | |
| 67 | 612 fl = self.file(".hgtags") |
| 254 | 613 h = fl.heads() |
| 614 h.reverse() | |
| 615 for r in h: | |
| 616 for l in fl.revision(r).splitlines(): | |
| 617 if l: | |
|
385
e9e1efd5291c
Fixed problems with extra spaces around tags in .hgtags
Thomas Arendsen Hein <thomas@intevation.de>
parents:
383
diff
changeset
|
618 n, k = l.split(" ", 1) |
|
609
2acf1f5df2e6
[PATCH] hg tag: local tag support in file .hg/localtags
Matt Mackall <mpm@selenic.com>
parents:
608
diff
changeset
|
619 addtag(self, k, n) |
|
477
520540fd6b64
Handle errors in .hgtags or hgrc [tags] section more gracefully.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
471
diff
changeset
|
620 except KeyError: |
|
520540fd6b64
Handle errors in .hgtags or hgrc [tags] section more gracefully.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
471
diff
changeset
|
621 pass |
| 659 | 622 |
|
609
2acf1f5df2e6
[PATCH] hg tag: local tag support in file .hg/localtags
Matt Mackall <mpm@selenic.com>
parents:
608
diff
changeset
|
623 try: |
|
2acf1f5df2e6
[PATCH] hg tag: local tag support in file .hg/localtags
Matt Mackall <mpm@selenic.com>
parents:
608
diff
changeset
|
624 f = self.opener("localtags") |
|
2acf1f5df2e6
[PATCH] hg tag: local tag support in file .hg/localtags
Matt Mackall <mpm@selenic.com>
parents:
608
diff
changeset
|
625 for l in f: |
|
2acf1f5df2e6
[PATCH] hg tag: local tag support in file .hg/localtags
Matt Mackall <mpm@selenic.com>
parents:
608
diff
changeset
|
626 n, k = l.split(" ", 1) |
|
2acf1f5df2e6
[PATCH] hg tag: local tag support in file .hg/localtags
Matt Mackall <mpm@selenic.com>
parents:
608
diff
changeset
|
627 addtag(self, k, n) |
|
2acf1f5df2e6
[PATCH] hg tag: local tag support in file .hg/localtags
Matt Mackall <mpm@selenic.com>
parents:
608
diff
changeset
|
628 except IOError: |
|
2acf1f5df2e6
[PATCH] hg tag: local tag support in file .hg/localtags
Matt Mackall <mpm@selenic.com>
parents:
608
diff
changeset
|
629 pass |
| 659 | 630 |
| 343 | 631 self.tagscache['tip'] = self.changelog.tip() |
| 659 | 632 |
| 343 | 633 return self.tagscache |
| 634 | |
| 635 def tagslist(self): | |
| 636 '''return a list of tags ordered by revision''' | |
| 637 l = [] | |
|
477
520540fd6b64
Handle errors in .hgtags or hgrc [tags] section more gracefully.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
471
diff
changeset
|
638 for t, n in self.tags().items(): |
| 343 | 639 try: |
| 640 r = self.changelog.rev(n) | |
| 641 except: | |
| 642 r = -2 # sort to the beginning of the list if unknown | |
| 643 l.append((r,t,n)) | |
| 644 l.sort() | |
| 645 return [(t,n) for r,t,n in l] | |
| 646 | |
| 647 def nodetags(self, node): | |
| 648 '''return the tags associated with a node''' | |
| 649 if not self.nodetagscache: | |
| 650 self.nodetagscache = {} | |
| 651 for t,n in self.tags().items(): | |
| 652 self.nodetagscache.setdefault(n,[]).append(t) | |
| 653 return self.nodetagscache.get(node, []) | |
| 654 | |
| 655 def lookup(self, key): | |
| 67 | 656 try: |
| 343 | 657 return self.tags()[key] |
| 67 | 658 except KeyError: |
|
658
f8098ae9f5b6
Generate a friendlier except for failed lookups
Matt Mackall <mpm@selenic.com>
parents:
657
diff
changeset
|
659 try: |
|
f8098ae9f5b6
Generate a friendlier except for failed lookups
Matt Mackall <mpm@selenic.com>
parents:
657
diff
changeset
|
660 return self.changelog.lookup(key) |
|
f8098ae9f5b6
Generate a friendlier except for failed lookups
Matt Mackall <mpm@selenic.com>
parents:
657
diff
changeset
|
661 except: |
|
f8098ae9f5b6
Generate a friendlier except for failed lookups
Matt Mackall <mpm@selenic.com>
parents:
657
diff
changeset
|
662 raise RepoError("unknown revision '%s'" % key) |
| 67 | 663 |
|
634
da5378d39269
Add a repo method to report repo device
Matt Mackall <mpm@selenic.com>
parents:
627
diff
changeset
|
664 def dev(self): |
|
da5378d39269
Add a repo method to report repo device
Matt Mackall <mpm@selenic.com>
parents:
627
diff
changeset
|
665 if self.remote: return -1 |
|
da5378d39269
Add a repo method to report repo device
Matt Mackall <mpm@selenic.com>
parents:
627
diff
changeset
|
666 return os.stat(self.path).st_dev |
|
da5378d39269
Add a repo method to report repo device
Matt Mackall <mpm@selenic.com>
parents:
627
diff
changeset
|
667 |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
668 def join(self, f): |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
669 return os.path.join(self.path, f) |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
670 |
| 244 | 671 def wjoin(self, f): |
| 672 return os.path.join(self.root, f) | |
| 673 | |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
674 def file(self, f): |
| 192 | 675 if f[0] == '/': f = f[1:] |
|
144
ea9188538222
Fix transaction handling bug by reverting fileopener change
mpm@selenic.com
parents:
140
diff
changeset
|
676 return filelog(self.opener, f) |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
677 |
| 627 | 678 def getcwd(self): |
| 679 cwd = os.getcwd() | |
| 680 if cwd == self.root: return '' | |
| 681 return cwd[len(self.root) + 1:] | |
| 682 | |
|
291
2c4f2be05587
Add wopener for opening files in the working directory
mpm@selenic.com
parents:
288
diff
changeset
|
683 def wfile(self, f, mode='r'): |
|
2c4f2be05587
Add wopener for opening files in the working directory
mpm@selenic.com
parents:
288
diff
changeset
|
684 return self.wopener(f, mode) |
|
2c4f2be05587
Add wopener for opening files in the working directory
mpm@selenic.com
parents:
288
diff
changeset
|
685 |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
686 def transaction(self): |
| 251 | 687 # save dirstate for undo |
| 263 | 688 try: |
| 689 ds = self.opener("dirstate").read() | |
| 690 except IOError: | |
| 691 ds = "" | |
| 785 | 692 self.opener("journal.dirstate", "w").write(ds) |
| 515 | 693 |
| 785 | 694 def after(): |
| 695 util.rename(self.join("journal"), self.join("undo")) | |
| 696 util.rename(self.join("journal.dirstate"), | |
| 697 self.join("undo.dirstate")) | |
| 698 | |
| 699 return transaction.transaction(self.ui.warn, self.opener, | |
| 700 self.join("journal"), after) | |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
701 |
| 210 | 702 def recover(self): |
| 225 | 703 lock = self.lock() |
| 557 | 704 if os.path.exists(self.join("journal")): |
| 501 | 705 self.ui.status("rolling back interrupted transaction\n") |
| 557 | 706 return transaction.rollback(self.opener, self.join("journal")) |
| 210 | 707 else: |
| 708 self.ui.warn("no interrupted transaction available\n") | |
| 709 | |
| 710 def undo(self): | |
| 225 | 711 lock = self.lock() |
| 210 | 712 if os.path.exists(self.join("undo")): |
| 501 | 713 self.ui.status("rolling back last transaction\n") |
| 262 | 714 transaction.rollback(self.opener, self.join("undo")) |
| 251 | 715 self.dirstate = None |
| 421 | 716 util.rename(self.join("undo.dirstate"), self.join("dirstate")) |
| 251 | 717 self.dirstate = dirstate(self.opener, self.ui, self.root) |
| 163 | 718 else: |
| 210 | 719 self.ui.warn("no undo information available\n") |
| 162 | 720 |
| 161 | 721 def lock(self, wait = 1): |
| 722 try: | |
| 723 return lock.lock(self.join("lock"), 0) | |
| 724 except lock.LockHeld, inst: | |
| 725 if wait: | |
| 726 self.ui.warn("waiting for lock held by %s\n" % inst.args[0]) | |
| 727 return lock.lock(self.join("lock"), wait) | |
| 728 raise inst | |
| 729 | |
| 203 | 730 def rawcommit(self, files, text, user, date, p1=None, p2=None): |
| 442 | 731 orig_parent = self.dirstate.parents()[0] or nullid |
|
452
a1e91c24dab5
rawcommit: do lookup of parents at the appropriate layer
mpm@selenic.com
parents:
442
diff
changeset
|
732 p1 = p1 or self.dirstate.parents()[0] or nullid |
|
a1e91c24dab5
rawcommit: do lookup of parents at the appropriate layer
mpm@selenic.com
parents:
442
diff
changeset
|
733 p2 = p2 or self.dirstate.parents()[1] or nullid |
| 302 | 734 c1 = self.changelog.read(p1) |
| 735 c2 = self.changelog.read(p2) | |
| 736 m1 = self.manifest.read(c1[0]) | |
| 737 mf1 = self.manifest.readflags(c1[0]) | |
| 738 m2 = self.manifest.read(c2[0]) | |
| 739 | |
| 442 | 740 if orig_parent == p1: |
| 741 update_dirstate = 1 | |
| 742 else: | |
| 743 update_dirstate = 0 | |
| 744 | |
| 203 | 745 tr = self.transaction() |
| 302 | 746 mm = m1.copy() |
| 747 mfm = mf1.copy() | |
| 203 | 748 linkrev = self.changelog.count() |
| 749 for f in files: | |
| 750 try: | |
| 302 | 751 t = self.wfile(f).read() |
| 441 | 752 tm = util.is_exec(self.wjoin(f), mfm.get(f, False)) |
| 302 | 753 r = self.file(f) |
| 754 mfm[f] = tm | |
| 360 | 755 mm[f] = r.add(t, {}, tr, linkrev, |
| 302 | 756 m1.get(f, nullid), m2.get(f, nullid)) |
| 442 | 757 if update_dirstate: |
| 758 self.dirstate.update([f], "n") | |
| 203 | 759 except IOError: |
|
314
3402cb9a4c06
More tweaking to rawcommit for repo conversion
mpm@selenic.com
parents:
313
diff
changeset
|
760 try: |
|
3402cb9a4c06
More tweaking to rawcommit for repo conversion
mpm@selenic.com
parents:
313
diff
changeset
|
761 del mm[f] |
|
3402cb9a4c06
More tweaking to rawcommit for repo conversion
mpm@selenic.com
parents:
313
diff
changeset
|
762 del mfm[f] |
| 442 | 763 if update_dirstate: |
| 764 self.dirstate.forget([f]) | |
|
314
3402cb9a4c06
More tweaking to rawcommit for repo conversion
mpm@selenic.com
parents:
313
diff
changeset
|
765 except: |
|
3402cb9a4c06
More tweaking to rawcommit for repo conversion
mpm@selenic.com
parents:
313
diff
changeset
|
766 # deleted from p2? |
|
3402cb9a4c06
More tweaking to rawcommit for repo conversion
mpm@selenic.com
parents:
313
diff
changeset
|
767 pass |
| 203 | 768 |
| 302 | 769 mnode = self.manifest.add(mm, mfm, tr, linkrev, c1[0], c2[0]) |
|
608
d2994b5298fb
Add username/merge/editor to .hgrc
Matt Mackall <mpm@selenic.com>
parents:
588
diff
changeset
|
770 user = user or self.ui.username() |
| 302 | 771 n = self.changelog.add(mnode, files, text, tr, p1, p2, user, date) |
| 203 | 772 tr.close() |
| 442 | 773 if update_dirstate: |
| 774 self.dirstate.setparents(n, nullid) | |
| 203 | 775 |
|
813
80fd2958235a
Adapt commit to use file matching code.
Bryan O'Sullivan <bos@serpentine.com>
parents:
786
diff
changeset
|
776 def commit(self, files = None, text = "", user = None, date = None, |
|
80fd2958235a
Adapt commit to use file matching code.
Bryan O'Sullivan <bos@serpentine.com>
parents:
786
diff
changeset
|
777 match = util.always): |
| 220 | 778 commit = [] |
| 779 remove = [] | |
| 780 if files: | |
| 781 for f in files: | |
| 782 s = self.dirstate.state(f) | |
| 244 | 783 if s in 'nmai': |
| 220 | 784 commit.append(f) |
| 785 elif s == 'r': | |
| 786 remove.append(f) | |
| 787 else: | |
| 244 | 788 self.ui.warn("%s not tracked!\n" % f) |
| 220 | 789 else: |
|
813
80fd2958235a
Adapt commit to use file matching code.
Bryan O'Sullivan <bos@serpentine.com>
parents:
786
diff
changeset
|
790 (c, a, d, u) = self.changes(match = match) |
| 220 | 791 commit = c + a |
| 792 remove = d | |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
793 |
| 220 | 794 if not commit and not remove: |
| 151 | 795 self.ui.status("nothing changed\n") |
| 796 return | |
| 797 | |
| 487 | 798 if not self.hook("precommit"): |
| 799 return 1 | |
| 800 | |
| 229 | 801 p1, p2 = self.dirstate.parents() |
| 802 c1 = self.changelog.read(p1) | |
| 803 c2 = self.changelog.read(p2) | |
| 804 m1 = self.manifest.read(c1[0]) | |
| 276 | 805 mf1 = self.manifest.readflags(c1[0]) |
| 229 | 806 m2 = self.manifest.read(c2[0]) |
| 225 | 807 lock = self.lock() |
| 151 | 808 tr = self.transaction() |
| 809 | |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
810 # check in files |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
811 new = {} |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
812 linkrev = self.changelog.count() |
| 220 | 813 commit.sort() |
| 814 for f in commit: | |
| 83 | 815 self.ui.note(f + "\n") |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
816 try: |
| 441 | 817 mf1[f] = util.is_exec(self.wjoin(f), mf1.get(f, False)) |
| 418 | 818 t = self.wfile(f).read() |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
819 except IOError: |
|
667
31a9aa890016
A number of minor fixes to problems that pychecker found.
mark.williamson@cl.cam.ac.uk
parents:
660
diff
changeset
|
820 self.ui.warn("trouble committing %s!\n" % f) |
| 220 | 821 raise |
| 822 | |
| 363 | 823 meta = {} |
| 824 cp = self.dirstate.copied(f) | |
| 825 if cp: | |
| 826 meta["copy"] = cp | |
| 827 meta["copyrev"] = hex(m1.get(cp, m2.get(cp, nullid))) | |
| 575 | 828 self.ui.debug(" %s: copy %s:%s\n" % (f, cp, meta["copyrev"])) |
| 363 | 829 |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
830 r = self.file(f) |
| 229 | 831 fp1 = m1.get(f, nullid) |
| 832 fp2 = m2.get(f, nullid) | |
| 363 | 833 new[f] = r.add(t, meta, tr, linkrev, fp1, fp2) |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
834 |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
835 # update manifest |
| 229 | 836 m1.update(new) |
|
416
5e9e8b8d2629
[PATCH] Removal of a file added by merging branches
mpm@selenic.com
parents:
415
diff
changeset
|
837 for f in remove: |
|
5e9e8b8d2629
[PATCH] Removal of a file added by merging branches
mpm@selenic.com
parents:
415
diff
changeset
|
838 if f in m1: |
|
5e9e8b8d2629
[PATCH] Removal of a file added by merging branches
mpm@selenic.com
parents:
415
diff
changeset
|
839 del m1[f] |
| 741 | 840 mn = self.manifest.add(m1, mf1, tr, linkrev, c1[0], c2[0], |
| 841 (new, remove)) | |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
842 |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
843 # add changeset |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
844 new = new.keys() |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
845 new.sort() |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
846 |
| 288 | 847 if not text: |
| 848 edittext = "\n" + "HG: manifest hash %s\n" % hex(mn) | |
| 849 edittext += "".join(["HG: changed %s\n" % f for f in new]) | |
| 850 edittext += "".join(["HG: removed %s\n" % f for f in remove]) | |
| 851 edittext = self.ui.edit(edittext) | |
| 852 if not edittext.rstrip(): | |
| 853 return 1 | |
| 854 text = edittext | |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
855 |
|
608
d2994b5298fb
Add username/merge/editor to .hgrc
Matt Mackall <mpm@selenic.com>
parents:
588
diff
changeset
|
856 user = user or self.ui.username() |
| 317 | 857 n = self.changelog.add(mn, new, text, tr, p1, p2, user, date) |
| 487 | 858 |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
859 tr.close() |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
860 |
| 229 | 861 self.dirstate.setparents(n) |
| 220 | 862 self.dirstate.update(new, "n") |
| 863 self.dirstate.forget(remove) | |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
864 |
|
660
2c83350784c3
Move commit hook after commit completes
Matt Mackall <mpm@selenic.com>
parents:
659
diff
changeset
|
865 if not self.hook("commit", node=hex(n)): |
|
2c83350784c3
Move commit hook after commit completes
Matt Mackall <mpm@selenic.com>
parents:
659
diff
changeset
|
866 return 1 |
|
2c83350784c3
Move commit hook after commit completes
Matt Mackall <mpm@selenic.com>
parents:
659
diff
changeset
|
867 |
|
724
1c0c413cccdd
Get add and locate to use new repo and dirstate walk code.
Bryan O'Sullivan <bos@serpentine.com>
parents:
723
diff
changeset
|
868 def walk(self, node = None, files = [], match = util.always): |
|
1c0c413cccdd
Get add and locate to use new repo and dirstate walk code.
Bryan O'Sullivan <bos@serpentine.com>
parents:
723
diff
changeset
|
869 if node: |
|
726
809a870a0e73
Add a source designator to the walk methods.
Bryan O'Sullivan <bos@serpentine.com>
parents:
725
diff
changeset
|
870 for fn in self.manifest.read(self.changelog.read(node)[0]): |
|
809a870a0e73
Add a source designator to the walk methods.
Bryan O'Sullivan <bos@serpentine.com>
parents:
725
diff
changeset
|
871 yield 'm', fn |
|
724
1c0c413cccdd
Get add and locate to use new repo and dirstate walk code.
Bryan O'Sullivan <bos@serpentine.com>
parents:
723
diff
changeset
|
872 else: |
|
726
809a870a0e73
Add a source designator to the walk methods.
Bryan O'Sullivan <bos@serpentine.com>
parents:
725
diff
changeset
|
873 for src, fn in self.dirstate.walk(files, match): |
|
809a870a0e73
Add a source designator to the walk methods.
Bryan O'Sullivan <bos@serpentine.com>
parents:
725
diff
changeset
|
874 yield src, fn |
| 723 | 875 |
|
724
1c0c413cccdd
Get add and locate to use new repo and dirstate walk code.
Bryan O'Sullivan <bos@serpentine.com>
parents:
723
diff
changeset
|
876 def changes(self, node1 = None, node2 = None, files = [], |
|
1c0c413cccdd
Get add and locate to use new repo and dirstate walk code.
Bryan O'Sullivan <bos@serpentine.com>
parents:
723
diff
changeset
|
877 match = util.always): |
| 566 | 878 mf2, u = None, [] |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
879 |
| 536 | 880 def fcmp(fn, mf): |
|
291
2c4f2be05587
Add wopener for opening files in the working directory
mpm@selenic.com
parents:
288
diff
changeset
|
881 t1 = self.wfile(fn).read() |
| 29 | 882 t2 = self.file(fn).revision(mf[fn]) |
| 883 return cmp(t1, t2) | |
| 884 | |
| 723 | 885 def mfmatches(node): |
| 886 mf = dict(self.manifest.read(node)) | |
| 887 for fn in mf.keys(): | |
| 888 if not match(fn): | |
| 889 del mf[fn] | |
| 890 return mf | |
| 741 | 891 |
| 536 | 892 # are we comparing the working directory? |
| 561 | 893 if not node2: |
| 723 | 894 l, c, a, d, u = self.dirstate.changes(files, match) |
| 536 | 895 |
| 896 # are we comparing working dir against its parent? | |
| 561 | 897 if not node1: |
| 536 | 898 if l: |
| 899 # do a full compare of any files that might have changed | |
| 900 change = self.changelog.read(self.dirstate.parents()[0]) | |
| 723 | 901 mf2 = mfmatches(change[0]) |
| 548 | 902 for f in l: |
| 561 | 903 if fcmp(f, mf2): |
| 536 | 904 c.append(f) |
| 561 | 905 |
| 906 for l in c, a, d, u: | |
| 907 l.sort() | |
| 908 | |
| 536 | 909 return (c, a, d, u) |
| 515 | 910 |
| 536 | 911 # are we comparing working dir against non-tip? |
| 912 # generate a pseudo-manifest for the working dir | |
| 561 | 913 if not node2: |
| 914 if not mf2: | |
| 536 | 915 change = self.changelog.read(self.dirstate.parents()[0]) |
| 723 | 916 mf2 = mfmatches(change[0]) |
| 536 | 917 for f in a + c + l: |
| 561 | 918 mf2[f] = "" |
| 536 | 919 for f in d: |
| 561 | 920 if f in mf2: del mf2[f] |
| 536 | 921 else: |
| 561 | 922 change = self.changelog.read(node2) |
| 723 | 923 mf2 = mfmatches(change[0]) |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
924 |
| 566 | 925 # flush lists from dirstate before comparing manifests |
| 926 c, a = [], [] | |
| 927 | |
| 561 | 928 change = self.changelog.read(node1) |
| 723 | 929 mf1 = mfmatches(change[0]) |
| 32 | 930 |
| 931 for fn in mf2: | |
| 932 if mf1.has_key(fn): | |
| 933 if mf1[fn] != mf2[fn]: | |
| 561 | 934 if mf2[fn] != "" or fcmp(fn, mf1): |
| 536 | 935 c.append(fn) |
| 32 | 936 del mf1[fn] |
| 937 else: | |
| 536 | 938 a.append(fn) |
| 515 | 939 |
| 536 | 940 d = mf1.keys() |
| 561 | 941 |
| 942 for l in c, a, d, u: | |
| 943 l.sort() | |
| 515 | 944 |
| 536 | 945 return (c, a, d, u) |
| 32 | 946 |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
947 def add(self, list): |
| 220 | 948 for f in list: |
| 244 | 949 p = self.wjoin(f) |
|
611
48c3eb2bf844
* clean up error handling when user requests to use a non file object
shaleh@speakeasy.net
parents:
609
diff
changeset
|
950 if not os.path.exists(p): |
| 659 | 951 self.ui.warn("%s does not exist!\n" % f) |
|
611
48c3eb2bf844
* clean up error handling when user requests to use a non file object
shaleh@speakeasy.net
parents:
609
diff
changeset
|
952 elif not os.path.isfile(p): |
| 741 | 953 self.ui.warn("%s not added: only files supported currently\n" % f) |
|
724
1c0c413cccdd
Get add and locate to use new repo and dirstate walk code.
Bryan O'Sullivan <bos@serpentine.com>
parents:
723
diff
changeset
|
954 elif self.dirstate.state(f) in 'an': |
| 220 | 955 self.ui.warn("%s already tracked!\n" % f) |
| 956 else: | |
| 957 self.dirstate.update([f], "a") | |
| 958 | |
| 959 def forget(self, list): | |
| 960 for f in list: | |
| 961 if self.dirstate.state(f) not in 'ai': | |
| 962 self.ui.warn("%s not added!\n" % f) | |
| 963 else: | |
| 964 self.dirstate.forget([f]) | |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
965 |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
966 def remove(self, list): |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
967 for f in list: |
| 244 | 968 p = self.wjoin(f) |
|
611
48c3eb2bf844
* clean up error handling when user requests to use a non file object
shaleh@speakeasy.net
parents:
609
diff
changeset
|
969 if os.path.exists(p): |
| 220 | 970 self.ui.warn("%s still exists!\n" % f) |
| 402 | 971 elif self.dirstate.state(f) == 'a': |
| 972 self.ui.warn("%s never committed!\n" % f) | |
|
657
22bc6fb9aefc
dirstate.forget() takes a list
Matt Mackall <mpm@selenic.com>
parents:
656
diff
changeset
|
973 self.dirstate.forget([f]) |
| 220 | 974 elif f not in self.dirstate: |
| 975 self.ui.warn("%s not tracked!\n" % f) | |
| 976 else: | |
| 977 self.dirstate.update([f], "r") | |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
978 |
| 363 | 979 def copy(self, source, dest): |
| 980 p = self.wjoin(dest) | |
| 781 | 981 if not os.path.exists(p): |
| 363 | 982 self.ui.warn("%s does not exist!\n" % dest) |
| 781 | 983 elif not os.path.isfile(p): |
| 659 | 984 self.ui.warn("copy failed: %s is not a file\n" % dest) |
| 363 | 985 else: |
| 986 if self.dirstate.state(dest) == '?': | |
| 987 self.dirstate.update([dest], "a") | |
| 988 self.dirstate.copy(source, dest) | |
| 989 | |
| 222 | 990 def heads(self): |
| 991 return self.changelog.heads() | |
| 992 | |
|
56
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
993 def branches(self, nodes): |
|
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
994 if not nodes: nodes = [self.changelog.tip()] |
|
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
995 b = [] |
|
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
996 for n in nodes: |
|
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
997 t = n |
|
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
998 while n: |
|
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
999 p = self.changelog.parents(n) |
|
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
1000 if p[1] != nullid or p[0] == nullid: |
|
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
1001 b.append((t, n, p[0], p[1])) |
|
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
1002 break |
|
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
1003 n = p[0] |
|
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
1004 return b |
|
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
1005 |
|
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
1006 def between(self, pairs): |
|
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
1007 r = [] |
|
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
1008 |
|
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
1009 for top, bottom in pairs: |
|
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
1010 n, l, i = top, [], 0 |
|
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
1011 f = 1 |
|
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
1012 |
|
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
1013 while n != bottom: |
|
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
1014 p = self.changelog.parents(n)[0] |
|
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
1015 if i == f: |
| 575 | 1016 l.append(n) |
|
56
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
1017 f = f * 2 |
|
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
1018 n = p |
|
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
1019 i += 1 |
|
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
1020 |
|
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
1021 r.append(l) |
|
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
1022 |
|
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
1023 return r |
|
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
1024 |
|
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
1025 def newer(self, nodes): |
|
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
1026 m = {} |
|
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
1027 nl = [] |
| 94 | 1028 pm = {} |
|
56
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
1029 cl = self.changelog |
|
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
1030 t = l = cl.count() |
| 94 | 1031 |
| 1032 # find the lowest numbered node | |
|
56
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
1033 for n in nodes: |
|
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
1034 l = min(l, cl.rev(n)) |
| 94 | 1035 m[n] = 1 |
| 46 | 1036 |
|
56
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
1037 for i in xrange(l, t): |
|
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
1038 n = cl.node(i) |
| 94 | 1039 if n in m: # explicitly listed |
| 1040 pm[n] = 1 | |
| 1041 nl.append(n) | |
| 1042 continue | |
|
56
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
1043 for p in cl.parents(n): |
| 94 | 1044 if p in pm: # parent listed |
| 1045 pm[n] = 1 | |
|
56
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
1046 nl.append(n) |
| 94 | 1047 break |
|
56
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
1048 |
|
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
1049 return nl |
|
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
1050 |
|
621
004e811f7706
Add a function to calculate the outgoing changegroup
Matt Mackall <mpm@selenic.com>
parents:
616
diff
changeset
|
1051 def findincoming(self, remote, base={}): |
|
65
d40cc5aacc31
Fix up a bunch of bugs in the new merge code
mpm@selenic.com
parents:
64
diff
changeset
|
1052 m = self.changelog.nodemap |
|
56
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
1053 search = [] |
|
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
1054 fetch = [] |
|
148
c32286d0a665
Improve pruning of branches in outstanding changeset algorithm
mpm@selenic.com
parents:
146
diff
changeset
|
1055 seen = {} |
|
c32286d0a665
Improve pruning of branches in outstanding changeset algorithm
mpm@selenic.com
parents:
146
diff
changeset
|
1056 seenbranch = {} |
| 192 | 1057 |
|
636
ac0ec421e3a5
Move the empty changeset detection out of findincoming to pull
Matt Mackall <mpm@selenic.com>
parents:
635
diff
changeset
|
1058 # assume we're closer to the tip than the root |
|
579
ffeb2c3a1966
Actually warn on pulling from an unrelated repository
mpm@selenic.com
parents:
578
diff
changeset
|
1059 # and start by examining the heads |
| 222 | 1060 self.ui.status("searching for changes\n") |
| 1061 heads = remote.heads() | |
| 1062 unknown = [] | |
| 1063 for h in heads: | |
| 1064 if h not in m: | |
| 1065 unknown.append(h) | |
|
621
004e811f7706
Add a function to calculate the outgoing changegroup
Matt Mackall <mpm@selenic.com>
parents:
616
diff
changeset
|
1066 else: |
|
004e811f7706
Add a function to calculate the outgoing changegroup
Matt Mackall <mpm@selenic.com>
parents:
616
diff
changeset
|
1067 base[h] = 1 |
| 46 | 1068 |
| 222 | 1069 if not unknown: |
| 60 | 1070 return None |
| 324 | 1071 |
| 1072 rep = {} | |
| 1073 reqcnt = 0 | |
| 515 | 1074 |
|
579
ffeb2c3a1966
Actually warn on pulling from an unrelated repository
mpm@selenic.com
parents:
578
diff
changeset
|
1075 # search through remote branches |
|
ffeb2c3a1966
Actually warn on pulling from an unrelated repository
mpm@selenic.com
parents:
578
diff
changeset
|
1076 # a 'branch' here is a linear segment of history, with four parts: |
|
ffeb2c3a1966
Actually warn on pulling from an unrelated repository
mpm@selenic.com
parents:
578
diff
changeset
|
1077 # head, root, first parent, second parent |
|
ffeb2c3a1966
Actually warn on pulling from an unrelated repository
mpm@selenic.com
parents:
578
diff
changeset
|
1078 # (a branch always has two parents (or none) by definition) |
| 222 | 1079 unknown = remote.branches(unknown) |
|
56
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
1080 while unknown: |
| 324 | 1081 r = [] |
| 1082 while unknown: | |
| 1083 n = unknown.pop(0) | |
| 1084 if n[0] in seen: | |
| 1085 continue | |
|
148
c32286d0a665
Improve pruning of branches in outstanding changeset algorithm
mpm@selenic.com
parents:
146
diff
changeset
|
1086 |
| 324 | 1087 self.ui.debug("examining %s:%s\n" % (short(n[0]), short(n[1]))) |
| 1088 if n[0] == nullid: | |
| 1089 break | |
| 328 | 1090 if n in seenbranch: |
| 324 | 1091 self.ui.debug("branch already found\n") |
| 1092 continue | |
| 1093 if n[1] and n[1] in m: # do we know the base? | |
| 1094 self.ui.debug("found incomplete branch %s:%s\n" | |
| 1095 % (short(n[0]), short(n[1]))) | |
| 1096 search.append(n) # schedule branch range for scanning | |
| 328 | 1097 seenbranch[n] = 1 |
| 324 | 1098 else: |
| 1099 if n[1] not in seen and n[1] not in fetch: | |
| 1100 if n[2] in m and n[3] in m: | |
| 1101 self.ui.debug("found new changeset %s\n" % | |
| 1102 short(n[1])) | |
| 1103 fetch.append(n[1]) # earliest unknown | |
|
579
ffeb2c3a1966
Actually warn on pulling from an unrelated repository
mpm@selenic.com
parents:
578
diff
changeset
|
1104 base[n[2]] = 1 # latest known |
| 324 | 1105 continue |
| 1106 | |
| 1107 for a in n[2:4]: | |
| 1108 if a not in rep: | |
| 1109 r.append(a) | |
| 1110 rep[a] = 1 | |
| 1111 | |
| 328 | 1112 seen[n[0]] = 1 |
| 1113 | |
| 324 | 1114 if r: |
| 1115 reqcnt += 1 | |
| 1116 self.ui.debug("request %d: %s\n" % | |
| 1117 (reqcnt, " ".join(map(short, r)))) | |
| 1118 for p in range(0, len(r), 10): | |
| 1119 for b in remote.branches(r[p:p+10]): | |
|
148
c32286d0a665
Improve pruning of branches in outstanding changeset algorithm
mpm@selenic.com
parents:
146
diff
changeset
|
1120 self.ui.debug("received %s:%s\n" % |
|
c32286d0a665
Improve pruning of branches in outstanding changeset algorithm
mpm@selenic.com
parents:
146
diff
changeset
|
1121 (short(b[0]), short(b[1]))) |
|
c32286d0a665
Improve pruning of branches in outstanding changeset algorithm
mpm@selenic.com
parents:
146
diff
changeset
|
1122 if b[0] not in m and b[0] not in seen: |
|
c32286d0a665
Improve pruning of branches in outstanding changeset algorithm
mpm@selenic.com
parents:
146
diff
changeset
|
1123 unknown.append(b) |
| 515 | 1124 |
|
579
ffeb2c3a1966
Actually warn on pulling from an unrelated repository
mpm@selenic.com
parents:
578
diff
changeset
|
1125 # do binary search on the branches we found |
|
56
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
1126 while search: |
|
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
1127 n = search.pop(0) |
| 324 | 1128 reqcnt += 1 |
|
56
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
1129 l = remote.between([(n[0], n[1])])[0] |
| 328 | 1130 l.append(n[1]) |
|
56
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
1131 p = n[0] |
|
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
1132 f = 1 |
| 328 | 1133 for i in l: |
| 1134 self.ui.debug("narrowing %d:%d %s\n" % (f, len(l), short(i))) | |
|
65
d40cc5aacc31
Fix up a bunch of bugs in the new merge code
mpm@selenic.com
parents:
64
diff
changeset
|
1135 if i in m: |
| 85 | 1136 if f <= 2: |
| 83 | 1137 self.ui.debug("found new branch changeset %s\n" % |
| 1138 short(p)) | |
|
56
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
1139 fetch.append(p) |
|
579
ffeb2c3a1966
Actually warn on pulling from an unrelated repository
mpm@selenic.com
parents:
578
diff
changeset
|
1140 base[i] = 1 |
|
56
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
1141 else: |
| 83 | 1142 self.ui.debug("narrowed branch search to %s:%s\n" |
| 1143 % (short(p), short(i))) | |
|
56
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
1144 search.append((p, i)) |
|
65
d40cc5aacc31
Fix up a bunch of bugs in the new merge code
mpm@selenic.com
parents:
64
diff
changeset
|
1145 break |
|
56
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
1146 p, f = i, f * 2 |
|
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
1147 |
|
579
ffeb2c3a1966
Actually warn on pulling from an unrelated repository
mpm@selenic.com
parents:
578
diff
changeset
|
1148 # sanity check our fetch list |
|
65
d40cc5aacc31
Fix up a bunch of bugs in the new merge code
mpm@selenic.com
parents:
64
diff
changeset
|
1149 for f in fetch: |
|
d40cc5aacc31
Fix up a bunch of bugs in the new merge code
mpm@selenic.com
parents:
64
diff
changeset
|
1150 if f in m: |
| 499 | 1151 raise RepoError("already have changeset " + short(f[:4])) |
| 83 | 1152 |
|
579
ffeb2c3a1966
Actually warn on pulling from an unrelated repository
mpm@selenic.com
parents:
578
diff
changeset
|
1153 if base.keys() == [nullid]: |
|
514
874e577e332e
change unrelated repository error to a warning
mpm@selenic.com
parents:
511
diff
changeset
|
1154 self.ui.warn("warning: pulling from an unrelated repository!\n") |
| 511 | 1155 |
| 94 | 1156 self.ui.note("adding new changesets starting at " + |
| 83 | 1157 " ".join([short(f) for f in fetch]) + "\n") |
|
65
d40cc5aacc31
Fix up a bunch of bugs in the new merge code
mpm@selenic.com
parents:
64
diff
changeset
|
1158 |
| 324 | 1159 self.ui.debug("%d total queries\n" % reqcnt) |
| 1160 | |
| 516 | 1161 return fetch |
| 1162 | |
|
621
004e811f7706
Add a function to calculate the outgoing changegroup
Matt Mackall <mpm@selenic.com>
parents:
616
diff
changeset
|
1163 def findoutgoing(self, remote): |
|
004e811f7706
Add a function to calculate the outgoing changegroup
Matt Mackall <mpm@selenic.com>
parents:
616
diff
changeset
|
1164 base = {} |
|
637
31e090c34d3b
Fix up the broken bits in findoutgoing
Matt Mackall <mpm@selenic.com>
parents:
636
diff
changeset
|
1165 self.findincoming(remote, base) |
|
621
004e811f7706
Add a function to calculate the outgoing changegroup
Matt Mackall <mpm@selenic.com>
parents:
616
diff
changeset
|
1166 remain = dict.fromkeys(self.changelog.nodemap) |
|
004e811f7706
Add a function to calculate the outgoing changegroup
Matt Mackall <mpm@selenic.com>
parents:
616
diff
changeset
|
1167 |
|
004e811f7706
Add a function to calculate the outgoing changegroup
Matt Mackall <mpm@selenic.com>
parents:
616
diff
changeset
|
1168 # prune everything remote has from the tree |
|
637
31e090c34d3b
Fix up the broken bits in findoutgoing
Matt Mackall <mpm@selenic.com>
parents:
636
diff
changeset
|
1169 del remain[nullid] |
|
621
004e811f7706
Add a function to calculate the outgoing changegroup
Matt Mackall <mpm@selenic.com>
parents:
616
diff
changeset
|
1170 remove = base.keys() |
|
004e811f7706
Add a function to calculate the outgoing changegroup
Matt Mackall <mpm@selenic.com>
parents:
616
diff
changeset
|
1171 while remove: |
|
004e811f7706
Add a function to calculate the outgoing changegroup
Matt Mackall <mpm@selenic.com>
parents:
616
diff
changeset
|
1172 n = remove.pop(0) |
|
004e811f7706
Add a function to calculate the outgoing changegroup
Matt Mackall <mpm@selenic.com>
parents:
616
diff
changeset
|
1173 if n in remain: |
|
004e811f7706
Add a function to calculate the outgoing changegroup
Matt Mackall <mpm@selenic.com>
parents:
616
diff
changeset
|
1174 del remain[n] |
|
004e811f7706
Add a function to calculate the outgoing changegroup
Matt Mackall <mpm@selenic.com>
parents:
616
diff
changeset
|
1175 for p in self.changelog.parents(n): |
|
637
31e090c34d3b
Fix up the broken bits in findoutgoing
Matt Mackall <mpm@selenic.com>
parents:
636
diff
changeset
|
1176 remove.append(p) |
|
621
004e811f7706
Add a function to calculate the outgoing changegroup
Matt Mackall <mpm@selenic.com>
parents:
616
diff
changeset
|
1177 |
|
004e811f7706
Add a function to calculate the outgoing changegroup
Matt Mackall <mpm@selenic.com>
parents:
616
diff
changeset
|
1178 # find every node whose parents have been pruned |
|
004e811f7706
Add a function to calculate the outgoing changegroup
Matt Mackall <mpm@selenic.com>
parents:
616
diff
changeset
|
1179 subset = [] |
|
004e811f7706
Add a function to calculate the outgoing changegroup
Matt Mackall <mpm@selenic.com>
parents:
616
diff
changeset
|
1180 for n in remain: |
|
004e811f7706
Add a function to calculate the outgoing changegroup
Matt Mackall <mpm@selenic.com>
parents:
616
diff
changeset
|
1181 p1, p2 = self.changelog.parents(n) |
|
004e811f7706
Add a function to calculate the outgoing changegroup
Matt Mackall <mpm@selenic.com>
parents:
616
diff
changeset
|
1182 if p1 not in remain and p2 not in remain: |
|
004e811f7706
Add a function to calculate the outgoing changegroup
Matt Mackall <mpm@selenic.com>
parents:
616
diff
changeset
|
1183 subset.append(n) |
|
004e811f7706
Add a function to calculate the outgoing changegroup
Matt Mackall <mpm@selenic.com>
parents:
616
diff
changeset
|
1184 |
|
004e811f7706
Add a function to calculate the outgoing changegroup
Matt Mackall <mpm@selenic.com>
parents:
616
diff
changeset
|
1185 # this is the set of all roots we have to push |
|
004e811f7706
Add a function to calculate the outgoing changegroup
Matt Mackall <mpm@selenic.com>
parents:
616
diff
changeset
|
1186 return subset |
|
004e811f7706
Add a function to calculate the outgoing changegroup
Matt Mackall <mpm@selenic.com>
parents:
616
diff
changeset
|
1187 |
|
622
e9fe5d5e67f7
Add generic repo commands for pull and push
Matt Mackall <mpm@selenic.com>
parents:
621
diff
changeset
|
1188 def pull(self, remote): |
|
e9fe5d5e67f7
Add generic repo commands for pull and push
Matt Mackall <mpm@selenic.com>
parents:
621
diff
changeset
|
1189 lock = self.lock() |
|
636
ac0ec421e3a5
Move the empty changeset detection out of findincoming to pull
Matt Mackall <mpm@selenic.com>
parents:
635
diff
changeset
|
1190 |
|
ac0ec421e3a5
Move the empty changeset detection out of findincoming to pull
Matt Mackall <mpm@selenic.com>
parents:
635
diff
changeset
|
1191 # if we have an empty repo, fetch everything |
|
ac0ec421e3a5
Move the empty changeset detection out of findincoming to pull
Matt Mackall <mpm@selenic.com>
parents:
635
diff
changeset
|
1192 if self.changelog.tip() == nullid: |
|
ac0ec421e3a5
Move the empty changeset detection out of findincoming to pull
Matt Mackall <mpm@selenic.com>
parents:
635
diff
changeset
|
1193 self.ui.status("requesting all changes\n") |
|
ac0ec421e3a5
Move the empty changeset detection out of findincoming to pull
Matt Mackall <mpm@selenic.com>
parents:
635
diff
changeset
|
1194 fetch = [nullid] |
|
ac0ec421e3a5
Move the empty changeset detection out of findincoming to pull
Matt Mackall <mpm@selenic.com>
parents:
635
diff
changeset
|
1195 else: |
|
ac0ec421e3a5
Move the empty changeset detection out of findincoming to pull
Matt Mackall <mpm@selenic.com>
parents:
635
diff
changeset
|
1196 fetch = self.findincoming(remote) |
|
ac0ec421e3a5
Move the empty changeset detection out of findincoming to pull
Matt Mackall <mpm@selenic.com>
parents:
635
diff
changeset
|
1197 |
|
622
e9fe5d5e67f7
Add generic repo commands for pull and push
Matt Mackall <mpm@selenic.com>
parents:
621
diff
changeset
|
1198 if not fetch: |
|
e9fe5d5e67f7
Add generic repo commands for pull and push
Matt Mackall <mpm@selenic.com>
parents:
621
diff
changeset
|
1199 self.ui.status("no changes found\n") |
|
e9fe5d5e67f7
Add generic repo commands for pull and push
Matt Mackall <mpm@selenic.com>
parents:
621
diff
changeset
|
1200 return 1 |
|
e9fe5d5e67f7
Add generic repo commands for pull and push
Matt Mackall <mpm@selenic.com>
parents:
621
diff
changeset
|
1201 |
|
e9fe5d5e67f7
Add generic repo commands for pull and push
Matt Mackall <mpm@selenic.com>
parents:
621
diff
changeset
|
1202 cg = remote.changegroup(fetch) |
|
e9fe5d5e67f7
Add generic repo commands for pull and push
Matt Mackall <mpm@selenic.com>
parents:
621
diff
changeset
|
1203 return self.addchangegroup(cg) |
|
e9fe5d5e67f7
Add generic repo commands for pull and push
Matt Mackall <mpm@selenic.com>
parents:
621
diff
changeset
|
1204 |
|
e9fe5d5e67f7
Add generic repo commands for pull and push
Matt Mackall <mpm@selenic.com>
parents:
621
diff
changeset
|
1205 def push(self, remote): |
|
e9fe5d5e67f7
Add generic repo commands for pull and push
Matt Mackall <mpm@selenic.com>
parents:
621
diff
changeset
|
1206 lock = remote.lock() |
|
e9fe5d5e67f7
Add generic repo commands for pull and push
Matt Mackall <mpm@selenic.com>
parents:
621
diff
changeset
|
1207 update = self.findoutgoing(remote) |
|
e9fe5d5e67f7
Add generic repo commands for pull and push
Matt Mackall <mpm@selenic.com>
parents:
621
diff
changeset
|
1208 if not update: |
|
e9fe5d5e67f7
Add generic repo commands for pull and push
Matt Mackall <mpm@selenic.com>
parents:
621
diff
changeset
|
1209 self.ui.status("no changes found\n") |
|
e9fe5d5e67f7
Add generic repo commands for pull and push
Matt Mackall <mpm@selenic.com>
parents:
621
diff
changeset
|
1210 return 1 |
|
e9fe5d5e67f7
Add generic repo commands for pull and push
Matt Mackall <mpm@selenic.com>
parents:
621
diff
changeset
|
1211 |
|
e9fe5d5e67f7
Add generic repo commands for pull and push
Matt Mackall <mpm@selenic.com>
parents:
621
diff
changeset
|
1212 cg = self.changegroup(update) |
|
e9fe5d5e67f7
Add generic repo commands for pull and push
Matt Mackall <mpm@selenic.com>
parents:
621
diff
changeset
|
1213 return remote.addchangegroup(cg) |
|
e9fe5d5e67f7
Add generic repo commands for pull and push
Matt Mackall <mpm@selenic.com>
parents:
621
diff
changeset
|
1214 |
|
56
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
1215 def changegroup(self, basenodes): |
| 222 | 1216 class genread: |
| 1217 def __init__(self, generator): | |
| 1218 self.g = generator | |
| 1219 self.buf = "" | |
| 1220 def read(self, l): | |
| 1221 while l > len(self.buf): | |
| 1222 try: | |
| 1223 self.buf += self.g.next() | |
| 1224 except StopIteration: | |
| 1225 break | |
| 1226 d, self.buf = self.buf[:l], self.buf[l:] | |
| 1227 return d | |
| 515 | 1228 |
|
635
85e2209d401c
Protocol switch from using generators to stream-like objects.
Matt Mackall <mpm@selenic.com>
parents:
634
diff
changeset
|
1229 def gengroup(): |
|
85e2209d401c
Protocol switch from using generators to stream-like objects.
Matt Mackall <mpm@selenic.com>
parents:
634
diff
changeset
|
1230 nodes = self.newer(basenodes) |
|
85e2209d401c
Protocol switch from using generators to stream-like objects.
Matt Mackall <mpm@selenic.com>
parents:
634
diff
changeset
|
1231 |
|
85e2209d401c
Protocol switch from using generators to stream-like objects.
Matt Mackall <mpm@selenic.com>
parents:
634
diff
changeset
|
1232 # construct the link map |
|
85e2209d401c
Protocol switch from using generators to stream-like objects.
Matt Mackall <mpm@selenic.com>
parents:
634
diff
changeset
|
1233 linkmap = {} |
|
85e2209d401c
Protocol switch from using generators to stream-like objects.
Matt Mackall <mpm@selenic.com>
parents:
634
diff
changeset
|
1234 for n in nodes: |
|
85e2209d401c
Protocol switch from using generators to stream-like objects.
Matt Mackall <mpm@selenic.com>
parents:
634
diff
changeset
|
1235 linkmap[self.changelog.rev(n)] = n |
|
85e2209d401c
Protocol switch from using generators to stream-like objects.
Matt Mackall <mpm@selenic.com>
parents:
634
diff
changeset
|
1236 |
|
85e2209d401c
Protocol switch from using generators to stream-like objects.
Matt Mackall <mpm@selenic.com>
parents:
634
diff
changeset
|
1237 # construct a list of all changed files |
|
85e2209d401c
Protocol switch from using generators to stream-like objects.
Matt Mackall <mpm@selenic.com>
parents:
634
diff
changeset
|
1238 changed = {} |
|
85e2209d401c
Protocol switch from using generators to stream-like objects.
Matt Mackall <mpm@selenic.com>
parents:
634
diff
changeset
|
1239 for n in nodes: |
|
85e2209d401c
Protocol switch from using generators to stream-like objects.
Matt Mackall <mpm@selenic.com>
parents:
634
diff
changeset
|
1240 c = self.changelog.read(n) |
|
85e2209d401c
Protocol switch from using generators to stream-like objects.
Matt Mackall <mpm@selenic.com>
parents:
634
diff
changeset
|
1241 for f in c[3]: |
|
85e2209d401c
Protocol switch from using generators to stream-like objects.
Matt Mackall <mpm@selenic.com>
parents:
634
diff
changeset
|
1242 changed[f] = 1 |
|
85e2209d401c
Protocol switch from using generators to stream-like objects.
Matt Mackall <mpm@selenic.com>
parents:
634
diff
changeset
|
1243 changed = changed.keys() |
|
85e2209d401c
Protocol switch from using generators to stream-like objects.
Matt Mackall <mpm@selenic.com>
parents:
634
diff
changeset
|
1244 changed.sort() |
|
85e2209d401c
Protocol switch from using generators to stream-like objects.
Matt Mackall <mpm@selenic.com>
parents:
634
diff
changeset
|
1245 |
|
85e2209d401c
Protocol switch from using generators to stream-like objects.
Matt Mackall <mpm@selenic.com>
parents:
634
diff
changeset
|
1246 # the changegroup is changesets + manifests + all file revs |
|
85e2209d401c
Protocol switch from using generators to stream-like objects.
Matt Mackall <mpm@selenic.com>
parents:
634
diff
changeset
|
1247 revs = [ self.changelog.rev(n) for n in nodes ] |
|
85e2209d401c
Protocol switch from using generators to stream-like objects.
Matt Mackall <mpm@selenic.com>
parents:
634
diff
changeset
|
1248 |
|
85e2209d401c
Protocol switch from using generators to stream-like objects.
Matt Mackall <mpm@selenic.com>
parents:
634
diff
changeset
|
1249 for y in self.changelog.group(linkmap): yield y |
|
85e2209d401c
Protocol switch from using generators to stream-like objects.
Matt Mackall <mpm@selenic.com>
parents:
634
diff
changeset
|
1250 for y in self.manifest.group(linkmap): yield y |
|
85e2209d401c
Protocol switch from using generators to stream-like objects.
Matt Mackall <mpm@selenic.com>
parents:
634
diff
changeset
|
1251 for f in changed: |
|
85e2209d401c
Protocol switch from using generators to stream-like objects.
Matt Mackall <mpm@selenic.com>
parents:
634
diff
changeset
|
1252 yield struct.pack(">l", len(f) + 4) + f |
|
85e2209d401c
Protocol switch from using generators to stream-like objects.
Matt Mackall <mpm@selenic.com>
parents:
634
diff
changeset
|
1253 g = self.file(f).group(linkmap) |
|
85e2209d401c
Protocol switch from using generators to stream-like objects.
Matt Mackall <mpm@selenic.com>
parents:
634
diff
changeset
|
1254 for y in g: |
|
85e2209d401c
Protocol switch from using generators to stream-like objects.
Matt Mackall <mpm@selenic.com>
parents:
634
diff
changeset
|
1255 yield y |
|
85e2209d401c
Protocol switch from using generators to stream-like objects.
Matt Mackall <mpm@selenic.com>
parents:
634
diff
changeset
|
1256 |
|
85e2209d401c
Protocol switch from using generators to stream-like objects.
Matt Mackall <mpm@selenic.com>
parents:
634
diff
changeset
|
1257 yield struct.pack(">l", 0) |
|
85e2209d401c
Protocol switch from using generators to stream-like objects.
Matt Mackall <mpm@selenic.com>
parents:
634
diff
changeset
|
1258 |
|
85e2209d401c
Protocol switch from using generators to stream-like objects.
Matt Mackall <mpm@selenic.com>
parents:
634
diff
changeset
|
1259 return genread(gengroup()) |
|
85e2209d401c
Protocol switch from using generators to stream-like objects.
Matt Mackall <mpm@selenic.com>
parents:
634
diff
changeset
|
1260 |
|
85e2209d401c
Protocol switch from using generators to stream-like objects.
Matt Mackall <mpm@selenic.com>
parents:
634
diff
changeset
|
1261 def addchangegroup(self, source): |
|
85e2209d401c
Protocol switch from using generators to stream-like objects.
Matt Mackall <mpm@selenic.com>
parents:
634
diff
changeset
|
1262 |
| 222 | 1263 def getchunk(): |
| 1264 d = source.read(4) | |
| 1265 if not d: return "" | |
| 1266 l = struct.unpack(">l", d)[0] | |
| 1267 if l <= 4: return "" | |
| 1268 return source.read(l - 4) | |
| 1269 | |
| 1270 def getgroup(): | |
| 1271 while 1: | |
| 1272 c = getchunk() | |
| 1273 if not c: break | |
| 1274 yield c | |
| 1275 | |
| 1276 def csmap(x): | |
| 1277 self.ui.debug("add changeset %s\n" % short(x)) | |
| 1278 return self.changelog.count() | |
| 1279 | |
| 1280 def revmap(x): | |
| 1281 return self.changelog.rev(x) | |
| 1282 | |
|
635
85e2209d401c
Protocol switch from using generators to stream-like objects.
Matt Mackall <mpm@selenic.com>
parents:
634
diff
changeset
|
1283 if not source: return |
| 222 | 1284 changesets = files = revisions = 0 |
| 225 | 1285 |
| 222 | 1286 tr = self.transaction() |
| 1287 | |
| 1288 # pull off the changeset group | |
| 1289 self.ui.status("adding changesets\n") | |
| 1290 co = self.changelog.tip() | |
|
224
ccbcc4d76f81
fix bad assumption about uniqueness of file versions
mpm@selenic.com
parents:
223
diff
changeset
|
1291 cn = self.changelog.addgroup(getgroup(), csmap, tr, 1) # unique |
| 222 | 1292 changesets = self.changelog.rev(cn) - self.changelog.rev(co) |
| 1293 | |
| 1294 # pull off the manifest group | |
| 1295 self.ui.status("adding manifests\n") | |
| 1296 mm = self.manifest.tip() | |
| 1297 mo = self.manifest.addgroup(getgroup(), revmap, tr) | |
| 1298 | |
| 1299 # process the files | |
| 772 | 1300 self.ui.status("adding file changes\n") |
| 222 | 1301 while 1: |
| 1302 f = getchunk() | |
| 1303 if not f: break | |
| 1304 self.ui.debug("adding %s revisions\n" % f) | |
| 1305 fl = self.file(f) | |
|
529
aace5b681fe9
Attempt to fix negative revision count from pull
mpm@selenic.com
parents:
522
diff
changeset
|
1306 o = fl.count() |
| 222 | 1307 n = fl.addgroup(getgroup(), revmap, tr) |
|
529
aace5b681fe9
Attempt to fix negative revision count from pull
mpm@selenic.com
parents:
522
diff
changeset
|
1308 revisions += fl.count() - o |
| 222 | 1309 files += 1 |
| 1310 | |
| 772 | 1311 self.ui.status(("added %d changesets" + |
| 1312 " with %d changes to %d files\n") | |
| 1313 % (changesets, revisions, files)) | |
| 222 | 1314 |
| 1315 tr.close() | |
| 780 | 1316 |
| 1317 if not self.hook("changegroup"): | |
| 1318 return 1 | |
| 1319 | |
| 222 | 1320 return |
| 1321 | |
| 588 | 1322 def update(self, node, allow=False, force=False, choose=None, |
| 1323 moddirstate=True): | |
|
232
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1324 pl = self.dirstate.parents() |
| 275 | 1325 if not force and pl[1] != nullid: |
| 254 | 1326 self.ui.warn("aborting: outstanding uncommitted merges\n") |
| 690 | 1327 return 1 |
| 46 | 1328 |
|
232
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1329 p1, p2 = pl[0], node |
| 305 | 1330 pa = self.changelog.ancestor(p1, p2) |
|
232
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1331 m1n = self.changelog.read(p1)[0] |
|
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1332 m2n = self.changelog.read(p2)[0] |
|
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1333 man = self.manifest.ancestor(m1n, m2n) |
|
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1334 m1 = self.manifest.read(m1n) |
| 276 | 1335 mf1 = self.manifest.readflags(m1n) |
|
232
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1336 m2 = self.manifest.read(m2n) |
| 276 | 1337 mf2 = self.manifest.readflags(m2n) |
|
232
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1338 ma = self.manifest.read(man) |
| 412 | 1339 mfa = self.manifest.readflags(man) |
|
232
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1340 |
| 723 | 1341 (c, a, d, u) = self.changes() |
|
232
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1342 |
|
408
3695fbd2c33b
[PATCH] Merging files that are deleted in both branches
mpm@selenic.com
parents:
407
diff
changeset
|
1343 # is this a jump, or a merge? i.e. is there a linear path |
|
3695fbd2c33b
[PATCH] Merging files that are deleted in both branches
mpm@selenic.com
parents:
407
diff
changeset
|
1344 # from p1 to p2? |
|
3695fbd2c33b
[PATCH] Merging files that are deleted in both branches
mpm@selenic.com
parents:
407
diff
changeset
|
1345 linear_path = (pa == p1 or pa == p2) |
|
3695fbd2c33b
[PATCH] Merging files that are deleted in both branches
mpm@selenic.com
parents:
407
diff
changeset
|
1346 |
|
232
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1347 # resolve the manifest to determine which files |
|
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1348 # we care about merging |
| 254 | 1349 self.ui.note("resolving manifests\n") |
|
650
2c934c7b79dc
Fix bug in reverting deleted files
Matt Mackall <mpm@selenic.com>
parents:
649
diff
changeset
|
1350 self.ui.debug(" force %s allow %s moddirstate %s linear %s\n" % |
|
2c934c7b79dc
Fix bug in reverting deleted files
Matt Mackall <mpm@selenic.com>
parents:
649
diff
changeset
|
1351 (force, allow, moddirstate, linear_path)) |
|
232
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1352 self.ui.debug(" ancestor %s local %s remote %s\n" % |
|
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1353 (short(man), short(m1n), short(m2n))) |
|
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1354 |
|
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1355 merge = {} |
|
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1356 get = {} |
|
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1357 remove = [] |
| 305 | 1358 mark = {} |
| 46 | 1359 |
|
232
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1360 # construct a working dir manifest |
|
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1361 mw = m1.copy() |
| 276 | 1362 mfw = mf1.copy() |
| 576 | 1363 umap = dict.fromkeys(u) |
| 1364 | |
| 254 | 1365 for f in a + c + u: |
| 1366 mw[f] = "" | |
| 441 | 1367 mfw[f] = util.is_exec(self.wjoin(f), mfw.get(f, False)) |
| 576 | 1368 |
|
232
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1369 for f in d: |
| 254 | 1370 if f in mw: del mw[f] |
|
232
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1371 |
|
408
3695fbd2c33b
[PATCH] Merging files that are deleted in both branches
mpm@selenic.com
parents:
407
diff
changeset
|
1372 # If we're jumping between revisions (as opposed to merging), |
|
3695fbd2c33b
[PATCH] Merging files that are deleted in both branches
mpm@selenic.com
parents:
407
diff
changeset
|
1373 # and if neither the working directory nor the target rev has |
|
3695fbd2c33b
[PATCH] Merging files that are deleted in both branches
mpm@selenic.com
parents:
407
diff
changeset
|
1374 # the file, then we need to remove it from the dirstate, to |
|
3695fbd2c33b
[PATCH] Merging files that are deleted in both branches
mpm@selenic.com
parents:
407
diff
changeset
|
1375 # prevent the dirstate from listing the file when it is no |
|
3695fbd2c33b
[PATCH] Merging files that are deleted in both branches
mpm@selenic.com
parents:
407
diff
changeset
|
1376 # longer in the manifest. |
| 588 | 1377 if moddirstate and linear_path and f not in m2: |
|
408
3695fbd2c33b
[PATCH] Merging files that are deleted in both branches
mpm@selenic.com
parents:
407
diff
changeset
|
1378 self.dirstate.forget((f,)) |
|
3695fbd2c33b
[PATCH] Merging files that are deleted in both branches
mpm@selenic.com
parents:
407
diff
changeset
|
1379 |
| 576 | 1380 # Compare manifests |
|
232
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1381 for f, n in mw.iteritems(): |
| 588 | 1382 if choose and not choose(f): continue |
|
232
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1383 if f in m2: |
|
277
79279550c8ff
merge: update permissions even if file contents didn't change
mpm@selenic.com
parents:
276
diff
changeset
|
1384 s = 0 |
|
79279550c8ff
merge: update permissions even if file contents didn't change
mpm@selenic.com
parents:
276
diff
changeset
|
1385 |
|
407
0e0d0670b2bc
[PATCH] Merging identical changes from another branch
mpm@selenic.com
parents:
405
diff
changeset
|
1386 # is the wfile new since m1, and match m2? |
| 428 | 1387 if f not in m1: |
|
407
0e0d0670b2bc
[PATCH] Merging identical changes from another branch
mpm@selenic.com
parents:
405
diff
changeset
|
1388 t1 = self.wfile(f).read() |
|
0e0d0670b2bc
[PATCH] Merging identical changes from another branch
mpm@selenic.com
parents:
405
diff
changeset
|
1389 t2 = self.file(f).revision(m2[f]) |
|
0e0d0670b2bc
[PATCH] Merging identical changes from another branch
mpm@selenic.com
parents:
405
diff
changeset
|
1390 if cmp(t1, t2) == 0: |
|
0e0d0670b2bc
[PATCH] Merging identical changes from another branch
mpm@selenic.com
parents:
405
diff
changeset
|
1391 mark[f] = 1 |
|
0e0d0670b2bc
[PATCH] Merging identical changes from another branch
mpm@selenic.com
parents:
405
diff
changeset
|
1392 n = m2[f] |
|
0e0d0670b2bc
[PATCH] Merging identical changes from another branch
mpm@selenic.com
parents:
405
diff
changeset
|
1393 del t1, t2 |
|
0e0d0670b2bc
[PATCH] Merging identical changes from another branch
mpm@selenic.com
parents:
405
diff
changeset
|
1394 |
|
296
a3d83bf86755
hg update: fix clobbering files when going backwards
mpm@selenic.com
parents:
292
diff
changeset
|
1395 # are files different? |
|
232
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1396 if n != m2[f]: |
| 254 | 1397 a = ma.get(f, nullid) |
|
296
a3d83bf86755
hg update: fix clobbering files when going backwards
mpm@selenic.com
parents:
292
diff
changeset
|
1398 # are both different from the ancestor? |
| 254 | 1399 if n != a and m2[f] != a: |
|
273
4f8174389001
merge: Fix bug where we overwrote local when local was newer
mpm@selenic.com
parents:
263
diff
changeset
|
1400 self.ui.debug(" %s versions differ, resolve\n" % f) |
| 276 | 1401 # merge executable bits |
| 1402 # "if we changed or they changed, change in merge" | |
| 1403 a, b, c = mfa.get(f, 0), mfw[f], mf2[f] | |
| 1404 mode = ((a^b) | (a^c)) ^ a | |
| 1405 merge[f] = (m1.get(f, nullid), m2[f], mode) | |
|
277
79279550c8ff
merge: update permissions even if file contents didn't change
mpm@selenic.com
parents:
276
diff
changeset
|
1406 s = 1 |
| 305 | 1407 # are we clobbering? |
| 1408 # is remote's version newer? | |
| 1409 # or are we going back in time? | |
| 1410 elif force or m2[f] != a or (p2 == pa and mw[f] == m1[f]): | |
|
273
4f8174389001
merge: Fix bug where we overwrote local when local was newer
mpm@selenic.com
parents:
263
diff
changeset
|
1411 self.ui.debug(" remote %s is newer, get\n" % f) |
| 254 | 1412 get[f] = m2[f] |
|
277
79279550c8ff
merge: update permissions even if file contents didn't change
mpm@selenic.com
parents:
276
diff
changeset
|
1413 s = 1 |
| 305 | 1414 else: |
| 1415 mark[f] = 1 | |
| 576 | 1416 elif f in umap: |
| 1417 # this unknown file is the same as the checkout | |
| 1418 get[f] = m2[f] | |
|
277
79279550c8ff
merge: update permissions even if file contents didn't change
mpm@selenic.com
parents:
276
diff
changeset
|
1419 |
|
79279550c8ff
merge: update permissions even if file contents didn't change
mpm@selenic.com
parents:
276
diff
changeset
|
1420 if not s and mfw[f] != mf2[f]: |
|
79279550c8ff
merge: update permissions even if file contents didn't change
mpm@selenic.com
parents:
276
diff
changeset
|
1421 if force: |
|
79279550c8ff
merge: update permissions even if file contents didn't change
mpm@selenic.com
parents:
276
diff
changeset
|
1422 self.ui.debug(" updating permissions for %s\n" % f) |
| 441 | 1423 util.set_exec(self.wjoin(f), mf2[f]) |
|
277
79279550c8ff
merge: update permissions even if file contents didn't change
mpm@selenic.com
parents:
276
diff
changeset
|
1424 else: |
|
79279550c8ff
merge: update permissions even if file contents didn't change
mpm@selenic.com
parents:
276
diff
changeset
|
1425 a, b, c = mfa.get(f, 0), mfw[f], mf2[f] |
|
79279550c8ff
merge: update permissions even if file contents didn't change
mpm@selenic.com
parents:
276
diff
changeset
|
1426 mode = ((a^b) | (a^c)) ^ a |
|
79279550c8ff
merge: update permissions even if file contents didn't change
mpm@selenic.com
parents:
276
diff
changeset
|
1427 if mode != b: |
|
79279550c8ff
merge: update permissions even if file contents didn't change
mpm@selenic.com
parents:
276
diff
changeset
|
1428 self.ui.debug(" updating permissions for %s\n" % f) |
| 441 | 1429 util.set_exec(self.wjoin(f), mode) |
| 305 | 1430 mark[f] = 1 |
|
232
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1431 del m2[f] |
|
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1432 elif f in ma: |
| 616 | 1433 if n != ma[f]: |
| 1434 r = "d" | |
| 1435 if not force and (linear_path or allow): | |
|
415
c2b9502a4e96
[PATCH] Don't prompt user for keep-vs-delete when the merge is about to be aborted
mpm@selenic.com
parents:
413
diff
changeset
|
1436 r = self.ui.prompt( |
|
c2b9502a4e96
[PATCH] Don't prompt user for keep-vs-delete when the merge is about to be aborted
mpm@selenic.com
parents:
413
diff
changeset
|
1437 (" local changed %s which remote deleted\n" % f) + |
|
c2b9502a4e96
[PATCH] Don't prompt user for keep-vs-delete when the merge is about to be aborted
mpm@selenic.com
parents:
413
diff
changeset
|
1438 "(k)eep or (d)elete?", "[kd]", "k") |
|
232
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1439 if r == "d": |
|
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1440 remove.append(f) |
|
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1441 else: |
|
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1442 self.ui.debug("other deleted %s\n" % f) |
| 254 | 1443 remove.append(f) # other deleted it |
|
232
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1444 else: |
| 254 | 1445 if n == m1.get(f, nullid): # same as parent |
|
383
4862a134e2c2
hg merge: fix time asymmetry bug with deleting files on update to past
mpm@selenic.com
parents:
377
diff
changeset
|
1446 if p2 == pa: # going backwards? |
|
4862a134e2c2
hg merge: fix time asymmetry bug with deleting files on update to past
mpm@selenic.com
parents:
377
diff
changeset
|
1447 self.ui.debug("remote deleted %s\n" % f) |
|
4862a134e2c2
hg merge: fix time asymmetry bug with deleting files on update to past
mpm@selenic.com
parents:
377
diff
changeset
|
1448 remove.append(f) |
|
4862a134e2c2
hg merge: fix time asymmetry bug with deleting files on update to past
mpm@selenic.com
parents:
377
diff
changeset
|
1449 else: |
|
4862a134e2c2
hg merge: fix time asymmetry bug with deleting files on update to past
mpm@selenic.com
parents:
377
diff
changeset
|
1450 self.ui.debug("local created %s, keeping\n" % f) |
| 254 | 1451 else: |
| 1452 self.ui.debug("working dir created %s, keeping\n" % f) | |
| 46 | 1453 |
|
232
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1454 for f, n in m2.iteritems(): |
| 588 | 1455 if choose and not choose(f): continue |
| 256 | 1456 if f[0] == "/": continue |
| 616 | 1457 if f in ma and n != ma[f]: |
| 1458 r = "k" | |
| 1459 if not force and (linear_path or allow): | |
|
415
c2b9502a4e96
[PATCH] Don't prompt user for keep-vs-delete when the merge is about to be aborted
mpm@selenic.com
parents:
413
diff
changeset
|
1460 r = self.ui.prompt( |
|
c2b9502a4e96
[PATCH] Don't prompt user for keep-vs-delete when the merge is about to be aborted
mpm@selenic.com
parents:
413
diff
changeset
|
1461 ("remote changed %s which local deleted\n" % f) + |
|
c2b9502a4e96
[PATCH] Don't prompt user for keep-vs-delete when the merge is about to be aborted
mpm@selenic.com
parents:
413
diff
changeset
|
1462 "(k)eep or (d)elete?", "[kd]", "k") |
| 616 | 1463 if r == "k": get[f] = n |
| 1464 elif f not in ma: | |
| 254 | 1465 self.ui.debug("remote created %s\n" % f) |
|
232
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1466 get[f] = n |
| 616 | 1467 else: |
|
680
4b7b79d2db2c
Handle undeletion of files when checking out old revisions
Matt Mackall <mpm@selenic.com>
parents:
679
diff
changeset
|
1468 if force or p2 == pa: # going backwards? |
|
4b7b79d2db2c
Handle undeletion of files when checking out old revisions
Matt Mackall <mpm@selenic.com>
parents:
679
diff
changeset
|
1469 self.ui.debug("local deleted %s, recreating\n" % f) |
|
650
2c934c7b79dc
Fix bug in reverting deleted files
Matt Mackall <mpm@selenic.com>
parents:
649
diff
changeset
|
1470 get[f] = n |
|
680
4b7b79d2db2c
Handle undeletion of files when checking out old revisions
Matt Mackall <mpm@selenic.com>
parents:
679
diff
changeset
|
1471 else: |
|
4b7b79d2db2c
Handle undeletion of files when checking out old revisions
Matt Mackall <mpm@selenic.com>
parents:
679
diff
changeset
|
1472 self.ui.debug("local deleted %s\n" % f) |
|
232
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1473 |
|
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1474 del mw, m1, m2, ma |
|
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1475 |
| 275 | 1476 if force: |
| 1477 for f in merge: | |
| 1478 get[f] = merge[f][1] | |
| 1479 merge = {} | |
| 1480 | |
| 690 | 1481 if linear_path or force: |
| 254 | 1482 # we don't need to do any magic, just jump to the new rev |
| 1483 mode = 'n' | |
| 1484 p1, p2 = p2, nullid | |
| 1485 else: | |
| 275 | 1486 if not allow: |
| 305 | 1487 self.ui.status("this update spans a branch" + |
| 1488 " affecting the following files:\n") | |
| 1489 fl = merge.keys() + get.keys() | |
| 1490 fl.sort() | |
| 1491 for f in fl: | |
| 1492 cf = "" | |
| 1493 if f in merge: cf = " (resolve)" | |
| 1494 self.ui.status(" %s%s\n" % (f, cf)) | |
| 1495 self.ui.warn("aborting update spanning branches!\n") | |
| 1496 self.ui.status("(use update -m to perform a branch merge)\n") | |
| 275 | 1497 return 1 |
| 254 | 1498 # we have to remember what files we needed to get/change |
| 1499 # because any file that's different from either one of its | |
| 1500 # parents must be in the changeset | |
| 1501 mode = 'm' | |
| 588 | 1502 if moddirstate: |
| 1503 self.dirstate.update(mark.keys(), "m") | |
| 254 | 1504 |
| 588 | 1505 if moddirstate: |
| 1506 self.dirstate.setparents(p1, p2) | |
|
191
d7e859cf2f1b
merge: add count of new manifests, files, and revisions
mpm@selenic.com
parents:
190
diff
changeset
|
1507 |
|
232
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1508 # get the files we don't need to change |
|
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1509 files = get.keys() |
|
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1510 files.sort() |
|
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1511 for f in files: |
|
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1512 if f[0] == "/": continue |
|
273
4f8174389001
merge: Fix bug where we overwrote local when local was newer
mpm@selenic.com
parents:
263
diff
changeset
|
1513 self.ui.note("getting %s\n" % f) |
| 276 | 1514 t = self.file(f).read(get[f]) |
|
232
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1515 try: |
|
291
2c4f2be05587
Add wopener for opening files in the working directory
mpm@selenic.com
parents:
288
diff
changeset
|
1516 self.wfile(f, "w").write(t) |
|
232
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1517 except IOError: |
|
297
0dbcf3c9ff20
Fixed usage of removed variable 'wp'.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
292
diff
changeset
|
1518 os.makedirs(os.path.dirname(self.wjoin(f))) |
|
291
2c4f2be05587
Add wopener for opening files in the working directory
mpm@selenic.com
parents:
288
diff
changeset
|
1519 self.wfile(f, "w").write(t) |
| 441 | 1520 util.set_exec(self.wjoin(f), mf2[f]) |
| 588 | 1521 if moddirstate: |
| 1522 self.dirstate.update([f], mode) | |
| 46 | 1523 |
|
232
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1524 # merge the tricky bits |
|
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1525 files = merge.keys() |
|
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1526 files.sort() |
|
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1527 for f in files: |
| 256 | 1528 self.ui.status("merging %s\n" % f) |
| 276 | 1529 m, o, flag = merge[f] |
|
232
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1530 self.merge3(f, m, o) |
| 441 | 1531 util.set_exec(self.wjoin(f), flag) |
|
768
20e95c245bc3
Fix local file changes being ignored after non-branch merge
mpm@selenic.com
parents:
765
diff
changeset
|
1532 if moddirstate and mode == 'm': |
|
20e95c245bc3
Fix local file changes being ignored after non-branch merge
mpm@selenic.com
parents:
765
diff
changeset
|
1533 # only update dirstate on branch merge, otherwise we |
|
20e95c245bc3
Fix local file changes being ignored after non-branch merge
mpm@selenic.com
parents:
765
diff
changeset
|
1534 # could mark files with changes as unchanged |
|
764
eea96285cbf9
Don't mark files with 'm'erge unless we're actually merging branches
mpm@selenic.com
parents:
753
diff
changeset
|
1535 self.dirstate.update([f], mode) |
|
232
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1536 |
| 681 | 1537 remove.sort() |
|
232
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1538 for f in remove: |
|
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1539 self.ui.note("removing %s\n" % f) |
| 690 | 1540 try: |
| 1541 os.unlink(f) | |
| 1542 except OSError, inst: | |
| 1543 self.ui.warn("update failed to remove %s: %s!\n" % (f, inst)) | |
| 578 | 1544 # try removing directories that might now be empty |
| 1545 try: os.removedirs(os.path.dirname(f)) | |
| 1546 except: pass | |
| 588 | 1547 if moddirstate: |
| 1548 if mode == 'n': | |
| 1549 self.dirstate.forget(remove) | |
| 1550 else: | |
| 1551 self.dirstate.update(remove, 'r') | |
|
232
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1552 |
|
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1553 def merge3(self, fn, my, other): |
|
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1554 """perform a 3-way merge in the working directory""" |
| 249 | 1555 |
| 96 | 1556 def temp(prefix, node): |
| 1557 pre = "%s~%s." % (os.path.basename(fn), prefix) | |
| 1558 (fd, name) = tempfile.mkstemp("", pre) | |
| 417 | 1559 f = os.fdopen(fd, "wb") |
| 96 | 1560 f.write(fl.revision(node)) |
| 1561 f.close() | |
| 1562 return name | |
| 1563 | |
|
232
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1564 fl = self.file(fn) |
| 96 | 1565 base = fl.ancestor(my, other) |
| 244 | 1566 a = self.wjoin(fn) |
| 346 | 1567 b = temp("base", base) |
| 1568 c = temp("other", other) | |
| 96 | 1569 |
|
232
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1570 self.ui.note("resolving %s\n" % fn) |
|
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1571 self.ui.debug("file %s: other %s ancestor %s\n" % |
|
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1572 (fn, short(other), short(base))) |
| 96 | 1573 |
|
703
fb6f85ecc863
merge program setting from hgrc wasn't used.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
691
diff
changeset
|
1574 cmd = (os.environ.get("HGMERGE") or self.ui.config("ui", "merge") |
|
fb6f85ecc863
merge program setting from hgrc wasn't used.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
691
diff
changeset
|
1575 or "hgmerge") |
| 240 | 1576 r = os.system("%s %s %s %s" % (cmd, a, b, c)) |
|
232
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1577 if r: |
| 275 | 1578 self.ui.warn("merging %s failed!\n" % fn) |
|
232
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1579 |
|
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1580 os.unlink(b) |
|
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1581 os.unlink(c) |
| 96 | 1582 |
| 247 | 1583 def verify(self): |
| 1584 filelinkrevs = {} | |
| 1585 filenodes = {} | |
| 1586 changesets = revisions = files = 0 | |
| 1587 errors = 0 | |
| 1588 | |
| 302 | 1589 seen = {} |
| 247 | 1590 self.ui.status("checking changesets\n") |
| 1591 for i in range(self.changelog.count()): | |
| 1592 changesets += 1 | |
| 1593 n = self.changelog.node(i) | |
| 302 | 1594 if n in seen: |
| 1595 self.ui.warn("duplicate changeset at revision %d\n" % i) | |
| 1596 errors += 1 | |
| 1597 seen[n] = 1 | |
| 515 | 1598 |
| 247 | 1599 for p in self.changelog.parents(n): |
| 1600 if p not in self.changelog.nodemap: | |
| 1601 self.ui.warn("changeset %s has unknown parent %s\n" % | |
| 1602 (short(n), short(p))) | |
| 1603 errors += 1 | |
| 1604 try: | |
| 1605 changes = self.changelog.read(n) | |
| 1606 except Exception, inst: | |
| 1607 self.ui.warn("unpacking changeset %s: %s\n" % (short(n), inst)) | |
| 1608 errors += 1 | |
| 1609 | |
| 1610 for f in changes[3]: | |
| 1611 filelinkrevs.setdefault(f, []).append(i) | |
| 1612 | |
| 302 | 1613 seen = {} |
| 247 | 1614 self.ui.status("checking manifests\n") |
| 1615 for i in range(self.manifest.count()): | |
| 1616 n = self.manifest.node(i) | |
| 302 | 1617 if n in seen: |
| 1618 self.ui.warn("duplicate manifest at revision %d\n" % i) | |
| 1619 errors += 1 | |
| 1620 seen[n] = 1 | |
| 515 | 1621 |
| 247 | 1622 for p in self.manifest.parents(n): |
| 1623 if p not in self.manifest.nodemap: | |
| 1624 self.ui.warn("manifest %s has unknown parent %s\n" % | |
| 1625 (short(n), short(p))) | |
| 1626 errors += 1 | |
| 1627 | |
| 1628 try: | |
| 1629 delta = mdiff.patchtext(self.manifest.delta(n)) | |
| 1630 except KeyboardInterrupt: | |
| 582 | 1631 self.ui.warn("aborted") |
| 247 | 1632 sys.exit(0) |
| 1633 except Exception, inst: | |
| 1634 self.ui.warn("unpacking manifest %s: %s\n" | |
| 1635 % (short(n), inst)) | |
| 1636 errors += 1 | |
| 1637 | |
| 1638 ff = [ l.split('\0') for l in delta.splitlines() ] | |
| 1639 for f, fn in ff: | |
| 284 | 1640 filenodes.setdefault(f, {})[bin(fn[:40])] = 1 |
| 247 | 1641 |
| 1642 self.ui.status("crosschecking files in changesets and manifests\n") | |
| 1643 for f in filenodes: | |
| 1644 if f not in filelinkrevs: | |
| 1645 self.ui.warn("file %s in manifest but not in changesets\n" % f) | |
| 1646 errors += 1 | |
| 1647 | |
| 1648 for f in filelinkrevs: | |
| 1649 if f not in filenodes: | |
| 1650 self.ui.warn("file %s in changeset but not in manifest\n" % f) | |
| 1651 errors += 1 | |
| 1652 | |
| 1653 self.ui.status("checking files\n") | |
| 1654 ff = filenodes.keys() | |
| 1655 ff.sort() | |
| 1656 for f in ff: | |
| 1657 if f == "/dev/null": continue | |
| 1658 files += 1 | |
| 1659 fl = self.file(f) | |
| 1660 nodes = { nullid: 1 } | |
| 302 | 1661 seen = {} |
| 247 | 1662 for i in range(fl.count()): |
| 1663 revisions += 1 | |
| 1664 n = fl.node(i) | |
| 1665 | |
| 302 | 1666 if n in seen: |
| 1667 self.ui.warn("%s: duplicate revision %d\n" % (f, i)) | |
| 1668 errors += 1 | |
| 1669 | |
| 247 | 1670 if n not in filenodes[f]: |
| 1671 self.ui.warn("%s: %d:%s not in manifests\n" | |
| 1672 % (f, i, short(n))) | |
| 1673 errors += 1 | |
| 1674 else: | |
| 1675 del filenodes[f][n] | |
| 1676 | |
| 1677 flr = fl.linkrev(n) | |
| 1678 if flr not in filelinkrevs[f]: | |
| 1679 self.ui.warn("%s:%s points to unexpected changeset %d\n" | |
| 1680 % (f, short(n), fl.linkrev(n))) | |
| 1681 errors += 1 | |
| 1682 else: | |
| 1683 filelinkrevs[f].remove(flr) | |
| 1684 | |
| 1685 # verify contents | |
| 1686 try: | |
| 1687 t = fl.read(n) | |
| 1688 except Exception, inst: | |
| 1689 self.ui.warn("unpacking file %s %s: %s\n" | |
| 1690 % (f, short(n), inst)) | |
| 1691 errors += 1 | |
| 1692 | |
| 1693 # verify parents | |
| 1694 (p1, p2) = fl.parents(n) | |
| 1695 if p1 not in nodes: | |
| 1696 self.ui.warn("file %s:%s unknown parent 1 %s" % | |
| 1697 (f, short(n), short(p1))) | |
| 1698 errors += 1 | |
| 1699 if p2 not in nodes: | |
| 1700 self.ui.warn("file %s:%s unknown parent 2 %s" % | |
| 1701 (f, short(n), short(p1))) | |
| 1702 errors += 1 | |
| 1703 nodes[n] = 1 | |
| 1704 | |
| 1705 # cross-check | |
| 1706 for node in filenodes[f]: | |
| 1707 self.ui.warn("node %s in manifests not in %s\n" | |
| 721 | 1708 % (hex(node), f)) |
| 247 | 1709 errors += 1 |
| 1710 | |
| 1711 self.ui.status("%d files, %d changesets, %d total revisions\n" % | |
| 1712 (files, changesets, revisions)) | |
| 1713 | |
| 1714 if errors: | |
| 1715 self.ui.warn("%d integrity errors encountered!\n" % errors) | |
| 1716 return 1 | |
| 1717 | |
|
623
314867960a4a
Change remote repository to httprepository
Matt Mackall <mpm@selenic.com>
parents:
622
diff
changeset
|
1718 class httprepository: |
| 60 | 1719 def __init__(self, ui, path): |
| 765 | 1720 # fix missing / after hostname |
| 1721 s = urlparse.urlsplit(path) | |
| 1722 partial = s[2] | |
| 1723 if not partial: partial = "/" | |
| 1724 self.url = urlparse.urlunsplit((s[0], s[1], partial, '', '')) | |
| 60 | 1725 self.ui = ui |
| 321 | 1726 no_list = [ "localhost", "127.0.0.1" ] |
| 1727 host = ui.config("http_proxy", "host") | |
|
424
9294dce4b633
Allow override of HTTP_PROXY, http_proxy and no_proxy; make no_proxy work.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
385
diff
changeset
|
1728 if host is None: |
|
9294dce4b633
Allow override of HTTP_PROXY, http_proxy and no_proxy; make no_proxy work.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
385
diff
changeset
|
1729 host = os.environ.get("http_proxy") |
|
426
8c90ab5644c9
Allow hgrc's proxy host and $http_proxy env var to start with http://
Thomas Arendsen Hein <thomas@intevation.de>
parents:
424
diff
changeset
|
1730 if host and host.startswith('http://'): |
|
8c90ab5644c9
Allow hgrc's proxy host and $http_proxy env var to start with http://
Thomas Arendsen Hein <thomas@intevation.de>
parents:
424
diff
changeset
|
1731 host = host[7:] |
| 321 | 1732 user = ui.config("http_proxy", "user") |
| 1733 passwd = ui.config("http_proxy", "passwd") | |
| 1734 no = ui.config("http_proxy", "no") | |
|
424
9294dce4b633
Allow override of HTTP_PROXY, http_proxy and no_proxy; make no_proxy work.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
385
diff
changeset
|
1735 if no is None: |
|
9294dce4b633
Allow override of HTTP_PROXY, http_proxy and no_proxy; make no_proxy work.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
385
diff
changeset
|
1736 no = os.environ.get("no_proxy") |
| 321 | 1737 if no: |
| 1738 no_list = no_list + no.split(",") | |
| 515 | 1739 |
| 321 | 1740 no_proxy = 0 |
| 1741 for h in no_list: | |
| 1742 if (path.startswith("http://" + h + "/") or | |
| 1743 path.startswith("http://" + h + ":") or | |
| 1744 path == "http://" + h): | |
| 1745 no_proxy = 1 | |
| 1746 | |
| 1747 # Note: urllib2 takes proxy values from the environment and those will | |
| 1748 # take precedence | |
|
424
9294dce4b633
Allow override of HTTP_PROXY, http_proxy and no_proxy; make no_proxy work.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
385
diff
changeset
|
1749 for env in ["HTTP_PROXY", "http_proxy", "no_proxy"]: |
|
9294dce4b633
Allow override of HTTP_PROXY, http_proxy and no_proxy; make no_proxy work.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
385
diff
changeset
|
1750 if os.environ.has_key(env): |
|
9294dce4b633
Allow override of HTTP_PROXY, http_proxy and no_proxy; make no_proxy work.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
385
diff
changeset
|
1751 del os.environ[env] |
| 321 | 1752 |
| 1753 proxy_handler = urllib2.BaseHandler() | |
| 1754 if host and not no_proxy: | |
| 1755 proxy_handler = urllib2.ProxyHandler({"http" : "http://" + host}) | |
| 1756 | |
| 1757 authinfo = None | |
| 1758 if user and passwd: | |
| 1759 passmgr = urllib2.HTTPPasswordMgrWithDefaultRealm() | |
| 1760 passmgr.add_password(None, host, user, passwd) | |
| 1761 authinfo = urllib2.ProxyBasicAuthHandler(passmgr) | |
| 1762 | |
| 1763 opener = urllib2.build_opener(proxy_handler, authinfo) | |
| 1764 urllib2.install_opener(opener) | |
| 60 | 1765 |
|
634
da5378d39269
Add a repo method to report repo device
Matt Mackall <mpm@selenic.com>
parents:
627
diff
changeset
|
1766 def dev(self): |
|
da5378d39269
Add a repo method to report repo device
Matt Mackall <mpm@selenic.com>
parents:
627
diff
changeset
|
1767 return -1 |
|
da5378d39269
Add a repo method to report repo device
Matt Mackall <mpm@selenic.com>
parents:
627
diff
changeset
|
1768 |
| 60 | 1769 def do_cmd(self, cmd, **args): |
| 83 | 1770 self.ui.debug("sending %s command\n" % cmd) |
| 60 | 1771 q = {"cmd": cmd} |
| 1772 q.update(args) | |
| 1773 qs = urllib.urlencode(q) | |
| 1774 cu = "%s?%s" % (self.url, qs) | |
| 752 | 1775 resp = urllib2.urlopen(cu) |
| 753 | 1776 proto = resp.headers['content-type'] |
| 752 | 1777 |
| 753 | 1778 # accept old "text/plain" and "application/hg-changegroup" for now |
| 1779 if not proto.startswith('application/mercurial') and \ | |
| 1780 not proto.startswith('text/plain') and \ | |
| 1781 not proto.startswith('application/hg-changegroup'): | |
| 752 | 1782 raise RepoError("'%s' does not appear to be an hg repository" |
| 1783 % self.url) | |
| 1784 | |
| 753 | 1785 if proto.startswith('application/mercurial'): |
| 1786 version = proto[22:] | |
| 1787 if float(version) > 0.1: | |
| 1788 raise RepoError("'%s' uses newer protocol %s" % | |
| 1789 (self.url, version)) | |
| 1790 | |
| 752 | 1791 return resp |
| 60 | 1792 |
| 222 | 1793 def heads(self): |
| 1794 d = self.do_cmd("heads").read() | |
| 1795 try: | |
| 1796 return map(bin, d[:-1].split(" ")) | |
| 1797 except: | |
| 1798 self.ui.warn("unexpected response:\n" + d[:400] + "\n...\n") | |
| 1799 raise | |
| 1800 | |
| 60 | 1801 def branches(self, nodes): |
| 1802 n = " ".join(map(hex, nodes)) | |
| 752 | 1803 d = self.do_cmd("branches", nodes=n).read() |
| 217 | 1804 try: |
| 1805 br = [ tuple(map(bin, b.split(" "))) for b in d.splitlines() ] | |
| 1806 return br | |
| 1807 except: | |
| 1808 self.ui.warn("unexpected response:\n" + d[:400] + "\n...\n") | |
| 1809 raise | |
| 60 | 1810 |
| 1811 def between(self, pairs): | |
| 1812 n = "\n".join(["-".join(map(hex, p)) for p in pairs]) | |
| 752 | 1813 d = self.do_cmd("between", pairs=n).read() |
| 217 | 1814 try: |
| 1815 p = [ l and map(bin, l.split(" ")) or [] for l in d.splitlines() ] | |
| 1816 return p | |
| 1817 except: | |
| 1818 self.ui.warn("unexpected response:\n" + d[:400] + "\n...\n") | |
| 1819 raise | |
| 60 | 1820 |
| 1821 def changegroup(self, nodes): | |
| 1822 n = " ".join(map(hex, nodes)) | |
| 752 | 1823 f = self.do_cmd("changegroup", roots=n) |
| 192 | 1824 bytes = 0 |
|
635
85e2209d401c
Protocol switch from using generators to stream-like objects.
Matt Mackall <mpm@selenic.com>
parents:
634
diff
changeset
|
1825 |
|
85e2209d401c
Protocol switch from using generators to stream-like objects.
Matt Mackall <mpm@selenic.com>
parents:
634
diff
changeset
|
1826 class zread: |
|
85e2209d401c
Protocol switch from using generators to stream-like objects.
Matt Mackall <mpm@selenic.com>
parents:
634
diff
changeset
|
1827 def __init__(self, f): |
|
85e2209d401c
Protocol switch from using generators to stream-like objects.
Matt Mackall <mpm@selenic.com>
parents:
634
diff
changeset
|
1828 self.zd = zlib.decompressobj() |
|
85e2209d401c
Protocol switch from using generators to stream-like objects.
Matt Mackall <mpm@selenic.com>
parents:
634
diff
changeset
|
1829 self.f = f |
|
85e2209d401c
Protocol switch from using generators to stream-like objects.
Matt Mackall <mpm@selenic.com>
parents:
634
diff
changeset
|
1830 self.buf = "" |
|
85e2209d401c
Protocol switch from using generators to stream-like objects.
Matt Mackall <mpm@selenic.com>
parents:
634
diff
changeset
|
1831 def read(self, l): |
|
85e2209d401c
Protocol switch from using generators to stream-like objects.
Matt Mackall <mpm@selenic.com>
parents:
634
diff
changeset
|
1832 while l > len(self.buf): |
|
751
0b245edec124
When pulling from a non hg repository URL (e.g. http://www.kernel.org/hg)
Muli Ben-Yehuda <mulix@mulix.org>
parents:
741
diff
changeset
|
1833 r = self.f.read(4096) |
|
635
85e2209d401c
Protocol switch from using generators to stream-like objects.
Matt Mackall <mpm@selenic.com>
parents:
634
diff
changeset
|
1834 if r: |
|
85e2209d401c
Protocol switch from using generators to stream-like objects.
Matt Mackall <mpm@selenic.com>
parents:
634
diff
changeset
|
1835 self.buf += self.zd.decompress(r) |
|
85e2209d401c
Protocol switch from using generators to stream-like objects.
Matt Mackall <mpm@selenic.com>
parents:
634
diff
changeset
|
1836 else: |
|
85e2209d401c
Protocol switch from using generators to stream-like objects.
Matt Mackall <mpm@selenic.com>
parents:
634
diff
changeset
|
1837 self.buf += self.zd.flush() |
|
85e2209d401c
Protocol switch from using generators to stream-like objects.
Matt Mackall <mpm@selenic.com>
parents:
634
diff
changeset
|
1838 break |
|
85e2209d401c
Protocol switch from using generators to stream-like objects.
Matt Mackall <mpm@selenic.com>
parents:
634
diff
changeset
|
1839 d, self.buf = self.buf[:l], self.buf[l:] |
|
85e2209d401c
Protocol switch from using generators to stream-like objects.
Matt Mackall <mpm@selenic.com>
parents:
634
diff
changeset
|
1840 return d |
|
85e2209d401c
Protocol switch from using generators to stream-like objects.
Matt Mackall <mpm@selenic.com>
parents:
634
diff
changeset
|
1841 |
| 752 | 1842 return zread(f) |
|
635
85e2209d401c
Protocol switch from using generators to stream-like objects.
Matt Mackall <mpm@selenic.com>
parents:
634
diff
changeset
|
1843 |
|
638
35f7adfefa69
Add a scheme for handling remote locking
Matt Mackall <mpm@selenic.com>
parents:
637
diff
changeset
|
1844 class remotelock: |
|
35f7adfefa69
Add a scheme for handling remote locking
Matt Mackall <mpm@selenic.com>
parents:
637
diff
changeset
|
1845 def __init__(self, repo): |
|
35f7adfefa69
Add a scheme for handling remote locking
Matt Mackall <mpm@selenic.com>
parents:
637
diff
changeset
|
1846 self.repo = repo |
|
35f7adfefa69
Add a scheme for handling remote locking
Matt Mackall <mpm@selenic.com>
parents:
637
diff
changeset
|
1847 def release(self): |
|
35f7adfefa69
Add a scheme for handling remote locking
Matt Mackall <mpm@selenic.com>
parents:
637
diff
changeset
|
1848 self.repo.unlock() |
|
35f7adfefa69
Add a scheme for handling remote locking
Matt Mackall <mpm@selenic.com>
parents:
637
diff
changeset
|
1849 self.repo = None |
|
35f7adfefa69
Add a scheme for handling remote locking
Matt Mackall <mpm@selenic.com>
parents:
637
diff
changeset
|
1850 def __del__(self): |
|
35f7adfefa69
Add a scheme for handling remote locking
Matt Mackall <mpm@selenic.com>
parents:
637
diff
changeset
|
1851 if self.repo: |
|
35f7adfefa69
Add a scheme for handling remote locking
Matt Mackall <mpm@selenic.com>
parents:
637
diff
changeset
|
1852 self.release() |
| 60 | 1853 |
|
624
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
1854 class sshrepository: |
|
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
1855 def __init__(self, ui, path): |
|
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
1856 self.url = path |
|
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
1857 self.ui = ui |
|
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
1858 |
|
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
1859 m = re.match(r'ssh://(([^@]+)@)?([^:/]+)(:(\d+))?(/(.*))?', path) |
|
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
1860 if not m: |
|
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
1861 raise RepoError("couldn't parse destination %s\n" % path) |
|
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
1862 |
|
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
1863 self.user = m.group(2) |
|
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
1864 self.host = m.group(3) |
|
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
1865 self.port = m.group(5) |
|
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
1866 self.path = m.group(7) |
|
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
1867 |
|
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
1868 args = self.user and ("%s@%s" % (self.user, self.host)) or self.host |
|
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
1869 args = self.port and ("%s -p %s") % (args, self.port) or args |
|
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
1870 path = self.path or "" |
|
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
1871 |
|
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
1872 cmd = "ssh %s 'hg -R %s serve --stdio'" |
|
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
1873 cmd = cmd % (args, path) |
|
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
1874 |
|
646
342927da4f4c
Show remote client output with "remote:"
Matt Mackall <mpm@selenic.com>
parents:
644
diff
changeset
|
1875 self.pipeo, self.pipei, self.pipee = os.popen3(cmd) |
|
342927da4f4c
Show remote client output with "remote:"
Matt Mackall <mpm@selenic.com>
parents:
644
diff
changeset
|
1876 |
|
342927da4f4c
Show remote client output with "remote:"
Matt Mackall <mpm@selenic.com>
parents:
644
diff
changeset
|
1877 def readerr(self): |
|
342927da4f4c
Show remote client output with "remote:"
Matt Mackall <mpm@selenic.com>
parents:
644
diff
changeset
|
1878 while 1: |
|
342927da4f4c
Show remote client output with "remote:"
Matt Mackall <mpm@selenic.com>
parents:
644
diff
changeset
|
1879 r,w,x = select.select([self.pipee], [], [], 0) |
|
342927da4f4c
Show remote client output with "remote:"
Matt Mackall <mpm@selenic.com>
parents:
644
diff
changeset
|
1880 if not r: break |
|
342927da4f4c
Show remote client output with "remote:"
Matt Mackall <mpm@selenic.com>
parents:
644
diff
changeset
|
1881 l = self.pipee.readline() |
|
342927da4f4c
Show remote client output with "remote:"
Matt Mackall <mpm@selenic.com>
parents:
644
diff
changeset
|
1882 if not l: break |
|
342927da4f4c
Show remote client output with "remote:"
Matt Mackall <mpm@selenic.com>
parents:
644
diff
changeset
|
1883 self.ui.status("remote: ", l) |
|
624
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
1884 |
|
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
1885 def __del__(self): |
|
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
1886 self.pipeo.close() |
|
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
1887 self.pipei.close() |
|
648
8c89408a7154
Attempt to read all remaining remote output at close
Matt Mackall <mpm@selenic.com>
parents:
646
diff
changeset
|
1888 for l in self.pipee: |
|
8c89408a7154
Attempt to read all remaining remote output at close
Matt Mackall <mpm@selenic.com>
parents:
646
diff
changeset
|
1889 self.ui.status("remote: ", l) |
|
646
342927da4f4c
Show remote client output with "remote:"
Matt Mackall <mpm@selenic.com>
parents:
644
diff
changeset
|
1890 self.pipee.close() |
|
624
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
1891 |
|
634
da5378d39269
Add a repo method to report repo device
Matt Mackall <mpm@selenic.com>
parents:
627
diff
changeset
|
1892 def dev(self): |
|
da5378d39269
Add a repo method to report repo device
Matt Mackall <mpm@selenic.com>
parents:
627
diff
changeset
|
1893 return -1 |
|
da5378d39269
Add a repo method to report repo device
Matt Mackall <mpm@selenic.com>
parents:
627
diff
changeset
|
1894 |
|
624
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
1895 def do_cmd(self, cmd, **args): |
|
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
1896 self.ui.debug("sending %s command\n" % cmd) |
|
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
1897 self.pipeo.write("%s\n" % cmd) |
|
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
1898 for k, v in args.items(): |
|
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
1899 self.pipeo.write("%s %d\n" % (k, len(v))) |
|
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
1900 self.pipeo.write(v) |
|
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
1901 self.pipeo.flush() |
|
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
1902 |
|
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
1903 return self.pipei |
|
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
1904 |
|
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
1905 def call(self, cmd, **args): |
|
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
1906 r = self.do_cmd(cmd, **args) |
|
646
342927da4f4c
Show remote client output with "remote:"
Matt Mackall <mpm@selenic.com>
parents:
644
diff
changeset
|
1907 l = r.readline() |
|
342927da4f4c
Show remote client output with "remote:"
Matt Mackall <mpm@selenic.com>
parents:
644
diff
changeset
|
1908 self.readerr() |
|
342927da4f4c
Show remote client output with "remote:"
Matt Mackall <mpm@selenic.com>
parents:
644
diff
changeset
|
1909 try: |
|
342927da4f4c
Show remote client output with "remote:"
Matt Mackall <mpm@selenic.com>
parents:
644
diff
changeset
|
1910 l = int(l) |
|
342927da4f4c
Show remote client output with "remote:"
Matt Mackall <mpm@selenic.com>
parents:
644
diff
changeset
|
1911 except: |
|
342927da4f4c
Show remote client output with "remote:"
Matt Mackall <mpm@selenic.com>
parents:
644
diff
changeset
|
1912 raise RepoError("unexpected response '%s'" % l) |
|
624
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
1913 return r.read(l) |
|
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
1914 |
|
638
35f7adfefa69
Add a scheme for handling remote locking
Matt Mackall <mpm@selenic.com>
parents:
637
diff
changeset
|
1915 def lock(self): |
|
35f7adfefa69
Add a scheme for handling remote locking
Matt Mackall <mpm@selenic.com>
parents:
637
diff
changeset
|
1916 self.call("lock") |
|
35f7adfefa69
Add a scheme for handling remote locking
Matt Mackall <mpm@selenic.com>
parents:
637
diff
changeset
|
1917 return remotelock(self) |
|
35f7adfefa69
Add a scheme for handling remote locking
Matt Mackall <mpm@selenic.com>
parents:
637
diff
changeset
|
1918 |
|
35f7adfefa69
Add a scheme for handling remote locking
Matt Mackall <mpm@selenic.com>
parents:
637
diff
changeset
|
1919 def unlock(self): |
|
35f7adfefa69
Add a scheme for handling remote locking
Matt Mackall <mpm@selenic.com>
parents:
637
diff
changeset
|
1920 self.call("unlock") |
|
35f7adfefa69
Add a scheme for handling remote locking
Matt Mackall <mpm@selenic.com>
parents:
637
diff
changeset
|
1921 |
|
624
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
1922 def heads(self): |
|
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
1923 d = self.call("heads") |
|
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
1924 try: |
|
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
1925 return map(bin, d[:-1].split(" ")) |
|
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
1926 except: |
|
646
342927da4f4c
Show remote client output with "remote:"
Matt Mackall <mpm@selenic.com>
parents:
644
diff
changeset
|
1927 raise RepoError("unexpected response '%s'" % (d[:400] + "...")) |
|
624
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
1928 |
|
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
1929 def branches(self, nodes): |
|
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
1930 n = " ".join(map(hex, nodes)) |
|
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
1931 d = self.call("branches", nodes=n) |
|
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
1932 try: |
|
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
1933 br = [ tuple(map(bin, b.split(" "))) for b in d.splitlines() ] |
|
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
1934 return br |
|
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
1935 except: |
|
646
342927da4f4c
Show remote client output with "remote:"
Matt Mackall <mpm@selenic.com>
parents:
644
diff
changeset
|
1936 raise RepoError("unexpected response '%s'" % (d[:400] + "...")) |
|
624
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
1937 |
|
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
1938 def between(self, pairs): |
|
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
1939 n = "\n".join(["-".join(map(hex, p)) for p in pairs]) |
|
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
1940 d = self.call("between", pairs=n) |
|
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
1941 try: |
|
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
1942 p = [ l and map(bin, l.split(" ")) or [] for l in d.splitlines() ] |
|
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
1943 return p |
|
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
1944 except: |
|
646
342927da4f4c
Show remote client output with "remote:"
Matt Mackall <mpm@selenic.com>
parents:
644
diff
changeset
|
1945 raise RepoError("unexpected response '%s'" % (d[:400] + "...")) |
|
624
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
1946 |
|
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
1947 def changegroup(self, nodes): |
|
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
1948 n = " ".join(map(hex, nodes)) |
|
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
1949 f = self.do_cmd("changegroup", roots=n) |
|
635
85e2209d401c
Protocol switch from using generators to stream-like objects.
Matt Mackall <mpm@selenic.com>
parents:
634
diff
changeset
|
1950 return self.pipei |
|
624
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
1951 |
|
639
31cebba881a0
Add addchangegroup to the ssh protocol
Matt Mackall <mpm@selenic.com>
parents:
638
diff
changeset
|
1952 def addchangegroup(self, cg): |
|
31cebba881a0
Add addchangegroup to the ssh protocol
Matt Mackall <mpm@selenic.com>
parents:
638
diff
changeset
|
1953 d = self.call("addchangegroup") |
|
31cebba881a0
Add addchangegroup to the ssh protocol
Matt Mackall <mpm@selenic.com>
parents:
638
diff
changeset
|
1954 if d: |
|
31cebba881a0
Add addchangegroup to the ssh protocol
Matt Mackall <mpm@selenic.com>
parents:
638
diff
changeset
|
1955 raise RepoError("push refused: %s", d) |
|
31cebba881a0
Add addchangegroup to the ssh protocol
Matt Mackall <mpm@selenic.com>
parents:
638
diff
changeset
|
1956 |
|
31cebba881a0
Add addchangegroup to the ssh protocol
Matt Mackall <mpm@selenic.com>
parents:
638
diff
changeset
|
1957 while 1: |
|
31cebba881a0
Add addchangegroup to the ssh protocol
Matt Mackall <mpm@selenic.com>
parents:
638
diff
changeset
|
1958 d = cg.read(4096) |
|
31cebba881a0
Add addchangegroup to the ssh protocol
Matt Mackall <mpm@selenic.com>
parents:
638
diff
changeset
|
1959 if not d: break |
|
31cebba881a0
Add addchangegroup to the ssh protocol
Matt Mackall <mpm@selenic.com>
parents:
638
diff
changeset
|
1960 self.pipeo.write(d) |
|
646
342927da4f4c
Show remote client output with "remote:"
Matt Mackall <mpm@selenic.com>
parents:
644
diff
changeset
|
1961 self.readerr() |
|
639
31cebba881a0
Add addchangegroup to the ssh protocol
Matt Mackall <mpm@selenic.com>
parents:
638
diff
changeset
|
1962 |
|
31cebba881a0
Add addchangegroup to the ssh protocol
Matt Mackall <mpm@selenic.com>
parents:
638
diff
changeset
|
1963 self.pipeo.flush() |
|
31cebba881a0
Add addchangegroup to the ssh protocol
Matt Mackall <mpm@selenic.com>
parents:
638
diff
changeset
|
1964 |
|
646
342927da4f4c
Show remote client output with "remote:"
Matt Mackall <mpm@selenic.com>
parents:
644
diff
changeset
|
1965 self.readerr() |
|
639
31cebba881a0
Add addchangegroup to the ssh protocol
Matt Mackall <mpm@selenic.com>
parents:
638
diff
changeset
|
1966 l = int(self.pipei.readline()) |
|
646
342927da4f4c
Show remote client output with "remote:"
Matt Mackall <mpm@selenic.com>
parents:
644
diff
changeset
|
1967 return self.pipei.read(l) != "" |
|
639
31cebba881a0
Add addchangegroup to the ssh protocol
Matt Mackall <mpm@selenic.com>
parents:
638
diff
changeset
|
1968 |
| 60 | 1969 def repository(ui, path=None, create=0): |
|
623
314867960a4a
Change remote repository to httprepository
Matt Mackall <mpm@selenic.com>
parents:
622
diff
changeset
|
1970 if path: |
|
314867960a4a
Change remote repository to httprepository
Matt Mackall <mpm@selenic.com>
parents:
622
diff
changeset
|
1971 if path.startswith("http://"): |
|
314867960a4a
Change remote repository to httprepository
Matt Mackall <mpm@selenic.com>
parents:
622
diff
changeset
|
1972 return httprepository(ui, path) |
|
314867960a4a
Change remote repository to httprepository
Matt Mackall <mpm@selenic.com>
parents:
622
diff
changeset
|
1973 if path.startswith("hg://"): |
|
314867960a4a
Change remote repository to httprepository
Matt Mackall <mpm@selenic.com>
parents:
622
diff
changeset
|
1974 return httprepository(ui, path.replace("hg://", "http://")) |
|
314867960a4a
Change remote repository to httprepository
Matt Mackall <mpm@selenic.com>
parents:
622
diff
changeset
|
1975 if path.startswith("old-http://"): |
|
314867960a4a
Change remote repository to httprepository
Matt Mackall <mpm@selenic.com>
parents:
622
diff
changeset
|
1976 return localrepository(ui, path.replace("old-http://", "http://")) |
|
624
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
1977 if path.startswith("ssh://"): |
|
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
1978 return sshrepository(ui, path) |
| 60 | 1979 |
|
623
314867960a4a
Change remote repository to httprepository
Matt Mackall <mpm@selenic.com>
parents:
622
diff
changeset
|
1980 return localrepository(ui, path, create) |