Mercurial > hg > mercurial-crew-with-dirclash
annotate mercurial/hg.py @ 916:fe094cca9915
Add bash_completion to contrib
Contributed by "Alexis S. L. Carvalho" <alexis@cecm.usp.br>
Attached is a file that implements bash completion for hg. Just
reading it from your .bashrc should be enough to use it - I think: I'm
using the /etc/bash_completion from debian and I'm not sure whether it
sets some important option.
It gets the list of commands, aliases and options from the output of hg
help and then adds some specific stuff - e.g. completing update with
tags; pull and push with path aliases and directories, etc.
| author | mpm@selenic.com |
|---|---|
| date | Tue, 16 Aug 2005 14:17:27 -0800 |
| parents | d46af8e6b858 |
| children | 1458d20df2a8 |
| 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") |
|
884
087771ebe2e6
Fix walk code for files that do not exist anywhere, and unhandled types.
Bryan O'Sullivan <bos@serpentine.com>
parents:
883
diff
changeset
|
14 demandload(globals(), "bisect errno select stat") |
|
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): |
|
856
fbe964ae7325
Fixed encoding of directories ending in .d or .i:
Thomas Arendsen Hein <thomas@intevation.de>
parents:
839
diff
changeset
|
25 return (path |
|
fbe964ae7325
Fixed encoding of directories ending in .d or .i:
Thomas Arendsen Hein <thomas@intevation.de>
parents:
839
diff
changeset
|
26 .replace(".hg/", ".hg.hg/") |
|
fbe964ae7325
Fixed encoding of directories ending in .d or .i:
Thomas Arendsen Hein <thomas@intevation.de>
parents:
839
diff
changeset
|
27 .replace(".i/", ".i.hg/") |
|
fbe964ae7325
Fixed encoding of directories ending in .d or .i:
Thomas Arendsen Hein <thomas@intevation.de>
parents:
839
diff
changeset
|
28 .replace(".d/", ".d.hg/")) |
|
786
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): |
|
856
fbe964ae7325
Fixed encoding of directories ending in .d or .i:
Thomas Arendsen Hein <thomas@intevation.de>
parents:
839
diff
changeset
|
31 return (path |
|
fbe964ae7325
Fixed encoding of directories ending in .d or .i:
Thomas Arendsen Hein <thomas@intevation.de>
parents:
839
diff
changeset
|
32 .replace(".d.hg/", ".d/") |
|
fbe964ae7325
Fixed encoding of directories ending in .d or .i:
Thomas Arendsen Hein <thomas@intevation.de>
parents:
839
diff
changeset
|
33 .replace(".i.hg/", ".i/") |
|
fbe964ae7325
Fixed encoding of directories ending in .d or .i:
Thomas Arendsen Hein <thomas@intevation.de>
parents:
839
diff
changeset
|
34 .replace(".hg.hg/", ".hg/")) |
|
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 | |
|
870
a82eae840447
Teach walk code about absolute paths.
Bryan O'Sullivan <bos@serpentine.com>
parents:
839
diff
changeset
|
303 def getcwd(self): |
|
a82eae840447
Teach walk code about absolute paths.
Bryan O'Sullivan <bos@serpentine.com>
parents:
839
diff
changeset
|
304 cwd = os.getcwd() |
|
a82eae840447
Teach walk code about absolute paths.
Bryan O'Sullivan <bos@serpentine.com>
parents:
839
diff
changeset
|
305 if cwd == self.root: return '' |
|
a82eae840447
Teach walk code about absolute paths.
Bryan O'Sullivan <bos@serpentine.com>
parents:
839
diff
changeset
|
306 return cwd[len(self.root) + 1:] |
|
a82eae840447
Teach walk code about absolute paths.
Bryan O'Sullivan <bos@serpentine.com>
parents:
839
diff
changeset
|
307 |
| 723 | 308 def ignore(self, f): |
| 309 if not self.ignorefunc: | |
| 310 bigpat = [] | |
| 311 try: | |
| 312 l = file(self.wjoin(".hgignore")) | |
| 313 for pat in l: | |
|
911
d46af8e6b858
Fix .hgignore parsing if last line has no EOL, ignore trailing white space.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
903
diff
changeset
|
314 p = pat.rstrip() |
|
d46af8e6b858
Fix .hgignore parsing if last line has no EOL, ignore trailing white space.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
903
diff
changeset
|
315 if p: |
| 723 | 316 try: |
|
886
509de8ab6f31
Fix walk path handling on Windows
Bryan O'Sullivan <bos@serpentine.com>
parents:
884
diff
changeset
|
317 re.compile(p) |
| 723 | 318 except: |
| 319 self.ui.warn("ignoring invalid ignore" | |
| 320 + " regular expression '%s'\n" % p) | |
| 321 else: | |
|
886
509de8ab6f31
Fix walk path handling on Windows
Bryan O'Sullivan <bos@serpentine.com>
parents:
884
diff
changeset
|
322 bigpat.append(p) |
| 723 | 323 except IOError: pass |
| 324 | |
|
735
3433b228bbb3
An empty .hgignore file must cause us to ignore nothing, not everything!
Bryan O'Sullivan <bos@serpentine.com>
parents:
730
diff
changeset
|
325 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
|
326 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
|
327 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
|
328 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
|
329 else: |
|
3433b228bbb3
An empty .hgignore file must cause us to ignore nothing, not everything!
Bryan O'Sullivan <bos@serpentine.com>
parents:
730
diff
changeset
|
330 self.ignorefunc = util.never |
| 723 | 331 |
| 332 return self.ignorefunc(f) | |
| 220 | 333 |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
334 def __del__(self): |
| 220 | 335 if self.dirty: |
| 336 self.write() | |
| 337 | |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
338 def __getitem__(self, key): |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
339 try: |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
340 return self.map[key] |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
341 except TypeError: |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
342 self.read() |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
343 return self[key] |
| 220 | 344 |
| 345 def __contains__(self, key): | |
| 346 if not self.map: self.read() | |
| 347 return key in self.map | |
| 348 | |
| 227 | 349 def parents(self): |
| 350 if not self.pl: | |
| 351 self.read() | |
| 352 return self.pl | |
| 353 | |
| 723 | 354 def markdirty(self): |
| 355 if not self.dirty: | |
| 356 self.dirty = 1 | |
| 357 | |
| 227 | 358 def setparents(self, p1, p2 = nullid): |
| 723 | 359 self.markdirty() |
| 227 | 360 self.pl = p1, p2 |
| 361 | |
| 220 | 362 def state(self, key): |
| 363 try: | |
| 364 return self[key][0] | |
| 365 except KeyError: | |
| 366 return "?" | |
| 367 | |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
368 def read(self): |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
369 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
|
370 |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
371 self.map = {} |
| 227 | 372 self.pl = [nullid, nullid] |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
373 try: |
| 220 | 374 st = self.opener("dirstate").read() |
| 311 | 375 if not st: return |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
376 except: return |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
377 |
| 227 | 378 self.pl = [st[:20], st[20: 40]] |
| 379 | |
| 380 pos = 40 | |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
381 while pos < len(st): |
| 220 | 382 e = struct.unpack(">cllll", st[pos:pos+17]) |
| 383 l = e[4] | |
| 384 pos += 17 | |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
385 f = st[pos:pos + l] |
| 515 | 386 if '\0' in f: |
| 363 | 387 f, c = f.split('\0') |
| 388 self.copies[f] = c | |
| 220 | 389 self.map[f] = e[:4] |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
390 pos += l |
| 363 | 391 |
| 392 def copy(self, source, dest): | |
| 393 self.read() | |
| 723 | 394 self.markdirty() |
| 363 | 395 self.copies[dest] = source |
| 396 | |
| 397 def copied(self, file): | |
| 398 return self.copies.get(file, None) | |
| 515 | 399 |
|
862
d70c1c31fd45
Fix 3-way-merge of original parent, workdir and new parent.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
861
diff
changeset
|
400 def update(self, files, state, **kw): |
| 220 | 401 ''' current states: |
| 402 n normal | |
| 231 | 403 m needs merging |
| 220 | 404 r marked for removal |
| 405 a marked for addition''' | |
| 406 | |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
407 if not files: return |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
408 self.read() |
| 723 | 409 self.markdirty() |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
410 for f in files: |
| 220 | 411 if state == "r": |
| 412 self.map[f] = ('r', 0, 0, 0) | |
| 413 else: | |
| 253 | 414 s = os.stat(os.path.join(self.root, f)) |
|
862
d70c1c31fd45
Fix 3-way-merge of original parent, workdir and new parent.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
861
diff
changeset
|
415 st_size = kw.get('st_size', s.st_size) |
|
d70c1c31fd45
Fix 3-way-merge of original parent, workdir and new parent.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
861
diff
changeset
|
416 st_mtime = kw.get('st_mtime', s.st_mtime) |
|
865
2d2fee33ec68
Cleanup after previous changes:
Thomas Arendsen Hein <thomas@intevation.de>
parents:
863
diff
changeset
|
417 self.map[f] = (state, s.st_mode, st_size, st_mtime) |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
418 |
| 220 | 419 def forget(self, files): |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
420 if not files: return |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
421 self.read() |
| 723 | 422 self.markdirty() |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
423 for f in files: |
| 20 | 424 try: |
| 425 del self.map[f] | |
| 426 except KeyError: | |
| 220 | 427 self.ui.warn("not in dirstate: %s!\n" % f) |
| 20 | 428 pass |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
429 |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
430 def clear(self): |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
431 self.map = {} |
| 723 | 432 self.markdirty() |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
433 |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
434 def write(self): |
| 220 | 435 st = self.opener("dirstate", "w") |
| 227 | 436 st.write("".join(self.pl)) |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
437 for f, e in self.map.items(): |
| 363 | 438 c = self.copied(f) |
| 439 if c: | |
| 440 f = f + "\0" + c | |
| 220 | 441 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
|
442 st.write(e + f) |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
443 self.dirty = 0 |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
444 |
| 879 | 445 def filterfiles(self, files): |
| 446 ret = {} | |
| 447 unknown = [] | |
| 448 | |
| 449 for x in files: | |
| 450 if x is '.': | |
| 451 return self.map.copy() | |
| 452 if x not in self.map: | |
| 453 unknown.append(x) | |
| 454 else: | |
| 455 ret[x] = self.map[x] | |
| 456 | |
| 457 if not unknown: | |
| 458 return ret | |
| 459 | |
| 460 b = self.map.keys() | |
| 461 b.sort() | |
| 462 blen = len(b) | |
| 463 | |
| 464 for x in unknown: | |
| 465 bs = bisect.bisect(b, x) | |
| 466 if bs != 0 and b[bs-1] == x: | |
| 467 ret[x] = self.map[x] | |
| 468 continue | |
| 469 while bs < blen: | |
| 470 s = b[bs] | |
| 471 if len(s) > len(x) and s.startswith(x) and s[len(x)] == '/': | |
| 472 ret[s] = self.map[s] | |
| 473 else: | |
| 474 break | |
| 475 bs += 1 | |
| 476 return ret | |
| 477 | |
| 478 def walk(self, files = None, match = util.always, dc=None): | |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
479 self.read() |
| 879 | 480 |
| 723 | 481 # walk all files by default |
| 879 | 482 if not files: |
| 483 files = [self.root] | |
| 484 if not dc: | |
| 485 dc = self.map.copy() | |
| 486 elif not dc: | |
| 487 dc = self.filterfiles(files) | |
| 488 | |
|
821
72d9bd4841f3
Ensure that dirstate.walk only yields names once.
Bryan O'Sullivan <bos@serpentine.com>
parents:
820
diff
changeset
|
489 known = {'.hg': 1} |
|
72d9bd4841f3
Ensure that dirstate.walk only yields names once.
Bryan O'Sullivan <bos@serpentine.com>
parents:
820
diff
changeset
|
490 def seen(fn): |
|
72d9bd4841f3
Ensure that dirstate.walk only yields names once.
Bryan O'Sullivan <bos@serpentine.com>
parents:
820
diff
changeset
|
491 if fn in known: return True |
|
72d9bd4841f3
Ensure that dirstate.walk only yields names once.
Bryan O'Sullivan <bos@serpentine.com>
parents:
820
diff
changeset
|
492 known[fn] = 1 |
| 723 | 493 def traverse(): |
|
884
087771ebe2e6
Fix walk code for files that do not exist anywhere, and unhandled types.
Bryan O'Sullivan <bos@serpentine.com>
parents:
883
diff
changeset
|
494 for ff in util.unique(files): |
|
087771ebe2e6
Fix walk code for files that do not exist anywhere, and unhandled types.
Bryan O'Sullivan <bos@serpentine.com>
parents:
883
diff
changeset
|
495 f = os.path.join(self.root, ff) |
|
087771ebe2e6
Fix walk code for files that do not exist anywhere, and unhandled types.
Bryan O'Sullivan <bos@serpentine.com>
parents:
883
diff
changeset
|
496 try: |
|
087771ebe2e6
Fix walk code for files that do not exist anywhere, and unhandled types.
Bryan O'Sullivan <bos@serpentine.com>
parents:
883
diff
changeset
|
497 st = os.stat(f) |
|
087771ebe2e6
Fix walk code for files that do not exist anywhere, and unhandled types.
Bryan O'Sullivan <bos@serpentine.com>
parents:
883
diff
changeset
|
498 except OSError, inst: |
|
087771ebe2e6
Fix walk code for files that do not exist anywhere, and unhandled types.
Bryan O'Sullivan <bos@serpentine.com>
parents:
883
diff
changeset
|
499 if ff not in dc: self.ui.warn('%s: %s\n' % ( |
|
087771ebe2e6
Fix walk code for files that do not exist anywhere, and unhandled types.
Bryan O'Sullivan <bos@serpentine.com>
parents:
883
diff
changeset
|
500 util.pathto(self.getcwd(), ff), |
|
087771ebe2e6
Fix walk code for files that do not exist anywhere, and unhandled types.
Bryan O'Sullivan <bos@serpentine.com>
parents:
883
diff
changeset
|
501 inst.strerror)) |
|
087771ebe2e6
Fix walk code for files that do not exist anywhere, and unhandled types.
Bryan O'Sullivan <bos@serpentine.com>
parents:
883
diff
changeset
|
502 continue |
|
087771ebe2e6
Fix walk code for files that do not exist anywhere, and unhandled types.
Bryan O'Sullivan <bos@serpentine.com>
parents:
883
diff
changeset
|
503 if stat.S_ISDIR(st.st_mode): |
| 536 | 504 for dir, subdirs, fl in os.walk(f): |
| 505 d = dir[len(self.root) + 1:] | |
|
886
509de8ab6f31
Fix walk path handling on Windows
Bryan O'Sullivan <bos@serpentine.com>
parents:
884
diff
changeset
|
506 nd = util.normpath(d) |
|
892
f481c9b6786e
Fix bug involving "hg debugwalk -Ipattern" from repository root.
Bryan O'Sullivan <bos@serpentine.com>
parents:
886
diff
changeset
|
507 if nd == '.': nd = '' |
|
821
72d9bd4841f3
Ensure that dirstate.walk only yields names once.
Bryan O'Sullivan <bos@serpentine.com>
parents:
820
diff
changeset
|
508 if seen(nd): |
| 723 | 509 subdirs[:] = [] |
| 510 continue | |
|
669
8aa2a282eda4
.hgignore speedups patch incorporating Matt's feedback.
mwilli2@localhost.localdomain
parents:
667
diff
changeset
|
511 for sd in subdirs: |
|
820
89985a1b3427
Clean up walk and changes code to use normalised names properly.
Bryan O'Sullivan <bos@serpentine.com>
parents:
814
diff
changeset
|
512 ds = os.path.join(nd, sd +'/') |
| 723 | 513 if self.ignore(ds) or not match(ds): |
|
669
8aa2a282eda4
.hgignore speedups patch incorporating Matt's feedback.
mwilli2@localhost.localdomain
parents:
667
diff
changeset
|
514 subdirs.remove(sd) |
|
822
b678e6d4f92d
Attempt to yield names in sorted order when walking.
Bryan O'Sullivan <bos@serpentine.com>
parents:
821
diff
changeset
|
515 subdirs.sort() |
|
b678e6d4f92d
Attempt to yield names in sorted order when walking.
Bryan O'Sullivan <bos@serpentine.com>
parents:
821
diff
changeset
|
516 fl.sort() |
| 536 | 517 for fn in fl: |
| 518 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
|
519 yield 'f', fn |
|
884
087771ebe2e6
Fix walk code for files that do not exist anywhere, and unhandled types.
Bryan O'Sullivan <bos@serpentine.com>
parents:
883
diff
changeset
|
520 elif stat.S_ISREG(st.st_mode): |
|
087771ebe2e6
Fix walk code for files that do not exist anywhere, and unhandled types.
Bryan O'Sullivan <bos@serpentine.com>
parents:
883
diff
changeset
|
521 yield 'f', ff |
| 536 | 522 else: |
|
884
087771ebe2e6
Fix walk code for files that do not exist anywhere, and unhandled types.
Bryan O'Sullivan <bos@serpentine.com>
parents:
883
diff
changeset
|
523 kind = 'unknown' |
|
087771ebe2e6
Fix walk code for files that do not exist anywhere, and unhandled types.
Bryan O'Sullivan <bos@serpentine.com>
parents:
883
diff
changeset
|
524 if stat.S_ISCHR(st.st_mode): kind = 'character device' |
|
087771ebe2e6
Fix walk code for files that do not exist anywhere, and unhandled types.
Bryan O'Sullivan <bos@serpentine.com>
parents:
883
diff
changeset
|
525 elif stat.S_ISBLK(st.st_mode): kind = 'block device' |
|
087771ebe2e6
Fix walk code for files that do not exist anywhere, and unhandled types.
Bryan O'Sullivan <bos@serpentine.com>
parents:
883
diff
changeset
|
526 elif stat.S_ISFIFO(st.st_mode): kind = 'fifo' |
|
087771ebe2e6
Fix walk code for files that do not exist anywhere, and unhandled types.
Bryan O'Sullivan <bos@serpentine.com>
parents:
883
diff
changeset
|
527 elif stat.S_ISLNK(st.st_mode): kind = 'symbolic link' |
|
087771ebe2e6
Fix walk code for files that do not exist anywhere, and unhandled types.
Bryan O'Sullivan <bos@serpentine.com>
parents:
883
diff
changeset
|
528 elif stat.S_ISSOCK(st.st_mode): kind = 'socket' |
|
087771ebe2e6
Fix walk code for files that do not exist anywhere, and unhandled types.
Bryan O'Sullivan <bos@serpentine.com>
parents:
883
diff
changeset
|
529 self.ui.warn('%s: unsupported file type (type is %s)\n' % ( |
|
087771ebe2e6
Fix walk code for files that do not exist anywhere, and unhandled types.
Bryan O'Sullivan <bos@serpentine.com>
parents:
883
diff
changeset
|
530 util.pathto(self.getcwd(), ff), |
|
087771ebe2e6
Fix walk code for files that do not exist anywhere, and unhandled types.
Bryan O'Sullivan <bos@serpentine.com>
parents:
883
diff
changeset
|
531 kind)) |
| 536 | 532 |
|
822
b678e6d4f92d
Attempt to yield names in sorted order when walking.
Bryan O'Sullivan <bos@serpentine.com>
parents:
821
diff
changeset
|
533 ks = dc.keys() |
|
b678e6d4f92d
Attempt to yield names in sorted order when walking.
Bryan O'Sullivan <bos@serpentine.com>
parents:
821
diff
changeset
|
534 ks.sort() |
|
b678e6d4f92d
Attempt to yield names in sorted order when walking.
Bryan O'Sullivan <bos@serpentine.com>
parents:
821
diff
changeset
|
535 for k in ks: |
|
726
809a870a0e73
Add a source designator to the walk methods.
Bryan O'Sullivan <bos@serpentine.com>
parents:
725
diff
changeset
|
536 yield 'm', k |
|
669
8aa2a282eda4
.hgignore speedups patch incorporating Matt's feedback.
mwilli2@localhost.localdomain
parents:
667
diff
changeset
|
537 |
| 723 | 538 # yield only files that match: all in dirstate, others only if |
| 539 # not in .hgignore | |
|
669
8aa2a282eda4
.hgignore speedups patch incorporating Matt's feedback.
mwilli2@localhost.localdomain
parents:
667
diff
changeset
|
540 |
|
726
809a870a0e73
Add a source designator to the walk methods.
Bryan O'Sullivan <bos@serpentine.com>
parents:
725
diff
changeset
|
541 for src, fn in util.unique(traverse()): |
|
886
509de8ab6f31
Fix walk path handling on Windows
Bryan O'Sullivan <bos@serpentine.com>
parents:
884
diff
changeset
|
542 fn = util.normpath(fn) |
|
821
72d9bd4841f3
Ensure that dirstate.walk only yields names once.
Bryan O'Sullivan <bos@serpentine.com>
parents:
820
diff
changeset
|
543 if seen(fn): continue |
| 879 | 544 if fn not in dc and self.ignore(fn): |
| 723 | 545 continue |
| 546 if match(fn): | |
|
726
809a870a0e73
Add a source designator to the walk methods.
Bryan O'Sullivan <bos@serpentine.com>
parents:
725
diff
changeset
|
547 yield src, fn |
| 723 | 548 |
|
861
cbe5c4d016b7
dirstate.changes() now distinguishes 'hg remove'd or just deleted files.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
856
diff
changeset
|
549 def changes(self, files=None, match=util.always): |
| 723 | 550 self.read() |
| 879 | 551 if not files: |
| 552 dc = self.map.copy() | |
| 553 else: | |
| 554 dc = self.filterfiles(files) | |
|
861
cbe5c4d016b7
dirstate.changes() now distinguishes 'hg remove'd or just deleted files.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
856
diff
changeset
|
555 lookup, modified, added, unknown = [], [], [], [] |
|
cbe5c4d016b7
dirstate.changes() now distinguishes 'hg remove'd or just deleted files.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
856
diff
changeset
|
556 removed, deleted = [], [] |
| 723 | 557 |
| 879 | 558 for src, fn in self.walk(files, match, dc=dc): |
|
861
cbe5c4d016b7
dirstate.changes() now distinguishes 'hg remove'd or just deleted files.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
856
diff
changeset
|
559 try: |
|
cbe5c4d016b7
dirstate.changes() now distinguishes 'hg remove'd or just deleted files.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
856
diff
changeset
|
560 s = os.stat(os.path.join(self.root, fn)) |
|
cbe5c4d016b7
dirstate.changes() now distinguishes 'hg remove'd or just deleted files.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
856
diff
changeset
|
561 except OSError: |
|
cbe5c4d016b7
dirstate.changes() now distinguishes 'hg remove'd or just deleted files.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
856
diff
changeset
|
562 continue |
|
cbe5c4d016b7
dirstate.changes() now distinguishes 'hg remove'd or just deleted files.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
856
diff
changeset
|
563 if not stat.S_ISREG(s.st_mode): |
|
cbe5c4d016b7
dirstate.changes() now distinguishes 'hg remove'd or just deleted files.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
856
diff
changeset
|
564 continue |
|
cbe5c4d016b7
dirstate.changes() now distinguishes 'hg remove'd or just deleted files.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
856
diff
changeset
|
565 c = dc.get(fn) |
|
cbe5c4d016b7
dirstate.changes() now distinguishes 'hg remove'd or just deleted files.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
856
diff
changeset
|
566 if c: |
| 536 | 567 del dc[fn] |
| 568 if c[0] == 'm': | |
|
861
cbe5c4d016b7
dirstate.changes() now distinguishes 'hg remove'd or just deleted files.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
856
diff
changeset
|
569 modified.append(fn) |
| 536 | 570 elif c[0] == 'a': |
| 571 added.append(fn) | |
| 572 elif c[0] == 'r': | |
| 573 unknown.append(fn) | |
| 574 elif c[2] != s.st_size or (c[1] ^ s.st_mode) & 0100: | |
|
861
cbe5c4d016b7
dirstate.changes() now distinguishes 'hg remove'd or just deleted files.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
856
diff
changeset
|
575 modified.append(fn) |
|
cbe5c4d016b7
dirstate.changes() now distinguishes 'hg remove'd or just deleted files.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
856
diff
changeset
|
576 elif c[3] != s.st_mtime: |
| 536 | 577 lookup.append(fn) |
| 578 else: | |
|
861
cbe5c4d016b7
dirstate.changes() now distinguishes 'hg remove'd or just deleted files.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
856
diff
changeset
|
579 unknown.append(fn) |
| 536 | 580 |
|
861
cbe5c4d016b7
dirstate.changes() now distinguishes 'hg remove'd or just deleted files.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
856
diff
changeset
|
581 for fn, c in [(fn, c) for fn, c in dc.items() if match(fn)]: |
|
cbe5c4d016b7
dirstate.changes() now distinguishes 'hg remove'd or just deleted files.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
856
diff
changeset
|
582 if c[0] == 'r': |
|
cbe5c4d016b7
dirstate.changes() now distinguishes 'hg remove'd or just deleted files.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
856
diff
changeset
|
583 removed.append(fn) |
|
cbe5c4d016b7
dirstate.changes() now distinguishes 'hg remove'd or just deleted files.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
856
diff
changeset
|
584 else: |
|
cbe5c4d016b7
dirstate.changes() now distinguishes 'hg remove'd or just deleted files.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
856
diff
changeset
|
585 deleted.append(fn) |
|
cbe5c4d016b7
dirstate.changes() now distinguishes 'hg remove'd or just deleted files.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
856
diff
changeset
|
586 return (lookup, modified, added, removed + deleted, unknown) |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
587 |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
588 # used to avoid circular references so destructors work |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
589 def opener(base): |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
590 p = base |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
591 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
|
592 if p.startswith("http://"): |
|
15
6daf7757e92b
Fix network pull of repo files with "%" in their base64 encoding.
mpm@selenic.com
parents:
10
diff
changeset
|
593 f = os.path.join(p, urllib.quote(path)) |
| 372 | 594 return httprangereader.httprangereader(f) |
|
15
6daf7757e92b
Fix network pull of repo files with "%" in their base64 encoding.
mpm@selenic.com
parents:
10
diff
changeset
|
595 |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
596 f = os.path.join(p, path) |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
597 |
| 292 | 598 mode += "b" # for that other OS |
| 599 | |
| 600 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
|
601 try: |
|
c37c7f784ee3
Move hg from storing files in data with base64 encoding to full
mpm@selenic.com
parents:
109
diff
changeset
|
602 s = os.stat(f) |
|
c37c7f784ee3
Move hg from storing files in data with base64 encoding to full
mpm@selenic.com
parents:
109
diff
changeset
|
603 except OSError: |
|
c37c7f784ee3
Move hg from storing files in data with base64 encoding to full
mpm@selenic.com
parents:
109
diff
changeset
|
604 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
|
605 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
|
606 os.makedirs(d) |
|
c37c7f784ee3
Move hg from storing files in data with base64 encoding to full
mpm@selenic.com
parents:
109
diff
changeset
|
607 else: |
|
c37c7f784ee3
Move hg from storing files in data with base64 encoding to full
mpm@selenic.com
parents:
109
diff
changeset
|
608 if s.st_nlink > 1: |
| 417 | 609 file(f + ".tmp", "wb").write(file(f, "rb").read()) |
| 421 | 610 util.rename(f+".tmp", f) |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
611 |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
612 return file(f, mode) |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
613 |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
614 return o |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
615 |
| 499 | 616 class RepoError(Exception): pass |
| 617 | |
| 60 | 618 class localrepository: |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
619 def __init__(self, ui, path=None, create=0): |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
620 self.remote = 0 |
|
686
d7d68d27ebe5
Reapply startswith() changes that got lost with stale edit
Matt Mackall <mpm@selenic.com>
parents:
681
diff
changeset
|
621 if path and path.startswith("http://"): |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
622 self.remote = 1 |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
623 self.path = path |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
624 else: |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
625 if not path: |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
626 p = os.getcwd() |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
627 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
|
628 oldp = p |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
629 p = os.path.dirname(p) |
| 499 | 630 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
|
631 path = p |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
632 self.path = os.path.join(path, ".hg") |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
633 |
| 405 | 634 if not create and not os.path.isdir(self.path): |
| 499 | 635 raise RepoError("repository %s not found" % self.path) |
| 405 | 636 |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
637 self.root = path |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
638 self.ui = ui |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
639 |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
640 if create: |
| 515 | 641 os.mkdir(self.path) |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
642 os.mkdir(self.join("data")) |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
643 |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
644 self.opener = opener(self.path) |
|
291
2c4f2be05587
Add wopener for opening files in the working directory
mpm@selenic.com
parents:
288
diff
changeset
|
645 self.wopener = opener(self.root) |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
646 self.manifest = manifest(self.opener) |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
647 self.changelog = changelog(self.opener) |
| 343 | 648 self.tagscache = None |
| 649 self.nodetagscache = None | |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
650 |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
651 if not self.remote: |
| 244 | 652 self.dirstate = dirstate(self.opener, ui, self.root) |
| 337 | 653 try: |
| 654 self.ui.readconfig(self.opener("hgrc")) | |
| 655 except IOError: pass | |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
656 |
| 487 | 657 def hook(self, name, **args): |
| 658 s = self.ui.config("hooks", name) | |
| 659 if s: | |
| 660 self.ui.note("running hook %s: %s\n" % (name, s)) | |
| 661 old = {} | |
| 662 for k, v in args.items(): | |
| 663 k = k.upper() | |
| 664 old[k] = os.environ.get(k, None) | |
| 665 os.environ[k] = v | |
| 666 | |
| 667 r = os.system(s) | |
| 668 | |
| 669 for k, v in old.items(): | |
| 670 if v != None: | |
| 671 os.environ[k] = v | |
| 672 else: | |
| 673 del os.environ[k] | |
| 674 | |
| 675 if r: | |
| 676 self.ui.warn("abort: %s hook failed with status %d!\n" % | |
| 677 (name, r)) | |
| 678 return False | |
| 679 return True | |
| 680 | |
| 343 | 681 def tags(self): |
| 682 '''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
|
683 if not self.tagscache: |
| 343 | 684 self.tagscache = {} |
|
609
2acf1f5df2e6
[PATCH] hg tag: local tag support in file .hg/localtags
Matt Mackall <mpm@selenic.com>
parents:
608
diff
changeset
|
685 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
|
686 try: |
|
2acf1f5df2e6
[PATCH] hg tag: local tag support in file .hg/localtags
Matt Mackall <mpm@selenic.com>
parents:
608
diff
changeset
|
687 bin_n = bin(n) |
|
2acf1f5df2e6
[PATCH] hg tag: local tag support in file .hg/localtags
Matt Mackall <mpm@selenic.com>
parents:
608
diff
changeset
|
688 except TypeError: |
|
2acf1f5df2e6
[PATCH] hg tag: local tag support in file .hg/localtags
Matt Mackall <mpm@selenic.com>
parents:
608
diff
changeset
|
689 bin_n = '' |
|
2acf1f5df2e6
[PATCH] hg tag: local tag support in file .hg/localtags
Matt Mackall <mpm@selenic.com>
parents:
608
diff
changeset
|
690 self.tagscache[k.strip()] = bin_n |
| 659 | 691 |
| 67 | 692 try: |
| 254 | 693 # read each head of the tags file, ending with the tip |
| 694 # and add each tag found to the map, with "newer" ones | |
| 695 # taking precedence | |
| 67 | 696 fl = self.file(".hgtags") |
| 254 | 697 h = fl.heads() |
| 698 h.reverse() | |
| 699 for r in h: | |
| 700 for l in fl.revision(r).splitlines(): | |
| 701 if l: | |
|
385
e9e1efd5291c
Fixed problems with extra spaces around tags in .hgtags
Thomas Arendsen Hein <thomas@intevation.de>
parents:
383
diff
changeset
|
702 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
|
703 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
|
704 except KeyError: |
|
520540fd6b64
Handle errors in .hgtags or hgrc [tags] section more gracefully.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
471
diff
changeset
|
705 pass |
| 659 | 706 |
|
609
2acf1f5df2e6
[PATCH] hg tag: local tag support in file .hg/localtags
Matt Mackall <mpm@selenic.com>
parents:
608
diff
changeset
|
707 try: |
|
2acf1f5df2e6
[PATCH] hg tag: local tag support in file .hg/localtags
Matt Mackall <mpm@selenic.com>
parents:
608
diff
changeset
|
708 f = self.opener("localtags") |
|
2acf1f5df2e6
[PATCH] hg tag: local tag support in file .hg/localtags
Matt Mackall <mpm@selenic.com>
parents:
608
diff
changeset
|
709 for l in f: |
|
2acf1f5df2e6
[PATCH] hg tag: local tag support in file .hg/localtags
Matt Mackall <mpm@selenic.com>
parents:
608
diff
changeset
|
710 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
|
711 addtag(self, k, n) |
|
2acf1f5df2e6
[PATCH] hg tag: local tag support in file .hg/localtags
Matt Mackall <mpm@selenic.com>
parents:
608
diff
changeset
|
712 except IOError: |
|
2acf1f5df2e6
[PATCH] hg tag: local tag support in file .hg/localtags
Matt Mackall <mpm@selenic.com>
parents:
608
diff
changeset
|
713 pass |
| 659 | 714 |
| 343 | 715 self.tagscache['tip'] = self.changelog.tip() |
| 659 | 716 |
| 343 | 717 return self.tagscache |
| 718 | |
| 719 def tagslist(self): | |
| 720 '''return a list of tags ordered by revision''' | |
| 721 l = [] | |
|
477
520540fd6b64
Handle errors in .hgtags or hgrc [tags] section more gracefully.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
471
diff
changeset
|
722 for t, n in self.tags().items(): |
| 343 | 723 try: |
| 724 r = self.changelog.rev(n) | |
| 725 except: | |
| 726 r = -2 # sort to the beginning of the list if unknown | |
| 727 l.append((r,t,n)) | |
| 728 l.sort() | |
| 729 return [(t,n) for r,t,n in l] | |
| 730 | |
| 731 def nodetags(self, node): | |
| 732 '''return the tags associated with a node''' | |
| 733 if not self.nodetagscache: | |
| 734 self.nodetagscache = {} | |
| 735 for t,n in self.tags().items(): | |
| 736 self.nodetagscache.setdefault(n,[]).append(t) | |
| 737 return self.nodetagscache.get(node, []) | |
| 738 | |
| 739 def lookup(self, key): | |
| 67 | 740 try: |
| 343 | 741 return self.tags()[key] |
| 67 | 742 except KeyError: |
|
658
f8098ae9f5b6
Generate a friendlier except for failed lookups
Matt Mackall <mpm@selenic.com>
parents:
657
diff
changeset
|
743 try: |
|
f8098ae9f5b6
Generate a friendlier except for failed lookups
Matt Mackall <mpm@selenic.com>
parents:
657
diff
changeset
|
744 return self.changelog.lookup(key) |
|
f8098ae9f5b6
Generate a friendlier except for failed lookups
Matt Mackall <mpm@selenic.com>
parents:
657
diff
changeset
|
745 except: |
|
f8098ae9f5b6
Generate a friendlier except for failed lookups
Matt Mackall <mpm@selenic.com>
parents:
657
diff
changeset
|
746 raise RepoError("unknown revision '%s'" % key) |
| 67 | 747 |
|
634
da5378d39269
Add a repo method to report repo device
Matt Mackall <mpm@selenic.com>
parents:
627
diff
changeset
|
748 def dev(self): |
|
da5378d39269
Add a repo method to report repo device
Matt Mackall <mpm@selenic.com>
parents:
627
diff
changeset
|
749 if self.remote: return -1 |
|
da5378d39269
Add a repo method to report repo device
Matt Mackall <mpm@selenic.com>
parents:
627
diff
changeset
|
750 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
|
751 |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
752 def join(self, f): |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
753 return os.path.join(self.path, f) |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
754 |
| 244 | 755 def wjoin(self, f): |
| 756 return os.path.join(self.root, f) | |
| 757 | |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
758 def file(self, f): |
| 192 | 759 if f[0] == '/': f = f[1:] |
|
144
ea9188538222
Fix transaction handling bug by reverting fileopener change
mpm@selenic.com
parents:
140
diff
changeset
|
760 return filelog(self.opener, f) |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
761 |
| 627 | 762 def getcwd(self): |
|
870
a82eae840447
Teach walk code about absolute paths.
Bryan O'Sullivan <bos@serpentine.com>
parents:
839
diff
changeset
|
763 return self.dirstate.getcwd() |
| 627 | 764 |
|
291
2c4f2be05587
Add wopener for opening files in the working directory
mpm@selenic.com
parents:
288
diff
changeset
|
765 def wfile(self, f, mode='r'): |
|
2c4f2be05587
Add wopener for opening files in the working directory
mpm@selenic.com
parents:
288
diff
changeset
|
766 return self.wopener(f, mode) |
|
2c4f2be05587
Add wopener for opening files in the working directory
mpm@selenic.com
parents:
288
diff
changeset
|
767 |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
768 def transaction(self): |
| 251 | 769 # save dirstate for undo |
| 263 | 770 try: |
| 771 ds = self.opener("dirstate").read() | |
| 772 except IOError: | |
| 773 ds = "" | |
| 785 | 774 self.opener("journal.dirstate", "w").write(ds) |
| 515 | 775 |
| 785 | 776 def after(): |
| 777 util.rename(self.join("journal"), self.join("undo")) | |
| 778 util.rename(self.join("journal.dirstate"), | |
| 779 self.join("undo.dirstate")) | |
| 780 | |
| 781 return transaction.transaction(self.ui.warn, self.opener, | |
| 782 self.join("journal"), after) | |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
783 |
| 210 | 784 def recover(self): |
| 225 | 785 lock = self.lock() |
| 557 | 786 if os.path.exists(self.join("journal")): |
| 501 | 787 self.ui.status("rolling back interrupted transaction\n") |
| 557 | 788 return transaction.rollback(self.opener, self.join("journal")) |
| 210 | 789 else: |
| 790 self.ui.warn("no interrupted transaction available\n") | |
| 791 | |
| 792 def undo(self): | |
| 225 | 793 lock = self.lock() |
| 210 | 794 if os.path.exists(self.join("undo")): |
| 501 | 795 self.ui.status("rolling back last transaction\n") |
| 262 | 796 transaction.rollback(self.opener, self.join("undo")) |
| 251 | 797 self.dirstate = None |
| 421 | 798 util.rename(self.join("undo.dirstate"), self.join("dirstate")) |
| 251 | 799 self.dirstate = dirstate(self.opener, self.ui, self.root) |
| 163 | 800 else: |
| 210 | 801 self.ui.warn("no undo information available\n") |
| 162 | 802 |
| 161 | 803 def lock(self, wait = 1): |
| 804 try: | |
| 805 return lock.lock(self.join("lock"), 0) | |
| 806 except lock.LockHeld, inst: | |
| 807 if wait: | |
| 808 self.ui.warn("waiting for lock held by %s\n" % inst.args[0]) | |
| 809 return lock.lock(self.join("lock"), wait) | |
| 810 raise inst | |
| 811 | |
| 203 | 812 def rawcommit(self, files, text, user, date, p1=None, p2=None): |
| 442 | 813 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
|
814 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
|
815 p2 = p2 or self.dirstate.parents()[1] or nullid |
| 302 | 816 c1 = self.changelog.read(p1) |
| 817 c2 = self.changelog.read(p2) | |
| 818 m1 = self.manifest.read(c1[0]) | |
| 819 mf1 = self.manifest.readflags(c1[0]) | |
| 820 m2 = self.manifest.read(c2[0]) | |
| 821 | |
| 442 | 822 if orig_parent == p1: |
| 823 update_dirstate = 1 | |
| 824 else: | |
| 825 update_dirstate = 0 | |
| 826 | |
| 203 | 827 tr = self.transaction() |
| 302 | 828 mm = m1.copy() |
| 829 mfm = mf1.copy() | |
| 203 | 830 linkrev = self.changelog.count() |
| 831 for f in files: | |
| 832 try: | |
| 302 | 833 t = self.wfile(f).read() |
| 441 | 834 tm = util.is_exec(self.wjoin(f), mfm.get(f, False)) |
| 302 | 835 r = self.file(f) |
| 836 mfm[f] = tm | |
| 360 | 837 mm[f] = r.add(t, {}, tr, linkrev, |
| 302 | 838 m1.get(f, nullid), m2.get(f, nullid)) |
| 442 | 839 if update_dirstate: |
| 840 self.dirstate.update([f], "n") | |
| 203 | 841 except IOError: |
|
314
3402cb9a4c06
More tweaking to rawcommit for repo conversion
mpm@selenic.com
parents:
313
diff
changeset
|
842 try: |
|
3402cb9a4c06
More tweaking to rawcommit for repo conversion
mpm@selenic.com
parents:
313
diff
changeset
|
843 del mm[f] |
|
3402cb9a4c06
More tweaking to rawcommit for repo conversion
mpm@selenic.com
parents:
313
diff
changeset
|
844 del mfm[f] |
| 442 | 845 if update_dirstate: |
| 846 self.dirstate.forget([f]) | |
|
314
3402cb9a4c06
More tweaking to rawcommit for repo conversion
mpm@selenic.com
parents:
313
diff
changeset
|
847 except: |
|
3402cb9a4c06
More tweaking to rawcommit for repo conversion
mpm@selenic.com
parents:
313
diff
changeset
|
848 # deleted from p2? |
|
3402cb9a4c06
More tweaking to rawcommit for repo conversion
mpm@selenic.com
parents:
313
diff
changeset
|
849 pass |
| 203 | 850 |
| 302 | 851 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
|
852 user = user or self.ui.username() |
| 302 | 853 n = self.changelog.add(mnode, files, text, tr, p1, p2, user, date) |
| 203 | 854 tr.close() |
| 442 | 855 if update_dirstate: |
| 856 self.dirstate.setparents(n, nullid) | |
| 203 | 857 |
|
813
80fd2958235a
Adapt commit to use file matching code.
Bryan O'Sullivan <bos@serpentine.com>
parents:
786
diff
changeset
|
858 def commit(self, files = None, text = "", user = None, date = None, |
|
900
ba8cf1f2210c
Add force option to repo.commit, allowing commits where no files change
mason@suse.com
parents:
898
diff
changeset
|
859 match = util.always, force=False): |
| 220 | 860 commit = [] |
| 861 remove = [] | |
| 862 if files: | |
| 863 for f in files: | |
| 864 s = self.dirstate.state(f) | |
| 244 | 865 if s in 'nmai': |
| 220 | 866 commit.append(f) |
| 867 elif s == 'r': | |
| 868 remove.append(f) | |
| 869 else: | |
| 244 | 870 self.ui.warn("%s not tracked!\n" % f) |
| 220 | 871 else: |
|
813
80fd2958235a
Adapt commit to use file matching code.
Bryan O'Sullivan <bos@serpentine.com>
parents:
786
diff
changeset
|
872 (c, a, d, u) = self.changes(match = match) |
| 220 | 873 commit = c + a |
| 874 remove = d | |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
875 |
|
900
ba8cf1f2210c
Add force option to repo.commit, allowing commits where no files change
mason@suse.com
parents:
898
diff
changeset
|
876 if not commit and not remove and not force: |
| 151 | 877 self.ui.status("nothing changed\n") |
|
901
120cba94d5aa
Change repo.comit to return None on error or the new revision number on
mason@suse.com
parents:
900
diff
changeset
|
878 return None |
| 151 | 879 |
| 487 | 880 if not self.hook("precommit"): |
|
901
120cba94d5aa
Change repo.comit to return None on error or the new revision number on
mason@suse.com
parents:
900
diff
changeset
|
881 return None |
| 487 | 882 |
| 229 | 883 p1, p2 = self.dirstate.parents() |
| 884 c1 = self.changelog.read(p1) | |
| 885 c2 = self.changelog.read(p2) | |
| 886 m1 = self.manifest.read(c1[0]) | |
| 276 | 887 mf1 = self.manifest.readflags(c1[0]) |
| 229 | 888 m2 = self.manifest.read(c2[0]) |
| 225 | 889 lock = self.lock() |
| 151 | 890 tr = self.transaction() |
| 891 | |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
892 # check in files |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
893 new = {} |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
894 linkrev = self.changelog.count() |
| 220 | 895 commit.sort() |
| 896 for f in commit: | |
| 83 | 897 self.ui.note(f + "\n") |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
898 try: |
| 441 | 899 mf1[f] = util.is_exec(self.wjoin(f), mf1.get(f, False)) |
| 418 | 900 t = self.wfile(f).read() |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
901 except IOError: |
|
667
31a9aa890016
A number of minor fixes to problems that pychecker found.
mark.williamson@cl.cam.ac.uk
parents:
660
diff
changeset
|
902 self.ui.warn("trouble committing %s!\n" % f) |
| 220 | 903 raise |
| 904 | |
| 363 | 905 meta = {} |
| 906 cp = self.dirstate.copied(f) | |
| 907 if cp: | |
| 908 meta["copy"] = cp | |
| 909 meta["copyrev"] = hex(m1.get(cp, m2.get(cp, nullid))) | |
| 575 | 910 self.ui.debug(" %s: copy %s:%s\n" % (f, cp, meta["copyrev"])) |
| 363 | 911 |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
912 r = self.file(f) |
| 229 | 913 fp1 = m1.get(f, nullid) |
| 914 fp2 = m2.get(f, nullid) | |
| 363 | 915 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
|
916 |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
917 # update manifest |
| 229 | 918 m1.update(new) |
|
416
5e9e8b8d2629
[PATCH] Removal of a file added by merging branches
mpm@selenic.com
parents:
415
diff
changeset
|
919 for f in remove: |
|
5e9e8b8d2629
[PATCH] Removal of a file added by merging branches
mpm@selenic.com
parents:
415
diff
changeset
|
920 if f in m1: |
|
5e9e8b8d2629
[PATCH] Removal of a file added by merging branches
mpm@selenic.com
parents:
415
diff
changeset
|
921 del m1[f] |
| 741 | 922 mn = self.manifest.add(m1, mf1, tr, linkrev, c1[0], c2[0], |
| 923 (new, remove)) | |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
924 |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
925 # add changeset |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
926 new = new.keys() |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
927 new.sort() |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
928 |
| 288 | 929 if not text: |
| 930 edittext = "\n" + "HG: manifest hash %s\n" % hex(mn) | |
| 931 edittext += "".join(["HG: changed %s\n" % f for f in new]) | |
| 932 edittext += "".join(["HG: removed %s\n" % f for f in remove]) | |
| 933 edittext = self.ui.edit(edittext) | |
| 934 if not edittext.rstrip(): | |
|
901
120cba94d5aa
Change repo.comit to return None on error or the new revision number on
mason@suse.com
parents:
900
diff
changeset
|
935 return None |
| 288 | 936 text = edittext |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
937 |
|
608
d2994b5298fb
Add username/merge/editor to .hgrc
Matt Mackall <mpm@selenic.com>
parents:
588
diff
changeset
|
938 user = user or self.ui.username() |
| 317 | 939 n = self.changelog.add(mn, new, text, tr, p1, p2, user, date) |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
940 tr.close() |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
941 |
| 229 | 942 self.dirstate.setparents(n) |
| 220 | 943 self.dirstate.update(new, "n") |
| 944 self.dirstate.forget(remove) | |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
945 |
|
660
2c83350784c3
Move commit hook after commit completes
Matt Mackall <mpm@selenic.com>
parents:
659
diff
changeset
|
946 if not self.hook("commit", node=hex(n)): |
|
901
120cba94d5aa
Change repo.comit to return None on error or the new revision number on
mason@suse.com
parents:
900
diff
changeset
|
947 return None |
|
120cba94d5aa
Change repo.comit to return None on error or the new revision number on
mason@suse.com
parents:
900
diff
changeset
|
948 return n |
|
660
2c83350784c3
Move commit hook after commit completes
Matt Mackall <mpm@selenic.com>
parents:
659
diff
changeset
|
949 |
|
724
1c0c413cccdd
Get add and locate to use new repo and dirstate walk code.
Bryan O'Sullivan <bos@serpentine.com>
parents:
723
diff
changeset
|
950 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
|
951 if node: |
|
726
809a870a0e73
Add a source designator to the walk methods.
Bryan O'Sullivan <bos@serpentine.com>
parents:
725
diff
changeset
|
952 for fn in self.manifest.read(self.changelog.read(node)[0]): |
|
820
89985a1b3427
Clean up walk and changes code to use normalised names properly.
Bryan O'Sullivan <bos@serpentine.com>
parents:
814
diff
changeset
|
953 if match(fn): 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
|
954 else: |
|
726
809a870a0e73
Add a source designator to the walk methods.
Bryan O'Sullivan <bos@serpentine.com>
parents:
725
diff
changeset
|
955 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
|
956 yield src, fn |
| 723 | 957 |
|
724
1c0c413cccdd
Get add and locate to use new repo and dirstate walk code.
Bryan O'Sullivan <bos@serpentine.com>
parents:
723
diff
changeset
|
958 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
|
959 match = util.always): |
| 566 | 960 mf2, u = None, [] |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
961 |
| 536 | 962 def fcmp(fn, mf): |
|
291
2c4f2be05587
Add wopener for opening files in the working directory
mpm@selenic.com
parents:
288
diff
changeset
|
963 t1 = self.wfile(fn).read() |
| 29 | 964 t2 = self.file(fn).revision(mf[fn]) |
| 965 return cmp(t1, t2) | |
| 966 | |
| 723 | 967 def mfmatches(node): |
| 968 mf = dict(self.manifest.read(node)) | |
| 969 for fn in mf.keys(): | |
| 970 if not match(fn): | |
| 971 del mf[fn] | |
| 972 return mf | |
| 741 | 973 |
| 536 | 974 # are we comparing the working directory? |
| 561 | 975 if not node2: |
| 723 | 976 l, c, a, d, u = self.dirstate.changes(files, match) |
| 536 | 977 |
| 978 # are we comparing working dir against its parent? | |
| 561 | 979 if not node1: |
| 536 | 980 if l: |
| 981 # do a full compare of any files that might have changed | |
| 982 change = self.changelog.read(self.dirstate.parents()[0]) | |
| 723 | 983 mf2 = mfmatches(change[0]) |
| 548 | 984 for f in l: |
| 561 | 985 if fcmp(f, mf2): |
| 536 | 986 c.append(f) |
| 561 | 987 |
| 988 for l in c, a, d, u: | |
| 989 l.sort() | |
| 990 | |
| 536 | 991 return (c, a, d, u) |
| 515 | 992 |
| 536 | 993 # are we comparing working dir against non-tip? |
| 994 # generate a pseudo-manifest for the working dir | |
| 561 | 995 if not node2: |
| 996 if not mf2: | |
| 536 | 997 change = self.changelog.read(self.dirstate.parents()[0]) |
| 723 | 998 mf2 = mfmatches(change[0]) |
| 536 | 999 for f in a + c + l: |
| 561 | 1000 mf2[f] = "" |
| 536 | 1001 for f in d: |
| 561 | 1002 if f in mf2: del mf2[f] |
| 536 | 1003 else: |
| 561 | 1004 change = self.changelog.read(node2) |
| 723 | 1005 mf2 = mfmatches(change[0]) |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
1006 |
| 566 | 1007 # flush lists from dirstate before comparing manifests |
| 1008 c, a = [], [] | |
| 1009 | |
| 561 | 1010 change = self.changelog.read(node1) |
| 723 | 1011 mf1 = mfmatches(change[0]) |
| 32 | 1012 |
| 1013 for fn in mf2: | |
| 1014 if mf1.has_key(fn): | |
| 1015 if mf1[fn] != mf2[fn]: | |
| 561 | 1016 if mf2[fn] != "" or fcmp(fn, mf1): |
| 536 | 1017 c.append(fn) |
| 32 | 1018 del mf1[fn] |
| 1019 else: | |
| 536 | 1020 a.append(fn) |
| 515 | 1021 |
| 536 | 1022 d = mf1.keys() |
| 561 | 1023 |
| 1024 for l in c, a, d, u: | |
| 1025 l.sort() | |
| 515 | 1026 |
| 536 | 1027 return (c, a, d, u) |
| 32 | 1028 |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
1029 def add(self, list): |
| 220 | 1030 for f in list: |
| 244 | 1031 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
|
1032 if not os.path.exists(p): |
| 659 | 1033 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
|
1034 elif not os.path.isfile(p): |
| 741 | 1035 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
|
1036 elif self.dirstate.state(f) in 'an': |
| 220 | 1037 self.ui.warn("%s already tracked!\n" % f) |
| 1038 else: | |
| 1039 self.dirstate.update([f], "a") | |
| 1040 | |
| 1041 def forget(self, list): | |
| 1042 for f in list: | |
| 1043 if self.dirstate.state(f) not in 'ai': | |
| 1044 self.ui.warn("%s not added!\n" % f) | |
| 1045 else: | |
| 1046 self.dirstate.forget([f]) | |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
1047 |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
1048 def remove(self, list): |
|
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
1049 for f in list: |
| 244 | 1050 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
|
1051 if os.path.exists(p): |
| 220 | 1052 self.ui.warn("%s still exists!\n" % f) |
| 402 | 1053 elif self.dirstate.state(f) == 'a': |
| 1054 self.ui.warn("%s never committed!\n" % f) | |
|
657
22bc6fb9aefc
dirstate.forget() takes a list
Matt Mackall <mpm@selenic.com>
parents:
656
diff
changeset
|
1055 self.dirstate.forget([f]) |
| 220 | 1056 elif f not in self.dirstate: |
| 1057 self.ui.warn("%s not tracked!\n" % f) | |
| 1058 else: | |
| 1059 self.dirstate.update([f], "r") | |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
1060 |
| 363 | 1061 def copy(self, source, dest): |
| 1062 p = self.wjoin(dest) | |
| 781 | 1063 if not os.path.exists(p): |
| 363 | 1064 self.ui.warn("%s does not exist!\n" % dest) |
| 781 | 1065 elif not os.path.isfile(p): |
| 659 | 1066 self.ui.warn("copy failed: %s is not a file\n" % dest) |
| 363 | 1067 else: |
| 1068 if self.dirstate.state(dest) == '?': | |
| 1069 self.dirstate.update([dest], "a") | |
| 1070 self.dirstate.copy(source, dest) | |
| 1071 | |
| 222 | 1072 def heads(self): |
| 1073 return self.changelog.heads() | |
| 1074 | |
| 898 | 1075 # branchlookup returns a dict giving a list of branches for |
| 1076 # each head. A branch is defined as the tag of a node or | |
| 1077 # the branch of the node's parents. If a node has multiple | |
| 1078 # branch tags, tags are eliminated if they are visible from other | |
| 1079 # branch tags. | |
| 1080 # | |
| 1081 # So, for this graph: a->b->c->d->e | |
| 1082 # \ / | |
| 1083 # aa -----/ | |
| 1084 # a has tag 2.6.12 | |
| 1085 # d has tag 2.6.13 | |
| 1086 # e would have branch tags for 2.6.12 and 2.6.13. Because the node | |
| 1087 # for 2.6.12 can be reached from the node 2.6.13, that is eliminated | |
| 1088 # from the list. | |
| 1089 # | |
| 1090 # It is possible that more than one head will have the same branch tag. | |
| 1091 # callers need to check the result for multiple heads under the same | |
| 1092 # branch tag if that is a problem for them (ie checkout of a specific | |
| 1093 # branch). | |
| 1094 # | |
| 1095 # passing in a specific branch will limit the depth of the search | |
| 1096 # through the parents. It won't limit the branches returned in the | |
| 1097 # result though. | |
| 1098 def branchlookup(self, heads=None, branch=None): | |
| 1099 if not heads: | |
| 1100 heads = self.heads() | |
| 1101 headt = [ h for h in heads ] | |
| 1102 chlog = self.changelog | |
| 1103 branches = {} | |
| 1104 merges = [] | |
| 1105 seenmerge = {} | |
| 1106 | |
| 1107 # traverse the tree once for each head, recording in the branches | |
| 1108 # dict which tags are visible from this head. The branches | |
| 1109 # dict also records which tags are visible from each tag | |
| 1110 # while we traverse. | |
| 1111 while headt or merges: | |
| 1112 if merges: | |
| 1113 n, found = merges.pop() | |
| 1114 visit = [n] | |
| 1115 else: | |
| 1116 h = headt.pop() | |
| 1117 visit = [h] | |
| 1118 found = [h] | |
| 1119 seen = {} | |
| 1120 while visit: | |
| 1121 n = visit.pop() | |
| 1122 if n in seen: | |
| 1123 continue | |
| 1124 pp = chlog.parents(n) | |
| 1125 tags = self.nodetags(n) | |
| 1126 if tags: | |
| 1127 for x in tags: | |
| 1128 if x == 'tip': | |
| 1129 continue | |
| 1130 for f in found: | |
| 1131 branches.setdefault(f, {})[n] = 1 | |
| 1132 branches.setdefault(n, {})[n] = 1 | |
| 1133 break | |
| 1134 if n not in found: | |
| 1135 found.append(n) | |
| 1136 if branch in tags: | |
| 1137 continue | |
| 1138 seen[n] = 1 | |
| 1139 if pp[1] != nullid and n not in seenmerge: | |
| 1140 merges.append((pp[1], [x for x in found])) | |
| 1141 seenmerge[n] = 1 | |
| 1142 if pp[0] != nullid: | |
| 1143 visit.append(pp[0]) | |
| 1144 # traverse the branches dict, eliminating branch tags from each | |
| 1145 # head that are visible from another branch tag for that head. | |
| 1146 out = {} | |
| 1147 viscache = {} | |
| 1148 for h in heads: | |
| 1149 def visible(node): | |
| 1150 if node in viscache: | |
| 1151 return viscache[node] | |
| 1152 ret = {} | |
| 1153 visit = [node] | |
| 1154 while visit: | |
| 1155 x = visit.pop() | |
| 1156 if x in viscache: | |
| 1157 ret.update(viscache[x]) | |
| 1158 elif x not in ret: | |
| 1159 ret[x] = 1 | |
| 1160 if x in branches: | |
| 1161 visit[len(visit):] = branches[x].keys() | |
| 1162 viscache[node] = ret | |
| 1163 return ret | |
| 1164 if h not in branches: | |
| 1165 continue | |
| 1166 # O(n^2), but somewhat limited. This only searches the | |
| 1167 # tags visible from a specific head, not all the tags in the | |
| 1168 # whole repo. | |
| 1169 for b in branches[h]: | |
| 1170 vis = False | |
| 1171 for bb in branches[h].keys(): | |
| 1172 if b != bb: | |
| 1173 if b in visible(bb): | |
| 1174 vis = True | |
| 1175 break | |
| 1176 if not vis: | |
| 1177 l = out.setdefault(h, []) | |
| 1178 l[len(l):] = self.nodetags(b) | |
| 1179 return out | |
| 1180 | |
|
56
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
1181 def branches(self, nodes): |
|
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
1182 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
|
1183 b = [] |
|
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
1184 for n in nodes: |
|
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
1185 t = n |
|
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
1186 while n: |
|
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
1187 p = self.changelog.parents(n) |
|
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
1188 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
|
1189 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
|
1190 break |
|
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
1191 n = p[0] |
|
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
1192 return b |
|
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
1193 |
|
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
1194 def between(self, pairs): |
|
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
1195 r = [] |
|
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
1196 |
|
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
1197 for top, bottom in pairs: |
|
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
1198 n, l, i = top, [], 0 |
|
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
1199 f = 1 |
|
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
1200 |
|
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
1201 while n != bottom: |
|
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
1202 p = self.changelog.parents(n)[0] |
|
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
1203 if i == f: |
| 575 | 1204 l.append(n) |
|
56
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
1205 f = f * 2 |
|
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
1206 n = p |
|
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
1207 i += 1 |
|
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
1208 |
|
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
1209 r.append(l) |
|
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
1210 |
|
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
1211 return r |
|
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
1212 |
|
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
1213 def newer(self, nodes): |
|
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
1214 m = {} |
|
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
1215 nl = [] |
| 94 | 1216 pm = {} |
|
56
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
1217 cl = self.changelog |
|
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
1218 t = l = cl.count() |
| 94 | 1219 |
| 1220 # find the lowest numbered node | |
|
56
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
1221 for n in nodes: |
|
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
1222 l = min(l, cl.rev(n)) |
| 94 | 1223 m[n] = 1 |
| 46 | 1224 |
|
56
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
1225 for i in xrange(l, t): |
|
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
1226 n = cl.node(i) |
| 94 | 1227 if n in m: # explicitly listed |
| 1228 pm[n] = 1 | |
| 1229 nl.append(n) | |
| 1230 continue | |
|
56
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
1231 for p in cl.parents(n): |
| 94 | 1232 if p in pm: # parent listed |
| 1233 pm[n] = 1 | |
|
56
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
1234 nl.append(n) |
| 94 | 1235 break |
|
56
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
1236 |
|
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
1237 return nl |
|
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
1238 |
|
816
8674b7803714
Warn on pushing unsynced repo or adding new heads
mpm@selenic.com
parents:
814
diff
changeset
|
1239 def findincoming(self, remote, base=None, heads=None): |
|
65
d40cc5aacc31
Fix up a bunch of bugs in the new merge code
mpm@selenic.com
parents:
64
diff
changeset
|
1240 m = self.changelog.nodemap |
|
56
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
1241 search = [] |
|
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
1242 fetch = [] |
|
148
c32286d0a665
Improve pruning of branches in outstanding changeset algorithm
mpm@selenic.com
parents:
146
diff
changeset
|
1243 seen = {} |
|
c32286d0a665
Improve pruning of branches in outstanding changeset algorithm
mpm@selenic.com
parents:
146
diff
changeset
|
1244 seenbranch = {} |
|
816
8674b7803714
Warn on pushing unsynced repo or adding new heads
mpm@selenic.com
parents:
814
diff
changeset
|
1245 if base == None: |
|
8674b7803714
Warn on pushing unsynced repo or adding new heads
mpm@selenic.com
parents:
814
diff
changeset
|
1246 base = {} |
| 192 | 1247 |
|
636
ac0ec421e3a5
Move the empty changeset detection out of findincoming to pull
Matt Mackall <mpm@selenic.com>
parents:
635
diff
changeset
|
1248 # 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
|
1249 # and start by examining the heads |
| 222 | 1250 self.ui.status("searching for changes\n") |
|
816
8674b7803714
Warn on pushing unsynced repo or adding new heads
mpm@selenic.com
parents:
814
diff
changeset
|
1251 |
|
8674b7803714
Warn on pushing unsynced repo or adding new heads
mpm@selenic.com
parents:
814
diff
changeset
|
1252 if not heads: |
|
8674b7803714
Warn on pushing unsynced repo or adding new heads
mpm@selenic.com
parents:
814
diff
changeset
|
1253 heads = remote.heads() |
|
8674b7803714
Warn on pushing unsynced repo or adding new heads
mpm@selenic.com
parents:
814
diff
changeset
|
1254 |
| 222 | 1255 unknown = [] |
| 1256 for h in heads: | |
| 1257 if h not in m: | |
| 1258 unknown.append(h) | |
|
621
004e811f7706
Add a function to calculate the outgoing changegroup
Matt Mackall <mpm@selenic.com>
parents:
616
diff
changeset
|
1259 else: |
|
004e811f7706
Add a function to calculate the outgoing changegroup
Matt Mackall <mpm@selenic.com>
parents:
616
diff
changeset
|
1260 base[h] = 1 |
| 46 | 1261 |
| 222 | 1262 if not unknown: |
| 60 | 1263 return None |
| 324 | 1264 |
| 1265 rep = {} | |
| 1266 reqcnt = 0 | |
| 515 | 1267 |
|
579
ffeb2c3a1966
Actually warn on pulling from an unrelated repository
mpm@selenic.com
parents:
578
diff
changeset
|
1268 # search through remote branches |
|
ffeb2c3a1966
Actually warn on pulling from an unrelated repository
mpm@selenic.com
parents:
578
diff
changeset
|
1269 # 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
|
1270 # head, root, first parent, second parent |
|
ffeb2c3a1966
Actually warn on pulling from an unrelated repository
mpm@selenic.com
parents:
578
diff
changeset
|
1271 # (a branch always has two parents (or none) by definition) |
| 222 | 1272 unknown = remote.branches(unknown) |
|
56
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
1273 while unknown: |
| 324 | 1274 r = [] |
| 1275 while unknown: | |
| 1276 n = unknown.pop(0) | |
| 1277 if n[0] in seen: | |
| 1278 continue | |
|
148
c32286d0a665
Improve pruning of branches in outstanding changeset algorithm
mpm@selenic.com
parents:
146
diff
changeset
|
1279 |
| 324 | 1280 self.ui.debug("examining %s:%s\n" % (short(n[0]), short(n[1]))) |
| 1281 if n[0] == nullid: | |
| 1282 break | |
| 328 | 1283 if n in seenbranch: |
| 324 | 1284 self.ui.debug("branch already found\n") |
| 1285 continue | |
| 1286 if n[1] and n[1] in m: # do we know the base? | |
| 1287 self.ui.debug("found incomplete branch %s:%s\n" | |
| 1288 % (short(n[0]), short(n[1]))) | |
| 1289 search.append(n) # schedule branch range for scanning | |
| 328 | 1290 seenbranch[n] = 1 |
| 324 | 1291 else: |
| 1292 if n[1] not in seen and n[1] not in fetch: | |
| 1293 if n[2] in m and n[3] in m: | |
| 1294 self.ui.debug("found new changeset %s\n" % | |
| 1295 short(n[1])) | |
| 1296 fetch.append(n[1]) # earliest unknown | |
|
579
ffeb2c3a1966
Actually warn on pulling from an unrelated repository
mpm@selenic.com
parents:
578
diff
changeset
|
1297 base[n[2]] = 1 # latest known |
| 324 | 1298 continue |
| 1299 | |
| 1300 for a in n[2:4]: | |
| 1301 if a not in rep: | |
| 1302 r.append(a) | |
| 1303 rep[a] = 1 | |
| 1304 | |
| 328 | 1305 seen[n[0]] = 1 |
| 1306 | |
| 324 | 1307 if r: |
| 1308 reqcnt += 1 | |
| 1309 self.ui.debug("request %d: %s\n" % | |
| 1310 (reqcnt, " ".join(map(short, r)))) | |
| 1311 for p in range(0, len(r), 10): | |
| 1312 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
|
1313 self.ui.debug("received %s:%s\n" % |
|
c32286d0a665
Improve pruning of branches in outstanding changeset algorithm
mpm@selenic.com
parents:
146
diff
changeset
|
1314 (short(b[0]), short(b[1]))) |
|
c32286d0a665
Improve pruning of branches in outstanding changeset algorithm
mpm@selenic.com
parents:
146
diff
changeset
|
1315 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
|
1316 unknown.append(b) |
| 515 | 1317 |
|
579
ffeb2c3a1966
Actually warn on pulling from an unrelated repository
mpm@selenic.com
parents:
578
diff
changeset
|
1318 # 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
|
1319 while search: |
|
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
1320 n = search.pop(0) |
| 324 | 1321 reqcnt += 1 |
|
56
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
1322 l = remote.between([(n[0], n[1])])[0] |
| 328 | 1323 l.append(n[1]) |
|
56
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
1324 p = n[0] |
|
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
1325 f = 1 |
| 328 | 1326 for i in l: |
| 1327 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
|
1328 if i in m: |
| 85 | 1329 if f <= 2: |
| 83 | 1330 self.ui.debug("found new branch changeset %s\n" % |
| 1331 short(p)) | |
|
56
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
1332 fetch.append(p) |
|
579
ffeb2c3a1966
Actually warn on pulling from an unrelated repository
mpm@selenic.com
parents:
578
diff
changeset
|
1333 base[i] = 1 |
|
56
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
1334 else: |
| 83 | 1335 self.ui.debug("narrowed branch search to %s:%s\n" |
| 1336 % (short(p), short(i))) | |
|
56
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
1337 search.append((p, i)) |
|
65
d40cc5aacc31
Fix up a bunch of bugs in the new merge code
mpm@selenic.com
parents:
64
diff
changeset
|
1338 break |
|
56
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
1339 p, f = i, f * 2 |
|
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
1340 |
|
579
ffeb2c3a1966
Actually warn on pulling from an unrelated repository
mpm@selenic.com
parents:
578
diff
changeset
|
1341 # 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
|
1342 for f in fetch: |
|
d40cc5aacc31
Fix up a bunch of bugs in the new merge code
mpm@selenic.com
parents:
64
diff
changeset
|
1343 if f in m: |
| 499 | 1344 raise RepoError("already have changeset " + short(f[:4])) |
| 83 | 1345 |
|
579
ffeb2c3a1966
Actually warn on pulling from an unrelated repository
mpm@selenic.com
parents:
578
diff
changeset
|
1346 if base.keys() == [nullid]: |
|
514
874e577e332e
change unrelated repository error to a warning
mpm@selenic.com
parents:
511
diff
changeset
|
1347 self.ui.warn("warning: pulling from an unrelated repository!\n") |
| 511 | 1348 |
| 94 | 1349 self.ui.note("adding new changesets starting at " + |
| 83 | 1350 " ".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
|
1351 |
| 324 | 1352 self.ui.debug("%d total queries\n" % reqcnt) |
| 1353 | |
| 516 | 1354 return fetch |
| 1355 | |
|
816
8674b7803714
Warn on pushing unsynced repo or adding new heads
mpm@selenic.com
parents:
814
diff
changeset
|
1356 def findoutgoing(self, remote, base=None, heads=None): |
|
8674b7803714
Warn on pushing unsynced repo or adding new heads
mpm@selenic.com
parents:
814
diff
changeset
|
1357 if base == None: |
|
8674b7803714
Warn on pushing unsynced repo or adding new heads
mpm@selenic.com
parents:
814
diff
changeset
|
1358 base = {} |
|
8674b7803714
Warn on pushing unsynced repo or adding new heads
mpm@selenic.com
parents:
814
diff
changeset
|
1359 self.findincoming(remote, base, heads) |
|
8674b7803714
Warn on pushing unsynced repo or adding new heads
mpm@selenic.com
parents:
814
diff
changeset
|
1360 |
|
621
004e811f7706
Add a function to calculate the outgoing changegroup
Matt Mackall <mpm@selenic.com>
parents:
616
diff
changeset
|
1361 remain = dict.fromkeys(self.changelog.nodemap) |
|
004e811f7706
Add a function to calculate the outgoing changegroup
Matt Mackall <mpm@selenic.com>
parents:
616
diff
changeset
|
1362 |
|
004e811f7706
Add a function to calculate the outgoing changegroup
Matt Mackall <mpm@selenic.com>
parents:
616
diff
changeset
|
1363 # 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
|
1364 del remain[nullid] |
|
621
004e811f7706
Add a function to calculate the outgoing changegroup
Matt Mackall <mpm@selenic.com>
parents:
616
diff
changeset
|
1365 remove = base.keys() |
|
004e811f7706
Add a function to calculate the outgoing changegroup
Matt Mackall <mpm@selenic.com>
parents:
616
diff
changeset
|
1366 while remove: |
|
004e811f7706
Add a function to calculate the outgoing changegroup
Matt Mackall <mpm@selenic.com>
parents:
616
diff
changeset
|
1367 n = remove.pop(0) |
|
004e811f7706
Add a function to calculate the outgoing changegroup
Matt Mackall <mpm@selenic.com>
parents:
616
diff
changeset
|
1368 if n in remain: |
|
004e811f7706
Add a function to calculate the outgoing changegroup
Matt Mackall <mpm@selenic.com>
parents:
616
diff
changeset
|
1369 del remain[n] |
|
004e811f7706
Add a function to calculate the outgoing changegroup
Matt Mackall <mpm@selenic.com>
parents:
616
diff
changeset
|
1370 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
|
1371 remove.append(p) |
|
621
004e811f7706
Add a function to calculate the outgoing changegroup
Matt Mackall <mpm@selenic.com>
parents:
616
diff
changeset
|
1372 |
|
004e811f7706
Add a function to calculate the outgoing changegroup
Matt Mackall <mpm@selenic.com>
parents:
616
diff
changeset
|
1373 # 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
|
1374 subset = [] |
|
004e811f7706
Add a function to calculate the outgoing changegroup
Matt Mackall <mpm@selenic.com>
parents:
616
diff
changeset
|
1375 for n in remain: |
|
004e811f7706
Add a function to calculate the outgoing changegroup
Matt Mackall <mpm@selenic.com>
parents:
616
diff
changeset
|
1376 p1, p2 = self.changelog.parents(n) |
|
004e811f7706
Add a function to calculate the outgoing changegroup
Matt Mackall <mpm@selenic.com>
parents:
616
diff
changeset
|
1377 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
|
1378 subset.append(n) |
|
004e811f7706
Add a function to calculate the outgoing changegroup
Matt Mackall <mpm@selenic.com>
parents:
616
diff
changeset
|
1379 |
|
004e811f7706
Add a function to calculate the outgoing changegroup
Matt Mackall <mpm@selenic.com>
parents:
616
diff
changeset
|
1380 # 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
|
1381 return subset |
|
004e811f7706
Add a function to calculate the outgoing changegroup
Matt Mackall <mpm@selenic.com>
parents:
616
diff
changeset
|
1382 |
|
622
e9fe5d5e67f7
Add generic repo commands for pull and push
Matt Mackall <mpm@selenic.com>
parents:
621
diff
changeset
|
1383 def pull(self, remote): |
|
e9fe5d5e67f7
Add generic repo commands for pull and push
Matt Mackall <mpm@selenic.com>
parents:
621
diff
changeset
|
1384 lock = self.lock() |
|
636
ac0ec421e3a5
Move the empty changeset detection out of findincoming to pull
Matt Mackall <mpm@selenic.com>
parents:
635
diff
changeset
|
1385 |
|
ac0ec421e3a5
Move the empty changeset detection out of findincoming to pull
Matt Mackall <mpm@selenic.com>
parents:
635
diff
changeset
|
1386 # 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
|
1387 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
|
1388 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
|
1389 fetch = [nullid] |
|
ac0ec421e3a5
Move the empty changeset detection out of findincoming to pull
Matt Mackall <mpm@selenic.com>
parents:
635
diff
changeset
|
1390 else: |
|
ac0ec421e3a5
Move the empty changeset detection out of findincoming to pull
Matt Mackall <mpm@selenic.com>
parents:
635
diff
changeset
|
1391 fetch = self.findincoming(remote) |
|
ac0ec421e3a5
Move the empty changeset detection out of findincoming to pull
Matt Mackall <mpm@selenic.com>
parents:
635
diff
changeset
|
1392 |
|
622
e9fe5d5e67f7
Add generic repo commands for pull and push
Matt Mackall <mpm@selenic.com>
parents:
621
diff
changeset
|
1393 if not fetch: |
|
e9fe5d5e67f7
Add generic repo commands for pull and push
Matt Mackall <mpm@selenic.com>
parents:
621
diff
changeset
|
1394 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
|
1395 return 1 |
|
e9fe5d5e67f7
Add generic repo commands for pull and push
Matt Mackall <mpm@selenic.com>
parents:
621
diff
changeset
|
1396 |
|
e9fe5d5e67f7
Add generic repo commands for pull and push
Matt Mackall <mpm@selenic.com>
parents:
621
diff
changeset
|
1397 cg = remote.changegroup(fetch) |
|
e9fe5d5e67f7
Add generic repo commands for pull and push
Matt Mackall <mpm@selenic.com>
parents:
621
diff
changeset
|
1398 return self.addchangegroup(cg) |
|
e9fe5d5e67f7
Add generic repo commands for pull and push
Matt Mackall <mpm@selenic.com>
parents:
621
diff
changeset
|
1399 |
|
816
8674b7803714
Warn on pushing unsynced repo or adding new heads
mpm@selenic.com
parents:
814
diff
changeset
|
1400 def push(self, remote, force=False): |
|
622
e9fe5d5e67f7
Add generic repo commands for pull and push
Matt Mackall <mpm@selenic.com>
parents:
621
diff
changeset
|
1401 lock = remote.lock() |
|
816
8674b7803714
Warn on pushing unsynced repo or adding new heads
mpm@selenic.com
parents:
814
diff
changeset
|
1402 |
|
8674b7803714
Warn on pushing unsynced repo or adding new heads
mpm@selenic.com
parents:
814
diff
changeset
|
1403 base = {} |
|
8674b7803714
Warn on pushing unsynced repo or adding new heads
mpm@selenic.com
parents:
814
diff
changeset
|
1404 heads = remote.heads() |
|
8674b7803714
Warn on pushing unsynced repo or adding new heads
mpm@selenic.com
parents:
814
diff
changeset
|
1405 inc = self.findincoming(remote, base, heads) |
|
8674b7803714
Warn on pushing unsynced repo or adding new heads
mpm@selenic.com
parents:
814
diff
changeset
|
1406 if not force and inc: |
|
8674b7803714
Warn on pushing unsynced repo or adding new heads
mpm@selenic.com
parents:
814
diff
changeset
|
1407 self.ui.warn("abort: unsynced remote changes!\n") |
|
8674b7803714
Warn on pushing unsynced repo or adding new heads
mpm@selenic.com
parents:
814
diff
changeset
|
1408 self.ui.status("(did you forget to sync? use push -f to force)\n") |
|
8674b7803714
Warn on pushing unsynced repo or adding new heads
mpm@selenic.com
parents:
814
diff
changeset
|
1409 return 1 |
|
8674b7803714
Warn on pushing unsynced repo or adding new heads
mpm@selenic.com
parents:
814
diff
changeset
|
1410 |
|
8674b7803714
Warn on pushing unsynced repo or adding new heads
mpm@selenic.com
parents:
814
diff
changeset
|
1411 update = self.findoutgoing(remote, base) |
|
622
e9fe5d5e67f7
Add generic repo commands for pull and push
Matt Mackall <mpm@selenic.com>
parents:
621
diff
changeset
|
1412 if not update: |
|
e9fe5d5e67f7
Add generic repo commands for pull and push
Matt Mackall <mpm@selenic.com>
parents:
621
diff
changeset
|
1413 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
|
1414 return 1 |
|
816
8674b7803714
Warn on pushing unsynced repo or adding new heads
mpm@selenic.com
parents:
814
diff
changeset
|
1415 elif not force: |
|
8674b7803714
Warn on pushing unsynced repo or adding new heads
mpm@selenic.com
parents:
814
diff
changeset
|
1416 if len(heads) < len(self.changelog.heads()): |
|
8674b7803714
Warn on pushing unsynced repo or adding new heads
mpm@selenic.com
parents:
814
diff
changeset
|
1417 self.ui.warn("abort: push creates new remote branches!\n") |
|
8674b7803714
Warn on pushing unsynced repo or adding new heads
mpm@selenic.com
parents:
814
diff
changeset
|
1418 self.ui.status("(did you forget to merge?" + |
|
8674b7803714
Warn on pushing unsynced repo or adding new heads
mpm@selenic.com
parents:
814
diff
changeset
|
1419 " use push -f to force)\n") |
|
8674b7803714
Warn on pushing unsynced repo or adding new heads
mpm@selenic.com
parents:
814
diff
changeset
|
1420 return 1 |
|
622
e9fe5d5e67f7
Add generic repo commands for pull and push
Matt Mackall <mpm@selenic.com>
parents:
621
diff
changeset
|
1421 |
|
e9fe5d5e67f7
Add generic repo commands for pull and push
Matt Mackall <mpm@selenic.com>
parents:
621
diff
changeset
|
1422 cg = self.changegroup(update) |
|
e9fe5d5e67f7
Add generic repo commands for pull and push
Matt Mackall <mpm@selenic.com>
parents:
621
diff
changeset
|
1423 return remote.addchangegroup(cg) |
|
e9fe5d5e67f7
Add generic repo commands for pull and push
Matt Mackall <mpm@selenic.com>
parents:
621
diff
changeset
|
1424 |
|
56
ad2ea1185f04
Add getchangegroup code to efficiently calculate and request a changegroup
mpm@selenic.com
parents:
55
diff
changeset
|
1425 def changegroup(self, basenodes): |
| 222 | 1426 class genread: |
| 1427 def __init__(self, generator): | |
| 1428 self.g = generator | |
| 1429 self.buf = "" | |
|
903
71be6dd282d1
Allow the changegroup generator to completely load the buffer.
mason@suse.com
parents:
901
diff
changeset
|
1430 def fillbuf(self): |
|
71be6dd282d1
Allow the changegroup generator to completely load the buffer.
mason@suse.com
parents:
901
diff
changeset
|
1431 self.buf += "".join(self.g) |
|
71be6dd282d1
Allow the changegroup generator to completely load the buffer.
mason@suse.com
parents:
901
diff
changeset
|
1432 |
| 222 | 1433 def read(self, l): |
| 1434 while l > len(self.buf): | |
| 1435 try: | |
| 1436 self.buf += self.g.next() | |
| 1437 except StopIteration: | |
| 1438 break | |
| 1439 d, self.buf = self.buf[:l], self.buf[l:] | |
| 1440 return d | |
| 515 | 1441 |
|
635
85e2209d401c
Protocol switch from using generators to stream-like objects.
Matt Mackall <mpm@selenic.com>
parents:
634
diff
changeset
|
1442 def gengroup(): |
|
85e2209d401c
Protocol switch from using generators to stream-like objects.
Matt Mackall <mpm@selenic.com>
parents:
634
diff
changeset
|
1443 nodes = self.newer(basenodes) |
|
85e2209d401c
Protocol switch from using generators to stream-like objects.
Matt Mackall <mpm@selenic.com>
parents:
634
diff
changeset
|
1444 |
|
85e2209d401c
Protocol switch from using generators to stream-like objects.
Matt Mackall <mpm@selenic.com>
parents:
634
diff
changeset
|
1445 # construct the link map |
|
85e2209d401c
Protocol switch from using generators to stream-like objects.
Matt Mackall <mpm@selenic.com>
parents:
634
diff
changeset
|
1446 linkmap = {} |
|
85e2209d401c
Protocol switch from using generators to stream-like objects.
Matt Mackall <mpm@selenic.com>
parents:
634
diff
changeset
|
1447 for n in nodes: |
|
85e2209d401c
Protocol switch from using generators to stream-like objects.
Matt Mackall <mpm@selenic.com>
parents:
634
diff
changeset
|
1448 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
|
1449 |
|
85e2209d401c
Protocol switch from using generators to stream-like objects.
Matt Mackall <mpm@selenic.com>
parents:
634
diff
changeset
|
1450 # 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
|
1451 changed = {} |
|
85e2209d401c
Protocol switch from using generators to stream-like objects.
Matt Mackall <mpm@selenic.com>
parents:
634
diff
changeset
|
1452 for n in nodes: |
|
85e2209d401c
Protocol switch from using generators to stream-like objects.
Matt Mackall <mpm@selenic.com>
parents:
634
diff
changeset
|
1453 c = self.changelog.read(n) |
|
85e2209d401c
Protocol switch from using generators to stream-like objects.
Matt Mackall <mpm@selenic.com>
parents:
634
diff
changeset
|
1454 for f in c[3]: |
|
85e2209d401c
Protocol switch from using generators to stream-like objects.
Matt Mackall <mpm@selenic.com>
parents:
634
diff
changeset
|
1455 changed[f] = 1 |
|
85e2209d401c
Protocol switch from using generators to stream-like objects.
Matt Mackall <mpm@selenic.com>
parents:
634
diff
changeset
|
1456 changed = changed.keys() |
|
85e2209d401c
Protocol switch from using generators to stream-like objects.
Matt Mackall <mpm@selenic.com>
parents:
634
diff
changeset
|
1457 changed.sort() |
|
85e2209d401c
Protocol switch from using generators to stream-like objects.
Matt Mackall <mpm@selenic.com>
parents:
634
diff
changeset
|
1458 |
|
85e2209d401c
Protocol switch from using generators to stream-like objects.
Matt Mackall <mpm@selenic.com>
parents:
634
diff
changeset
|
1459 # 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
|
1460 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
|
1461 |
|
85e2209d401c
Protocol switch from using generators to stream-like objects.
Matt Mackall <mpm@selenic.com>
parents:
634
diff
changeset
|
1462 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
|
1463 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
|
1464 for f in changed: |
|
85e2209d401c
Protocol switch from using generators to stream-like objects.
Matt Mackall <mpm@selenic.com>
parents:
634
diff
changeset
|
1465 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
|
1466 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
|
1467 for y in g: |
|
85e2209d401c
Protocol switch from using generators to stream-like objects.
Matt Mackall <mpm@selenic.com>
parents:
634
diff
changeset
|
1468 yield y |
|
85e2209d401c
Protocol switch from using generators to stream-like objects.
Matt Mackall <mpm@selenic.com>
parents:
634
diff
changeset
|
1469 |
|
85e2209d401c
Protocol switch from using generators to stream-like objects.
Matt Mackall <mpm@selenic.com>
parents:
634
diff
changeset
|
1470 yield struct.pack(">l", 0) |
|
85e2209d401c
Protocol switch from using generators to stream-like objects.
Matt Mackall <mpm@selenic.com>
parents:
634
diff
changeset
|
1471 |
|
85e2209d401c
Protocol switch from using generators to stream-like objects.
Matt Mackall <mpm@selenic.com>
parents:
634
diff
changeset
|
1472 return genread(gengroup()) |
|
85e2209d401c
Protocol switch from using generators to stream-like objects.
Matt Mackall <mpm@selenic.com>
parents:
634
diff
changeset
|
1473 |
|
85e2209d401c
Protocol switch from using generators to stream-like objects.
Matt Mackall <mpm@selenic.com>
parents:
634
diff
changeset
|
1474 def addchangegroup(self, source): |
|
85e2209d401c
Protocol switch from using generators to stream-like objects.
Matt Mackall <mpm@selenic.com>
parents:
634
diff
changeset
|
1475 |
| 222 | 1476 def getchunk(): |
| 1477 d = source.read(4) | |
| 1478 if not d: return "" | |
| 1479 l = struct.unpack(">l", d)[0] | |
| 1480 if l <= 4: return "" | |
| 1481 return source.read(l - 4) | |
| 1482 | |
| 1483 def getgroup(): | |
| 1484 while 1: | |
| 1485 c = getchunk() | |
| 1486 if not c: break | |
| 1487 yield c | |
| 1488 | |
| 1489 def csmap(x): | |
| 1490 self.ui.debug("add changeset %s\n" % short(x)) | |
| 1491 return self.changelog.count() | |
| 1492 | |
| 1493 def revmap(x): | |
| 1494 return self.changelog.rev(x) | |
| 1495 | |
|
635
85e2209d401c
Protocol switch from using generators to stream-like objects.
Matt Mackall <mpm@selenic.com>
parents:
634
diff
changeset
|
1496 if not source: return |
| 222 | 1497 changesets = files = revisions = 0 |
| 225 | 1498 |
| 222 | 1499 tr = self.transaction() |
| 1500 | |
| 1501 # pull off the changeset group | |
| 1502 self.ui.status("adding changesets\n") | |
| 1503 co = self.changelog.tip() | |
|
224
ccbcc4d76f81
fix bad assumption about uniqueness of file versions
mpm@selenic.com
parents:
223
diff
changeset
|
1504 cn = self.changelog.addgroup(getgroup(), csmap, tr, 1) # unique |
| 222 | 1505 changesets = self.changelog.rev(cn) - self.changelog.rev(co) |
| 1506 | |
| 1507 # pull off the manifest group | |
| 1508 self.ui.status("adding manifests\n") | |
| 1509 mm = self.manifest.tip() | |
| 1510 mo = self.manifest.addgroup(getgroup(), revmap, tr) | |
| 1511 | |
| 1512 # process the files | |
| 772 | 1513 self.ui.status("adding file changes\n") |
| 222 | 1514 while 1: |
| 1515 f = getchunk() | |
| 1516 if not f: break | |
| 1517 self.ui.debug("adding %s revisions\n" % f) | |
| 1518 fl = self.file(f) | |
|
529
aace5b681fe9
Attempt to fix negative revision count from pull
mpm@selenic.com
parents:
522
diff
changeset
|
1519 o = fl.count() |
| 222 | 1520 n = fl.addgroup(getgroup(), revmap, tr) |
|
529
aace5b681fe9
Attempt to fix negative revision count from pull
mpm@selenic.com
parents:
522
diff
changeset
|
1521 revisions += fl.count() - o |
| 222 | 1522 files += 1 |
| 1523 | |
| 772 | 1524 self.ui.status(("added %d changesets" + |
| 1525 " with %d changes to %d files\n") | |
| 1526 % (changesets, revisions, files)) | |
| 222 | 1527 |
| 1528 tr.close() | |
| 780 | 1529 |
| 1530 if not self.hook("changegroup"): | |
| 1531 return 1 | |
| 1532 | |
| 222 | 1533 return |
| 1534 | |
| 588 | 1535 def update(self, node, allow=False, force=False, choose=None, |
| 1536 moddirstate=True): | |
|
232
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1537 pl = self.dirstate.parents() |
| 275 | 1538 if not force and pl[1] != nullid: |
| 254 | 1539 self.ui.warn("aborting: outstanding uncommitted merges\n") |
| 690 | 1540 return 1 |
| 46 | 1541 |
|
232
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1542 p1, p2 = pl[0], node |
| 305 | 1543 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
|
1544 m1n = self.changelog.read(p1)[0] |
|
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1545 m2n = self.changelog.read(p2)[0] |
|
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1546 man = self.manifest.ancestor(m1n, m2n) |
|
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1547 m1 = self.manifest.read(m1n) |
| 276 | 1548 mf1 = self.manifest.readflags(m1n) |
|
232
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1549 m2 = self.manifest.read(m2n) |
| 276 | 1550 mf2 = self.manifest.readflags(m2n) |
|
232
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1551 ma = self.manifest.read(man) |
| 412 | 1552 mfa = self.manifest.readflags(man) |
|
232
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1553 |
| 723 | 1554 (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
|
1555 |
|
408
3695fbd2c33b
[PATCH] Merging files that are deleted in both branches
mpm@selenic.com
parents:
407
diff
changeset
|
1556 # 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
|
1557 # from p1 to p2? |
|
3695fbd2c33b
[PATCH] Merging files that are deleted in both branches
mpm@selenic.com
parents:
407
diff
changeset
|
1558 linear_path = (pa == p1 or pa == p2) |
|
3695fbd2c33b
[PATCH] Merging files that are deleted in both branches
mpm@selenic.com
parents:
407
diff
changeset
|
1559 |
|
232
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1560 # 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
|
1561 # we care about merging |
| 254 | 1562 self.ui.note("resolving manifests\n") |
|
650
2c934c7b79dc
Fix bug in reverting deleted files
Matt Mackall <mpm@selenic.com>
parents:
649
diff
changeset
|
1563 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
|
1564 (force, allow, moddirstate, linear_path)) |
|
232
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1565 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
|
1566 (short(man), short(m1n), short(m2n))) |
|
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1567 |
|
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1568 merge = {} |
|
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1569 get = {} |
|
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1570 remove = [] |
| 305 | 1571 mark = {} |
| 46 | 1572 |
|
232
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1573 # construct a working dir manifest |
|
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1574 mw = m1.copy() |
| 276 | 1575 mfw = mf1.copy() |
| 576 | 1576 umap = dict.fromkeys(u) |
| 1577 | |
| 254 | 1578 for f in a + c + u: |
| 1579 mw[f] = "" | |
| 441 | 1580 mfw[f] = util.is_exec(self.wjoin(f), mfw.get(f, False)) |
| 576 | 1581 |
|
232
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1582 for f in d: |
| 254 | 1583 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
|
1584 |
|
408
3695fbd2c33b
[PATCH] Merging files that are deleted in both branches
mpm@selenic.com
parents:
407
diff
changeset
|
1585 # 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
|
1586 # 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
|
1587 # 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
|
1588 # 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
|
1589 # longer in the manifest. |
| 588 | 1590 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
|
1591 self.dirstate.forget((f,)) |
|
3695fbd2c33b
[PATCH] Merging files that are deleted in both branches
mpm@selenic.com
parents:
407
diff
changeset
|
1592 |
| 576 | 1593 # Compare manifests |
|
232
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1594 for f, n in mw.iteritems(): |
| 588 | 1595 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
|
1596 if f in m2: |
|
277
79279550c8ff
merge: update permissions even if file contents didn't change
mpm@selenic.com
parents:
276
diff
changeset
|
1597 s = 0 |
|
79279550c8ff
merge: update permissions even if file contents didn't change
mpm@selenic.com
parents:
276
diff
changeset
|
1598 |
|
407
0e0d0670b2bc
[PATCH] Merging identical changes from another branch
mpm@selenic.com
parents:
405
diff
changeset
|
1599 # is the wfile new since m1, and match m2? |
| 428 | 1600 if f not in m1: |
|
407
0e0d0670b2bc
[PATCH] Merging identical changes from another branch
mpm@selenic.com
parents:
405
diff
changeset
|
1601 t1 = self.wfile(f).read() |
|
0e0d0670b2bc
[PATCH] Merging identical changes from another branch
mpm@selenic.com
parents:
405
diff
changeset
|
1602 t2 = self.file(f).revision(m2[f]) |
|
0e0d0670b2bc
[PATCH] Merging identical changes from another branch
mpm@selenic.com
parents:
405
diff
changeset
|
1603 if cmp(t1, t2) == 0: |
|
0e0d0670b2bc
[PATCH] Merging identical changes from another branch
mpm@selenic.com
parents:
405
diff
changeset
|
1604 mark[f] = 1 |
|
0e0d0670b2bc
[PATCH] Merging identical changes from another branch
mpm@selenic.com
parents:
405
diff
changeset
|
1605 n = m2[f] |
|
0e0d0670b2bc
[PATCH] Merging identical changes from another branch
mpm@selenic.com
parents:
405
diff
changeset
|
1606 del t1, t2 |
|
0e0d0670b2bc
[PATCH] Merging identical changes from another branch
mpm@selenic.com
parents:
405
diff
changeset
|
1607 |
|
296
a3d83bf86755
hg update: fix clobbering files when going backwards
mpm@selenic.com
parents:
292
diff
changeset
|
1608 # are files different? |
|
232
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1609 if n != m2[f]: |
| 254 | 1610 a = ma.get(f, nullid) |
|
296
a3d83bf86755
hg update: fix clobbering files when going backwards
mpm@selenic.com
parents:
292
diff
changeset
|
1611 # are both different from the ancestor? |
| 254 | 1612 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
|
1613 self.ui.debug(" %s versions differ, resolve\n" % f) |
| 276 | 1614 # merge executable bits |
| 1615 # "if we changed or they changed, change in merge" | |
| 1616 a, b, c = mfa.get(f, 0), mfw[f], mf2[f] | |
| 1617 mode = ((a^b) | (a^c)) ^ a | |
| 1618 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
|
1619 s = 1 |
| 305 | 1620 # are we clobbering? |
| 1621 # is remote's version newer? | |
| 1622 # or are we going back in time? | |
| 1623 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
|
1624 self.ui.debug(" remote %s is newer, get\n" % f) |
| 254 | 1625 get[f] = m2[f] |
|
277
79279550c8ff
merge: update permissions even if file contents didn't change
mpm@selenic.com
parents:
276
diff
changeset
|
1626 s = 1 |
| 305 | 1627 else: |
| 1628 mark[f] = 1 | |
| 576 | 1629 elif f in umap: |
| 1630 # this unknown file is the same as the checkout | |
| 1631 get[f] = m2[f] | |
|
277
79279550c8ff
merge: update permissions even if file contents didn't change
mpm@selenic.com
parents:
276
diff
changeset
|
1632 |
|
79279550c8ff
merge: update permissions even if file contents didn't change
mpm@selenic.com
parents:
276
diff
changeset
|
1633 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
|
1634 if force: |
|
79279550c8ff
merge: update permissions even if file contents didn't change
mpm@selenic.com
parents:
276
diff
changeset
|
1635 self.ui.debug(" updating permissions for %s\n" % f) |
| 441 | 1636 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
|
1637 else: |
|
79279550c8ff
merge: update permissions even if file contents didn't change
mpm@selenic.com
parents:
276
diff
changeset
|
1638 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
|
1639 mode = ((a^b) | (a^c)) ^ a |
|
79279550c8ff
merge: update permissions even if file contents didn't change
mpm@selenic.com
parents:
276
diff
changeset
|
1640 if mode != b: |
|
79279550c8ff
merge: update permissions even if file contents didn't change
mpm@selenic.com
parents:
276
diff
changeset
|
1641 self.ui.debug(" updating permissions for %s\n" % f) |
| 441 | 1642 util.set_exec(self.wjoin(f), mode) |
| 305 | 1643 mark[f] = 1 |
|
232
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1644 del m2[f] |
|
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1645 elif f in ma: |
| 616 | 1646 if n != ma[f]: |
| 1647 r = "d" | |
| 1648 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
|
1649 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
|
1650 (" 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
|
1651 "(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
|
1652 if r == "d": |
|
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1653 remove.append(f) |
|
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1654 else: |
|
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1655 self.ui.debug("other deleted %s\n" % f) |
| 254 | 1656 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
|
1657 else: |
| 254 | 1658 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
|
1659 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
|
1660 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
|
1661 remove.append(f) |
|
4862a134e2c2
hg merge: fix time asymmetry bug with deleting files on update to past
mpm@selenic.com
parents:
377
diff
changeset
|
1662 else: |
|
4862a134e2c2
hg merge: fix time asymmetry bug with deleting files on update to past
mpm@selenic.com
parents:
377
diff
changeset
|
1663 self.ui.debug("local created %s, keeping\n" % f) |
| 254 | 1664 else: |
| 1665 self.ui.debug("working dir created %s, keeping\n" % f) | |
| 46 | 1666 |
|
232
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1667 for f, n in m2.iteritems(): |
| 588 | 1668 if choose and not choose(f): continue |
| 256 | 1669 if f[0] == "/": continue |
| 616 | 1670 if f in ma and n != ma[f]: |
| 1671 r = "k" | |
| 1672 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
|
1673 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
|
1674 ("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
|
1675 "(k)eep or (d)elete?", "[kd]", "k") |
| 616 | 1676 if r == "k": get[f] = n |
| 1677 elif f not in ma: | |
| 254 | 1678 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
|
1679 get[f] = n |
| 616 | 1680 else: |
|
680
4b7b79d2db2c
Handle undeletion of files when checking out old revisions
Matt Mackall <mpm@selenic.com>
parents:
679
diff
changeset
|
1681 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
|
1682 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
|
1683 get[f] = n |
|
680
4b7b79d2db2c
Handle undeletion of files when checking out old revisions
Matt Mackall <mpm@selenic.com>
parents:
679
diff
changeset
|
1684 else: |
|
4b7b79d2db2c
Handle undeletion of files when checking out old revisions
Matt Mackall <mpm@selenic.com>
parents:
679
diff
changeset
|
1685 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
|
1686 |
|
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1687 del mw, m1, m2, ma |
|
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1688 |
| 275 | 1689 if force: |
| 1690 for f in merge: | |
| 1691 get[f] = merge[f][1] | |
| 1692 merge = {} | |
| 1693 | |
| 690 | 1694 if linear_path or force: |
| 254 | 1695 # we don't need to do any magic, just jump to the new rev |
| 1696 mode = 'n' | |
| 1697 p1, p2 = p2, nullid | |
| 1698 else: | |
| 275 | 1699 if not allow: |
| 305 | 1700 self.ui.status("this update spans a branch" + |
| 1701 " affecting the following files:\n") | |
| 1702 fl = merge.keys() + get.keys() | |
| 1703 fl.sort() | |
| 1704 for f in fl: | |
| 1705 cf = "" | |
| 1706 if f in merge: cf = " (resolve)" | |
| 1707 self.ui.status(" %s%s\n" % (f, cf)) | |
| 1708 self.ui.warn("aborting update spanning branches!\n") | |
| 788 | 1709 self.ui.status("(use update -m to merge across branches" + |
| 1710 " or -C to lose changes)\n") | |
| 275 | 1711 return 1 |
| 254 | 1712 # we have to remember what files we needed to get/change |
| 1713 # because any file that's different from either one of its | |
| 1714 # parents must be in the changeset | |
| 1715 mode = 'm' | |
| 588 | 1716 if moddirstate: |
| 1717 self.dirstate.update(mark.keys(), "m") | |
| 254 | 1718 |
| 588 | 1719 if moddirstate: |
| 1720 self.dirstate.setparents(p1, p2) | |
|
191
d7e859cf2f1b
merge: add count of new manifests, files, and revisions
mpm@selenic.com
parents:
190
diff
changeset
|
1721 |
|
232
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1722 # 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
|
1723 files = get.keys() |
|
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1724 files.sort() |
|
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1725 for f in files: |
|
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1726 if f[0] == "/": continue |
|
273
4f8174389001
merge: Fix bug where we overwrote local when local was newer
mpm@selenic.com
parents:
263
diff
changeset
|
1727 self.ui.note("getting %s\n" % f) |
| 276 | 1728 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
|
1729 try: |
|
291
2c4f2be05587
Add wopener for opening files in the working directory
mpm@selenic.com
parents:
288
diff
changeset
|
1730 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
|
1731 except IOError: |
|
297
0dbcf3c9ff20
Fixed usage of removed variable 'wp'.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
292
diff
changeset
|
1732 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
|
1733 self.wfile(f, "w").write(t) |
| 441 | 1734 util.set_exec(self.wjoin(f), mf2[f]) |
| 588 | 1735 if moddirstate: |
| 1736 self.dirstate.update([f], mode) | |
| 46 | 1737 |
|
232
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1738 # merge the tricky bits |
|
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1739 files = merge.keys() |
|
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1740 files.sort() |
|
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1741 for f in files: |
| 256 | 1742 self.ui.status("merging %s\n" % f) |
| 276 | 1743 m, o, flag = merge[f] |
|
232
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1744 self.merge3(f, m, o) |
| 441 | 1745 util.set_exec(self.wjoin(f), flag) |
|
862
d70c1c31fd45
Fix 3-way-merge of original parent, workdir and new parent.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
861
diff
changeset
|
1746 if moddirstate: |
|
d70c1c31fd45
Fix 3-way-merge of original parent, workdir and new parent.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
861
diff
changeset
|
1747 if mode == 'm': |
|
d70c1c31fd45
Fix 3-way-merge of original parent, workdir and new parent.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
861
diff
changeset
|
1748 # only update dirstate on branch merge, otherwise we |
|
d70c1c31fd45
Fix 3-way-merge of original parent, workdir and new parent.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
861
diff
changeset
|
1749 # could mark files with changes as unchanged |
|
d70c1c31fd45
Fix 3-way-merge of original parent, workdir and new parent.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
861
diff
changeset
|
1750 self.dirstate.update([f], mode) |
|
d70c1c31fd45
Fix 3-way-merge of original parent, workdir and new parent.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
861
diff
changeset
|
1751 elif p2 == nullid: |
|
d70c1c31fd45
Fix 3-way-merge of original parent, workdir and new parent.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
861
diff
changeset
|
1752 # update dirstate from parent1's manifest |
|
d70c1c31fd45
Fix 3-way-merge of original parent, workdir and new parent.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
861
diff
changeset
|
1753 m1n = self.changelog.read(p1)[0] |
|
d70c1c31fd45
Fix 3-way-merge of original parent, workdir and new parent.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
861
diff
changeset
|
1754 m1 = self.manifest.read(m1n) |
|
865
2d2fee33ec68
Cleanup after previous changes:
Thomas Arendsen Hein <thomas@intevation.de>
parents:
863
diff
changeset
|
1755 f_len = len(self.file(f).read(m1[f])) |
|
862
d70c1c31fd45
Fix 3-way-merge of original parent, workdir and new parent.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
861
diff
changeset
|
1756 self.dirstate.update([f], mode, st_size=f_len, st_mtime=0) |
|
d70c1c31fd45
Fix 3-way-merge of original parent, workdir and new parent.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
861
diff
changeset
|
1757 else: |
|
d70c1c31fd45
Fix 3-way-merge of original parent, workdir and new parent.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
861
diff
changeset
|
1758 self.ui.warn("Second parent without branch merge!?\n" |
|
d70c1c31fd45
Fix 3-way-merge of original parent, workdir and new parent.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
861
diff
changeset
|
1759 "Dirstate for file %s may be wrong.\n" % f) |
|
232
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1760 |
| 681 | 1761 remove.sort() |
|
232
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1762 for f in remove: |
|
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1763 self.ui.note("removing %s\n" % f) |
| 690 | 1764 try: |
| 1765 os.unlink(f) | |
| 1766 except OSError, inst: | |
| 1767 self.ui.warn("update failed to remove %s: %s!\n" % (f, inst)) | |
| 578 | 1768 # try removing directories that might now be empty |
| 1769 try: os.removedirs(os.path.dirname(f)) | |
| 1770 except: pass | |
| 588 | 1771 if moddirstate: |
| 1772 if mode == 'n': | |
| 1773 self.dirstate.forget(remove) | |
| 1774 else: | |
| 1775 self.dirstate.update(remove, 'r') | |
|
232
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1776 |
|
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1777 def merge3(self, fn, my, other): |
|
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1778 """perform a 3-way merge in the working directory""" |
| 249 | 1779 |
| 96 | 1780 def temp(prefix, node): |
| 1781 pre = "%s~%s." % (os.path.basename(fn), prefix) | |
| 1782 (fd, name) = tempfile.mkstemp("", pre) | |
| 417 | 1783 f = os.fdopen(fd, "wb") |
| 96 | 1784 f.write(fl.revision(node)) |
| 1785 f.close() | |
| 1786 return name | |
| 1787 | |
|
232
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1788 fl = self.file(fn) |
| 96 | 1789 base = fl.ancestor(my, other) |
| 244 | 1790 a = self.wjoin(fn) |
| 346 | 1791 b = temp("base", base) |
| 1792 c = temp("other", other) | |
| 96 | 1793 |
|
232
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1794 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
|
1795 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
|
1796 (fn, short(other), short(base))) |
| 96 | 1797 |
|
703
fb6f85ecc863
merge program setting from hgrc wasn't used.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
691
diff
changeset
|
1798 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
|
1799 or "hgmerge") |
| 240 | 1800 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
|
1801 if r: |
| 275 | 1802 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
|
1803 |
|
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1804 os.unlink(b) |
|
fc4a6e5b5812
hg resolve: merge a given node into the working directory
mpm@selenic.com
parents:
231
diff
changeset
|
1805 os.unlink(c) |
| 96 | 1806 |
| 247 | 1807 def verify(self): |
| 1808 filelinkrevs = {} | |
| 1809 filenodes = {} | |
| 1810 changesets = revisions = files = 0 | |
| 1811 errors = 0 | |
| 1812 | |
| 302 | 1813 seen = {} |
| 247 | 1814 self.ui.status("checking changesets\n") |
| 1815 for i in range(self.changelog.count()): | |
| 1816 changesets += 1 | |
| 1817 n = self.changelog.node(i) | |
| 302 | 1818 if n in seen: |
| 1819 self.ui.warn("duplicate changeset at revision %d\n" % i) | |
| 1820 errors += 1 | |
| 1821 seen[n] = 1 | |
| 515 | 1822 |
| 247 | 1823 for p in self.changelog.parents(n): |
| 1824 if p not in self.changelog.nodemap: | |
| 1825 self.ui.warn("changeset %s has unknown parent %s\n" % | |
| 1826 (short(n), short(p))) | |
| 1827 errors += 1 | |
| 1828 try: | |
| 1829 changes = self.changelog.read(n) | |
| 1830 except Exception, inst: | |
| 1831 self.ui.warn("unpacking changeset %s: %s\n" % (short(n), inst)) | |
| 1832 errors += 1 | |
| 1833 | |
| 1834 for f in changes[3]: | |
| 1835 filelinkrevs.setdefault(f, []).append(i) | |
| 1836 | |
| 302 | 1837 seen = {} |
| 247 | 1838 self.ui.status("checking manifests\n") |
| 1839 for i in range(self.manifest.count()): | |
| 1840 n = self.manifest.node(i) | |
| 302 | 1841 if n in seen: |
| 1842 self.ui.warn("duplicate manifest at revision %d\n" % i) | |
| 1843 errors += 1 | |
| 1844 seen[n] = 1 | |
| 515 | 1845 |
| 247 | 1846 for p in self.manifest.parents(n): |
| 1847 if p not in self.manifest.nodemap: | |
| 1848 self.ui.warn("manifest %s has unknown parent %s\n" % | |
| 1849 (short(n), short(p))) | |
| 1850 errors += 1 | |
| 1851 | |
| 1852 try: | |
| 1853 delta = mdiff.patchtext(self.manifest.delta(n)) | |
| 1854 except KeyboardInterrupt: | |
| 582 | 1855 self.ui.warn("aborted") |
| 247 | 1856 sys.exit(0) |
| 1857 except Exception, inst: | |
| 1858 self.ui.warn("unpacking manifest %s: %s\n" | |
| 1859 % (short(n), inst)) | |
| 1860 errors += 1 | |
| 1861 | |
| 1862 ff = [ l.split('\0') for l in delta.splitlines() ] | |
| 1863 for f, fn in ff: | |
| 284 | 1864 filenodes.setdefault(f, {})[bin(fn[:40])] = 1 |
| 247 | 1865 |
| 1866 self.ui.status("crosschecking files in changesets and manifests\n") | |
| 1867 for f in filenodes: | |
| 1868 if f not in filelinkrevs: | |
| 1869 self.ui.warn("file %s in manifest but not in changesets\n" % f) | |
| 1870 errors += 1 | |
| 1871 | |
| 1872 for f in filelinkrevs: | |
| 1873 if f not in filenodes: | |
| 1874 self.ui.warn("file %s in changeset but not in manifest\n" % f) | |
| 1875 errors += 1 | |
| 1876 | |
| 1877 self.ui.status("checking files\n") | |
| 1878 ff = filenodes.keys() | |
| 1879 ff.sort() | |
| 1880 for f in ff: | |
| 1881 if f == "/dev/null": continue | |
| 1882 files += 1 | |
| 1883 fl = self.file(f) | |
| 1884 nodes = { nullid: 1 } | |
| 302 | 1885 seen = {} |
| 247 | 1886 for i in range(fl.count()): |
| 1887 revisions += 1 | |
| 1888 n = fl.node(i) | |
| 1889 | |
| 302 | 1890 if n in seen: |
| 1891 self.ui.warn("%s: duplicate revision %d\n" % (f, i)) | |
| 1892 errors += 1 | |
| 1893 | |
| 247 | 1894 if n not in filenodes[f]: |
| 1895 self.ui.warn("%s: %d:%s not in manifests\n" | |
| 1896 % (f, i, short(n))) | |
| 1897 errors += 1 | |
| 1898 else: | |
| 1899 del filenodes[f][n] | |
| 1900 | |
| 1901 flr = fl.linkrev(n) | |
| 1902 if flr not in filelinkrevs[f]: | |
| 1903 self.ui.warn("%s:%s points to unexpected changeset %d\n" | |
| 1904 % (f, short(n), fl.linkrev(n))) | |
| 1905 errors += 1 | |
| 1906 else: | |
| 1907 filelinkrevs[f].remove(flr) | |
| 1908 | |
| 1909 # verify contents | |
| 1910 try: | |
| 1911 t = fl.read(n) | |
| 1912 except Exception, inst: | |
| 1913 self.ui.warn("unpacking file %s %s: %s\n" | |
| 1914 % (f, short(n), inst)) | |
| 1915 errors += 1 | |
| 1916 | |
| 1917 # verify parents | |
| 1918 (p1, p2) = fl.parents(n) | |
| 1919 if p1 not in nodes: | |
| 1920 self.ui.warn("file %s:%s unknown parent 1 %s" % | |
| 1921 (f, short(n), short(p1))) | |
| 1922 errors += 1 | |
| 1923 if p2 not in nodes: | |
| 1924 self.ui.warn("file %s:%s unknown parent 2 %s" % | |
| 1925 (f, short(n), short(p1))) | |
| 1926 errors += 1 | |
| 1927 nodes[n] = 1 | |
| 1928 | |
| 1929 # cross-check | |
| 1930 for node in filenodes[f]: | |
| 1931 self.ui.warn("node %s in manifests not in %s\n" | |
| 721 | 1932 % (hex(node), f)) |
| 247 | 1933 errors += 1 |
| 1934 | |
| 1935 self.ui.status("%d files, %d changesets, %d total revisions\n" % | |
| 1936 (files, changesets, revisions)) | |
| 1937 | |
| 1938 if errors: | |
| 1939 self.ui.warn("%d integrity errors encountered!\n" % errors) | |
| 1940 return 1 | |
| 1941 | |
|
623
314867960a4a
Change remote repository to httprepository
Matt Mackall <mpm@selenic.com>
parents:
622
diff
changeset
|
1942 class httprepository: |
| 60 | 1943 def __init__(self, ui, path): |
| 765 | 1944 # fix missing / after hostname |
| 1945 s = urlparse.urlsplit(path) | |
| 1946 partial = s[2] | |
| 1947 if not partial: partial = "/" | |
| 1948 self.url = urlparse.urlunsplit((s[0], s[1], partial, '', '')) | |
| 60 | 1949 self.ui = ui |
| 321 | 1950 no_list = [ "localhost", "127.0.0.1" ] |
| 1951 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
|
1952 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
|
1953 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
|
1954 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
|
1955 host = host[7:] |
| 321 | 1956 user = ui.config("http_proxy", "user") |
| 1957 passwd = ui.config("http_proxy", "passwd") | |
| 1958 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
|
1959 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
|
1960 no = os.environ.get("no_proxy") |
| 321 | 1961 if no: |
| 1962 no_list = no_list + no.split(",") | |
| 515 | 1963 |
| 321 | 1964 no_proxy = 0 |
| 1965 for h in no_list: | |
| 1966 if (path.startswith("http://" + h + "/") or | |
| 1967 path.startswith("http://" + h + ":") or | |
| 1968 path == "http://" + h): | |
| 1969 no_proxy = 1 | |
| 1970 | |
| 1971 # Note: urllib2 takes proxy values from the environment and those will | |
| 1972 # 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
|
1973 for env in ["HTTP_PROXY", "http_proxy", "no_proxy"]: |
|
859
6390c377a9e6
Trap OSError when deleting env vars
Edouard Gomez <ed.gomez@free.fr>
parents:
856
diff
changeset
|
1974 try: |
|
6390c377a9e6
Trap OSError when deleting env vars
Edouard Gomez <ed.gomez@free.fr>
parents:
856
diff
changeset
|
1975 if os.environ.has_key(env): |
|
6390c377a9e6
Trap OSError when deleting env vars
Edouard Gomez <ed.gomez@free.fr>
parents:
856
diff
changeset
|
1976 del os.environ[env] |
|
6390c377a9e6
Trap OSError when deleting env vars
Edouard Gomez <ed.gomez@free.fr>
parents:
856
diff
changeset
|
1977 except OSError: |
|
6390c377a9e6
Trap OSError when deleting env vars
Edouard Gomez <ed.gomez@free.fr>
parents:
856
diff
changeset
|
1978 pass |
| 321 | 1979 |
| 1980 proxy_handler = urllib2.BaseHandler() | |
| 1981 if host and not no_proxy: | |
| 1982 proxy_handler = urllib2.ProxyHandler({"http" : "http://" + host}) | |
| 1983 | |
| 1984 authinfo = None | |
| 1985 if user and passwd: | |
| 1986 passmgr = urllib2.HTTPPasswordMgrWithDefaultRealm() | |
| 1987 passmgr.add_password(None, host, user, passwd) | |
| 1988 authinfo = urllib2.ProxyBasicAuthHandler(passmgr) | |
| 1989 | |
| 1990 opener = urllib2.build_opener(proxy_handler, authinfo) | |
| 1991 urllib2.install_opener(opener) | |
| 60 | 1992 |
|
634
da5378d39269
Add a repo method to report repo device
Matt Mackall <mpm@selenic.com>
parents:
627
diff
changeset
|
1993 def dev(self): |
|
da5378d39269
Add a repo method to report repo device
Matt Mackall <mpm@selenic.com>
parents:
627
diff
changeset
|
1994 return -1 |
|
da5378d39269
Add a repo method to report repo device
Matt Mackall <mpm@selenic.com>
parents:
627
diff
changeset
|
1995 |
| 60 | 1996 def do_cmd(self, cmd, **args): |
| 83 | 1997 self.ui.debug("sending %s command\n" % cmd) |
| 60 | 1998 q = {"cmd": cmd} |
| 1999 q.update(args) | |
| 2000 qs = urllib.urlencode(q) | |
| 2001 cu = "%s?%s" % (self.url, qs) | |
| 752 | 2002 resp = urllib2.urlopen(cu) |
| 753 | 2003 proto = resp.headers['content-type'] |
| 752 | 2004 |
| 753 | 2005 # accept old "text/plain" and "application/hg-changegroup" for now |
| 2006 if not proto.startswith('application/mercurial') and \ | |
| 2007 not proto.startswith('text/plain') and \ | |
| 2008 not proto.startswith('application/hg-changegroup'): | |
| 752 | 2009 raise RepoError("'%s' does not appear to be an hg repository" |
| 2010 % self.url) | |
| 2011 | |
| 753 | 2012 if proto.startswith('application/mercurial'): |
| 2013 version = proto[22:] | |
| 2014 if float(version) > 0.1: | |
| 2015 raise RepoError("'%s' uses newer protocol %s" % | |
| 2016 (self.url, version)) | |
| 2017 | |
| 752 | 2018 return resp |
| 60 | 2019 |
| 222 | 2020 def heads(self): |
| 2021 d = self.do_cmd("heads").read() | |
| 2022 try: | |
| 2023 return map(bin, d[:-1].split(" ")) | |
| 2024 except: | |
| 2025 self.ui.warn("unexpected response:\n" + d[:400] + "\n...\n") | |
| 2026 raise | |
| 2027 | |
| 60 | 2028 def branches(self, nodes): |
| 2029 n = " ".join(map(hex, nodes)) | |
| 752 | 2030 d = self.do_cmd("branches", nodes=n).read() |
| 217 | 2031 try: |
| 2032 br = [ tuple(map(bin, b.split(" "))) for b in d.splitlines() ] | |
| 2033 return br | |
| 2034 except: | |
| 2035 self.ui.warn("unexpected response:\n" + d[:400] + "\n...\n") | |
| 2036 raise | |
| 60 | 2037 |
| 2038 def between(self, pairs): | |
| 2039 n = "\n".join(["-".join(map(hex, p)) for p in pairs]) | |
| 752 | 2040 d = self.do_cmd("between", pairs=n).read() |
| 217 | 2041 try: |
| 2042 p = [ l and map(bin, l.split(" ")) or [] for l in d.splitlines() ] | |
| 2043 return p | |
| 2044 except: | |
| 2045 self.ui.warn("unexpected response:\n" + d[:400] + "\n...\n") | |
| 2046 raise | |
| 60 | 2047 |
| 2048 def changegroup(self, nodes): | |
| 2049 n = " ".join(map(hex, nodes)) | |
| 752 | 2050 f = self.do_cmd("changegroup", roots=n) |
| 192 | 2051 bytes = 0 |
|
635
85e2209d401c
Protocol switch from using generators to stream-like objects.
Matt Mackall <mpm@selenic.com>
parents:
634
diff
changeset
|
2052 |
|
85e2209d401c
Protocol switch from using generators to stream-like objects.
Matt Mackall <mpm@selenic.com>
parents:
634
diff
changeset
|
2053 class zread: |
|
85e2209d401c
Protocol switch from using generators to stream-like objects.
Matt Mackall <mpm@selenic.com>
parents:
634
diff
changeset
|
2054 def __init__(self, f): |
|
85e2209d401c
Protocol switch from using generators to stream-like objects.
Matt Mackall <mpm@selenic.com>
parents:
634
diff
changeset
|
2055 self.zd = zlib.decompressobj() |
|
85e2209d401c
Protocol switch from using generators to stream-like objects.
Matt Mackall <mpm@selenic.com>
parents:
634
diff
changeset
|
2056 self.f = f |
|
85e2209d401c
Protocol switch from using generators to stream-like objects.
Matt Mackall <mpm@selenic.com>
parents:
634
diff
changeset
|
2057 self.buf = "" |
|
85e2209d401c
Protocol switch from using generators to stream-like objects.
Matt Mackall <mpm@selenic.com>
parents:
634
diff
changeset
|
2058 def read(self, l): |
|
85e2209d401c
Protocol switch from using generators to stream-like objects.
Matt Mackall <mpm@selenic.com>
parents:
634
diff
changeset
|
2059 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
|
2060 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
|
2061 if r: |
|
85e2209d401c
Protocol switch from using generators to stream-like objects.
Matt Mackall <mpm@selenic.com>
parents:
634
diff
changeset
|
2062 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
|
2063 else: |
|
85e2209d401c
Protocol switch from using generators to stream-like objects.
Matt Mackall <mpm@selenic.com>
parents:
634
diff
changeset
|
2064 self.buf += self.zd.flush() |
|
85e2209d401c
Protocol switch from using generators to stream-like objects.
Matt Mackall <mpm@selenic.com>
parents:
634
diff
changeset
|
2065 break |
|
85e2209d401c
Protocol switch from using generators to stream-like objects.
Matt Mackall <mpm@selenic.com>
parents:
634
diff
changeset
|
2066 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
|
2067 return d |
|
85e2209d401c
Protocol switch from using generators to stream-like objects.
Matt Mackall <mpm@selenic.com>
parents:
634
diff
changeset
|
2068 |
| 752 | 2069 return zread(f) |
|
635
85e2209d401c
Protocol switch from using generators to stream-like objects.
Matt Mackall <mpm@selenic.com>
parents:
634
diff
changeset
|
2070 |
|
638
35f7adfefa69
Add a scheme for handling remote locking
Matt Mackall <mpm@selenic.com>
parents:
637
diff
changeset
|
2071 class remotelock: |
|
35f7adfefa69
Add a scheme for handling remote locking
Matt Mackall <mpm@selenic.com>
parents:
637
diff
changeset
|
2072 def __init__(self, repo): |
|
35f7adfefa69
Add a scheme for handling remote locking
Matt Mackall <mpm@selenic.com>
parents:
637
diff
changeset
|
2073 self.repo = repo |
|
35f7adfefa69
Add a scheme for handling remote locking
Matt Mackall <mpm@selenic.com>
parents:
637
diff
changeset
|
2074 def release(self): |
|
35f7adfefa69
Add a scheme for handling remote locking
Matt Mackall <mpm@selenic.com>
parents:
637
diff
changeset
|
2075 self.repo.unlock() |
|
35f7adfefa69
Add a scheme for handling remote locking
Matt Mackall <mpm@selenic.com>
parents:
637
diff
changeset
|
2076 self.repo = None |
|
35f7adfefa69
Add a scheme for handling remote locking
Matt Mackall <mpm@selenic.com>
parents:
637
diff
changeset
|
2077 def __del__(self): |
|
35f7adfefa69
Add a scheme for handling remote locking
Matt Mackall <mpm@selenic.com>
parents:
637
diff
changeset
|
2078 if self.repo: |
|
35f7adfefa69
Add a scheme for handling remote locking
Matt Mackall <mpm@selenic.com>
parents:
637
diff
changeset
|
2079 self.release() |
| 60 | 2080 |
|
624
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
2081 class sshrepository: |
|
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
2082 def __init__(self, ui, path): |
|
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
2083 self.url = path |
|
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
2084 self.ui = ui |
|
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
2085 |
| 817 | 2086 m = re.match(r'ssh://(([^@]+)@)?([^:/]+)(:(\d+))?(/(.*))', path) |
|
624
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
2087 if not m: |
| 817 | 2088 raise RepoError("couldn't parse destination %s" % path) |
|
624
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
2089 |
|
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
2090 self.user = m.group(2) |
|
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
2091 self.host = m.group(3) |
|
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
2092 self.port = m.group(5) |
|
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
2093 self.path = m.group(7) |
|
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
2094 |
|
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
2095 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
|
2096 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
|
2097 path = self.path or "" |
|
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
2098 |
| 817 | 2099 if not path: |
| 2100 raise RepoError("no remote repository path specified") | |
| 2101 | |
|
624
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
2102 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
|
2103 cmd = cmd % (args, path) |
|
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
2104 |
|
646
342927da4f4c
Show remote client output with "remote:"
Matt Mackall <mpm@selenic.com>
parents:
644
diff
changeset
|
2105 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
|
2106 |
|
342927da4f4c
Show remote client output with "remote:"
Matt Mackall <mpm@selenic.com>
parents:
644
diff
changeset
|
2107 def readerr(self): |
|
342927da4f4c
Show remote client output with "remote:"
Matt Mackall <mpm@selenic.com>
parents:
644
diff
changeset
|
2108 while 1: |
|
342927da4f4c
Show remote client output with "remote:"
Matt Mackall <mpm@selenic.com>
parents:
644
diff
changeset
|
2109 r,w,x = select.select([self.pipee], [], [], 0) |
|
342927da4f4c
Show remote client output with "remote:"
Matt Mackall <mpm@selenic.com>
parents:
644
diff
changeset
|
2110 if not r: break |
|
342927da4f4c
Show remote client output with "remote:"
Matt Mackall <mpm@selenic.com>
parents:
644
diff
changeset
|
2111 l = self.pipee.readline() |
|
342927da4f4c
Show remote client output with "remote:"
Matt Mackall <mpm@selenic.com>
parents:
644
diff
changeset
|
2112 if not l: break |
|
342927da4f4c
Show remote client output with "remote:"
Matt Mackall <mpm@selenic.com>
parents:
644
diff
changeset
|
2113 self.ui.status("remote: ", l) |
|
624
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
2114 |
|
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
2115 def __del__(self): |
| 817 | 2116 try: |
| 2117 self.pipeo.close() | |
| 2118 self.pipei.close() | |
| 2119 for l in self.pipee: | |
| 2120 self.ui.status("remote: ", l) | |
| 2121 self.pipee.close() | |
| 2122 except: | |
| 2123 pass | |
|
624
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
2124 |
|
634
da5378d39269
Add a repo method to report repo device
Matt Mackall <mpm@selenic.com>
parents:
627
diff
changeset
|
2125 def dev(self): |
|
da5378d39269
Add a repo method to report repo device
Matt Mackall <mpm@selenic.com>
parents:
627
diff
changeset
|
2126 return -1 |
|
da5378d39269
Add a repo method to report repo device
Matt Mackall <mpm@selenic.com>
parents:
627
diff
changeset
|
2127 |
|
624
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
2128 def do_cmd(self, cmd, **args): |
|
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
2129 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
|
2130 self.pipeo.write("%s\n" % cmd) |
|
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
2131 for k, v in args.items(): |
|
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
2132 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
|
2133 self.pipeo.write(v) |
|
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
2134 self.pipeo.flush() |
|
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
2135 |
|
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
2136 return self.pipei |
|
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
2137 |
|
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
2138 def call(self, cmd, **args): |
|
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
2139 r = self.do_cmd(cmd, **args) |
|
646
342927da4f4c
Show remote client output with "remote:"
Matt Mackall <mpm@selenic.com>
parents:
644
diff
changeset
|
2140 l = r.readline() |
|
342927da4f4c
Show remote client output with "remote:"
Matt Mackall <mpm@selenic.com>
parents:
644
diff
changeset
|
2141 self.readerr() |
|
342927da4f4c
Show remote client output with "remote:"
Matt Mackall <mpm@selenic.com>
parents:
644
diff
changeset
|
2142 try: |
|
342927da4f4c
Show remote client output with "remote:"
Matt Mackall <mpm@selenic.com>
parents:
644
diff
changeset
|
2143 l = int(l) |
|
342927da4f4c
Show remote client output with "remote:"
Matt Mackall <mpm@selenic.com>
parents:
644
diff
changeset
|
2144 except: |
|
342927da4f4c
Show remote client output with "remote:"
Matt Mackall <mpm@selenic.com>
parents:
644
diff
changeset
|
2145 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
|
2146 return r.read(l) |
|
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
2147 |
|
638
35f7adfefa69
Add a scheme for handling remote locking
Matt Mackall <mpm@selenic.com>
parents:
637
diff
changeset
|
2148 def lock(self): |
|
35f7adfefa69
Add a scheme for handling remote locking
Matt Mackall <mpm@selenic.com>
parents:
637
diff
changeset
|
2149 self.call("lock") |
|
35f7adfefa69
Add a scheme for handling remote locking
Matt Mackall <mpm@selenic.com>
parents:
637
diff
changeset
|
2150 return remotelock(self) |
|
35f7adfefa69
Add a scheme for handling remote locking
Matt Mackall <mpm@selenic.com>
parents:
637
diff
changeset
|
2151 |
|
35f7adfefa69
Add a scheme for handling remote locking
Matt Mackall <mpm@selenic.com>
parents:
637
diff
changeset
|
2152 def unlock(self): |
|
35f7adfefa69
Add a scheme for handling remote locking
Matt Mackall <mpm@selenic.com>
parents:
637
diff
changeset
|
2153 self.call("unlock") |
|
35f7adfefa69
Add a scheme for handling remote locking
Matt Mackall <mpm@selenic.com>
parents:
637
diff
changeset
|
2154 |
|
624
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
2155 def heads(self): |
|
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
2156 d = self.call("heads") |
|
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
2157 try: |
|
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
2158 return map(bin, d[:-1].split(" ")) |
|
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
2159 except: |
|
646
342927da4f4c
Show remote client output with "remote:"
Matt Mackall <mpm@selenic.com>
parents:
644
diff
changeset
|
2160 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
|
2161 |
|
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
2162 def branches(self, nodes): |
|
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
2163 n = " ".join(map(hex, nodes)) |
|
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
2164 d = self.call("branches", nodes=n) |
|
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
2165 try: |
|
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
2166 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
|
2167 return br |
|
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
2168 except: |
|
646
342927da4f4c
Show remote client output with "remote:"
Matt Mackall <mpm@selenic.com>
parents:
644
diff
changeset
|
2169 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
|
2170 |
|
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
2171 def between(self, pairs): |
|
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
2172 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
|
2173 d = self.call("between", pairs=n) |
|
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
2174 try: |
|
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
2175 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
|
2176 return p |
|
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
2177 except: |
|
646
342927da4f4c
Show remote client output with "remote:"
Matt Mackall <mpm@selenic.com>
parents:
644
diff
changeset
|
2178 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
|
2179 |
|
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
2180 def changegroup(self, nodes): |
|
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
2181 n = " ".join(map(hex, nodes)) |
|
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
2182 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
|
2183 return self.pipei |
|
624
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
2184 |
|
639
31cebba881a0
Add addchangegroup to the ssh protocol
Matt Mackall <mpm@selenic.com>
parents:
638
diff
changeset
|
2185 def addchangegroup(self, cg): |
|
31cebba881a0
Add addchangegroup to the ssh protocol
Matt Mackall <mpm@selenic.com>
parents:
638
diff
changeset
|
2186 d = self.call("addchangegroup") |
|
31cebba881a0
Add addchangegroup to the ssh protocol
Matt Mackall <mpm@selenic.com>
parents:
638
diff
changeset
|
2187 if d: |
|
31cebba881a0
Add addchangegroup to the ssh protocol
Matt Mackall <mpm@selenic.com>
parents:
638
diff
changeset
|
2188 raise RepoError("push refused: %s", d) |
|
31cebba881a0
Add addchangegroup to the ssh protocol
Matt Mackall <mpm@selenic.com>
parents:
638
diff
changeset
|
2189 |
|
31cebba881a0
Add addchangegroup to the ssh protocol
Matt Mackall <mpm@selenic.com>
parents:
638
diff
changeset
|
2190 while 1: |
|
31cebba881a0
Add addchangegroup to the ssh protocol
Matt Mackall <mpm@selenic.com>
parents:
638
diff
changeset
|
2191 d = cg.read(4096) |
|
31cebba881a0
Add addchangegroup to the ssh protocol
Matt Mackall <mpm@selenic.com>
parents:
638
diff
changeset
|
2192 if not d: break |
|
31cebba881a0
Add addchangegroup to the ssh protocol
Matt Mackall <mpm@selenic.com>
parents:
638
diff
changeset
|
2193 self.pipeo.write(d) |
|
646
342927da4f4c
Show remote client output with "remote:"
Matt Mackall <mpm@selenic.com>
parents:
644
diff
changeset
|
2194 self.readerr() |
|
639
31cebba881a0
Add addchangegroup to the ssh protocol
Matt Mackall <mpm@selenic.com>
parents:
638
diff
changeset
|
2195 |
|
31cebba881a0
Add addchangegroup to the ssh protocol
Matt Mackall <mpm@selenic.com>
parents:
638
diff
changeset
|
2196 self.pipeo.flush() |
|
31cebba881a0
Add addchangegroup to the ssh protocol
Matt Mackall <mpm@selenic.com>
parents:
638
diff
changeset
|
2197 |
|
646
342927da4f4c
Show remote client output with "remote:"
Matt Mackall <mpm@selenic.com>
parents:
644
diff
changeset
|
2198 self.readerr() |
|
639
31cebba881a0
Add addchangegroup to the ssh protocol
Matt Mackall <mpm@selenic.com>
parents:
638
diff
changeset
|
2199 l = int(self.pipei.readline()) |
|
646
342927da4f4c
Show remote client output with "remote:"
Matt Mackall <mpm@selenic.com>
parents:
644
diff
changeset
|
2200 return self.pipei.read(l) != "" |
|
639
31cebba881a0
Add addchangegroup to the ssh protocol
Matt Mackall <mpm@selenic.com>
parents:
638
diff
changeset
|
2201 |
| 60 | 2202 def repository(ui, path=None, create=0): |
|
623
314867960a4a
Change remote repository to httprepository
Matt Mackall <mpm@selenic.com>
parents:
622
diff
changeset
|
2203 if path: |
|
314867960a4a
Change remote repository to httprepository
Matt Mackall <mpm@selenic.com>
parents:
622
diff
changeset
|
2204 if path.startswith("http://"): |
|
314867960a4a
Change remote repository to httprepository
Matt Mackall <mpm@selenic.com>
parents:
622
diff
changeset
|
2205 return httprepository(ui, path) |
|
314867960a4a
Change remote repository to httprepository
Matt Mackall <mpm@selenic.com>
parents:
622
diff
changeset
|
2206 if path.startswith("hg://"): |
|
314867960a4a
Change remote repository to httprepository
Matt Mackall <mpm@selenic.com>
parents:
622
diff
changeset
|
2207 return httprepository(ui, path.replace("hg://", "http://")) |
|
314867960a4a
Change remote repository to httprepository
Matt Mackall <mpm@selenic.com>
parents:
622
diff
changeset
|
2208 if path.startswith("old-http://"): |
|
314867960a4a
Change remote repository to httprepository
Matt Mackall <mpm@selenic.com>
parents:
622
diff
changeset
|
2209 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
|
2210 if path.startswith("ssh://"): |
|
876333a295ff
Add an sshrepository class and hg serve --stdio
Matt Mackall <mpm@selenic.com>
parents:
623
diff
changeset
|
2211 return sshrepository(ui, path) |
| 60 | 2212 |
|
623
314867960a4a
Change remote repository to httprepository
Matt Mackall <mpm@selenic.com>
parents:
622
diff
changeset
|
2213 return localrepository(ui, path, create) |