##// END OF EJS Templates
subrepo: add forgotten annotation for reverting git subrepos...
Mathias De Maré -
r23679:dd1e73c4 default
parent child Browse files
Show More
@@ -1,1680 +1,1681 b''
1 # subrepo.py - sub-repository handling for Mercurial
1 # subrepo.py - sub-repository handling for Mercurial
2 #
2 #
3 # Copyright 2009-2010 Matt Mackall <mpm@selenic.com>
3 # Copyright 2009-2010 Matt Mackall <mpm@selenic.com>
4 #
4 #
5 # This software may be used and distributed according to the terms of the
5 # This software may be used and distributed according to the terms of the
6 # GNU General Public License version 2 or any later version.
6 # GNU General Public License version 2 or any later version.
7
7
8 import copy
8 import copy
9 import errno, os, re, shutil, posixpath, sys
9 import errno, os, re, shutil, posixpath, sys
10 import xml.dom.minidom
10 import xml.dom.minidom
11 import stat, subprocess, tarfile
11 import stat, subprocess, tarfile
12 from i18n import _
12 from i18n import _
13 import config, util, node, error, cmdutil, scmutil, match as matchmod
13 import config, util, node, error, cmdutil, scmutil, match as matchmod
14 import phases
14 import phases
15 import pathutil
15 import pathutil
16 import exchange
16 import exchange
17 hg = None
17 hg = None
18 propertycache = util.propertycache
18 propertycache = util.propertycache
19
19
20 nullstate = ('', '', 'empty')
20 nullstate = ('', '', 'empty')
21
21
22 def _expandedabspath(path):
22 def _expandedabspath(path):
23 '''
23 '''
24 get a path or url and if it is a path expand it and return an absolute path
24 get a path or url and if it is a path expand it and return an absolute path
25 '''
25 '''
26 expandedpath = util.urllocalpath(util.expandpath(path))
26 expandedpath = util.urllocalpath(util.expandpath(path))
27 u = util.url(expandedpath)
27 u = util.url(expandedpath)
28 if not u.scheme:
28 if not u.scheme:
29 path = util.normpath(os.path.abspath(u.path))
29 path = util.normpath(os.path.abspath(u.path))
30 return path
30 return path
31
31
32 def _getstorehashcachename(remotepath):
32 def _getstorehashcachename(remotepath):
33 '''get a unique filename for the store hash cache of a remote repository'''
33 '''get a unique filename for the store hash cache of a remote repository'''
34 return util.sha1(_expandedabspath(remotepath)).hexdigest()[0:12]
34 return util.sha1(_expandedabspath(remotepath)).hexdigest()[0:12]
35
35
36 class SubrepoAbort(error.Abort):
36 class SubrepoAbort(error.Abort):
37 """Exception class used to avoid handling a subrepo error more than once"""
37 """Exception class used to avoid handling a subrepo error more than once"""
38 def __init__(self, *args, **kw):
38 def __init__(self, *args, **kw):
39 error.Abort.__init__(self, *args, **kw)
39 error.Abort.__init__(self, *args, **kw)
40 self.subrepo = kw.get('subrepo')
40 self.subrepo = kw.get('subrepo')
41 self.cause = kw.get('cause')
41 self.cause = kw.get('cause')
42
42
43 def annotatesubrepoerror(func):
43 def annotatesubrepoerror(func):
44 def decoratedmethod(self, *args, **kargs):
44 def decoratedmethod(self, *args, **kargs):
45 try:
45 try:
46 res = func(self, *args, **kargs)
46 res = func(self, *args, **kargs)
47 except SubrepoAbort, ex:
47 except SubrepoAbort, ex:
48 # This exception has already been handled
48 # This exception has already been handled
49 raise ex
49 raise ex
50 except error.Abort, ex:
50 except error.Abort, ex:
51 subrepo = subrelpath(self)
51 subrepo = subrelpath(self)
52 errormsg = str(ex) + ' ' + _('(in subrepo %s)') % subrepo
52 errormsg = str(ex) + ' ' + _('(in subrepo %s)') % subrepo
53 # avoid handling this exception by raising a SubrepoAbort exception
53 # avoid handling this exception by raising a SubrepoAbort exception
54 raise SubrepoAbort(errormsg, hint=ex.hint, subrepo=subrepo,
54 raise SubrepoAbort(errormsg, hint=ex.hint, subrepo=subrepo,
55 cause=sys.exc_info())
55 cause=sys.exc_info())
56 return res
56 return res
57 return decoratedmethod
57 return decoratedmethod
58
58
59 def state(ctx, ui):
59 def state(ctx, ui):
60 """return a state dict, mapping subrepo paths configured in .hgsub
60 """return a state dict, mapping subrepo paths configured in .hgsub
61 to tuple: (source from .hgsub, revision from .hgsubstate, kind
61 to tuple: (source from .hgsub, revision from .hgsubstate, kind
62 (key in types dict))
62 (key in types dict))
63 """
63 """
64 p = config.config()
64 p = config.config()
65 def read(f, sections=None, remap=None):
65 def read(f, sections=None, remap=None):
66 if f in ctx:
66 if f in ctx:
67 try:
67 try:
68 data = ctx[f].data()
68 data = ctx[f].data()
69 except IOError, err:
69 except IOError, err:
70 if err.errno != errno.ENOENT:
70 if err.errno != errno.ENOENT:
71 raise
71 raise
72 # handle missing subrepo spec files as removed
72 # handle missing subrepo spec files as removed
73 ui.warn(_("warning: subrepo spec file %s not found\n") % f)
73 ui.warn(_("warning: subrepo spec file %s not found\n") % f)
74 return
74 return
75 p.parse(f, data, sections, remap, read)
75 p.parse(f, data, sections, remap, read)
76 else:
76 else:
77 raise util.Abort(_("subrepo spec file %s not found") % f)
77 raise util.Abort(_("subrepo spec file %s not found") % f)
78
78
79 if '.hgsub' in ctx:
79 if '.hgsub' in ctx:
80 read('.hgsub')
80 read('.hgsub')
81
81
82 for path, src in ui.configitems('subpaths'):
82 for path, src in ui.configitems('subpaths'):
83 p.set('subpaths', path, src, ui.configsource('subpaths', path))
83 p.set('subpaths', path, src, ui.configsource('subpaths', path))
84
84
85 rev = {}
85 rev = {}
86 if '.hgsubstate' in ctx:
86 if '.hgsubstate' in ctx:
87 try:
87 try:
88 for i, l in enumerate(ctx['.hgsubstate'].data().splitlines()):
88 for i, l in enumerate(ctx['.hgsubstate'].data().splitlines()):
89 l = l.lstrip()
89 l = l.lstrip()
90 if not l:
90 if not l:
91 continue
91 continue
92 try:
92 try:
93 revision, path = l.split(" ", 1)
93 revision, path = l.split(" ", 1)
94 except ValueError:
94 except ValueError:
95 raise util.Abort(_("invalid subrepository revision "
95 raise util.Abort(_("invalid subrepository revision "
96 "specifier in .hgsubstate line %d")
96 "specifier in .hgsubstate line %d")
97 % (i + 1))
97 % (i + 1))
98 rev[path] = revision
98 rev[path] = revision
99 except IOError, err:
99 except IOError, err:
100 if err.errno != errno.ENOENT:
100 if err.errno != errno.ENOENT:
101 raise
101 raise
102
102
103 def remap(src):
103 def remap(src):
104 for pattern, repl in p.items('subpaths'):
104 for pattern, repl in p.items('subpaths'):
105 # Turn r'C:\foo\bar' into r'C:\\foo\\bar' since re.sub
105 # Turn r'C:\foo\bar' into r'C:\\foo\\bar' since re.sub
106 # does a string decode.
106 # does a string decode.
107 repl = repl.encode('string-escape')
107 repl = repl.encode('string-escape')
108 # However, we still want to allow back references to go
108 # However, we still want to allow back references to go
109 # through unharmed, so we turn r'\\1' into r'\1'. Again,
109 # through unharmed, so we turn r'\\1' into r'\1'. Again,
110 # extra escapes are needed because re.sub string decodes.
110 # extra escapes are needed because re.sub string decodes.
111 repl = re.sub(r'\\\\([0-9]+)', r'\\\1', repl)
111 repl = re.sub(r'\\\\([0-9]+)', r'\\\1', repl)
112 try:
112 try:
113 src = re.sub(pattern, repl, src, 1)
113 src = re.sub(pattern, repl, src, 1)
114 except re.error, e:
114 except re.error, e:
115 raise util.Abort(_("bad subrepository pattern in %s: %s")
115 raise util.Abort(_("bad subrepository pattern in %s: %s")
116 % (p.source('subpaths', pattern), e))
116 % (p.source('subpaths', pattern), e))
117 return src
117 return src
118
118
119 state = {}
119 state = {}
120 for path, src in p[''].items():
120 for path, src in p[''].items():
121 kind = 'hg'
121 kind = 'hg'
122 if src.startswith('['):
122 if src.startswith('['):
123 if ']' not in src:
123 if ']' not in src:
124 raise util.Abort(_('missing ] in subrepo source'))
124 raise util.Abort(_('missing ] in subrepo source'))
125 kind, src = src.split(']', 1)
125 kind, src = src.split(']', 1)
126 kind = kind[1:]
126 kind = kind[1:]
127 src = src.lstrip() # strip any extra whitespace after ']'
127 src = src.lstrip() # strip any extra whitespace after ']'
128
128
129 if not util.url(src).isabs():
129 if not util.url(src).isabs():
130 parent = _abssource(ctx._repo, abort=False)
130 parent = _abssource(ctx._repo, abort=False)
131 if parent:
131 if parent:
132 parent = util.url(parent)
132 parent = util.url(parent)
133 parent.path = posixpath.join(parent.path or '', src)
133 parent.path = posixpath.join(parent.path or '', src)
134 parent.path = posixpath.normpath(parent.path)
134 parent.path = posixpath.normpath(parent.path)
135 joined = str(parent)
135 joined = str(parent)
136 # Remap the full joined path and use it if it changes,
136 # Remap the full joined path and use it if it changes,
137 # else remap the original source.
137 # else remap the original source.
138 remapped = remap(joined)
138 remapped = remap(joined)
139 if remapped == joined:
139 if remapped == joined:
140 src = remap(src)
140 src = remap(src)
141 else:
141 else:
142 src = remapped
142 src = remapped
143
143
144 src = remap(src)
144 src = remap(src)
145 state[util.pconvert(path)] = (src.strip(), rev.get(path, ''), kind)
145 state[util.pconvert(path)] = (src.strip(), rev.get(path, ''), kind)
146
146
147 return state
147 return state
148
148
149 def writestate(repo, state):
149 def writestate(repo, state):
150 """rewrite .hgsubstate in (outer) repo with these subrepo states"""
150 """rewrite .hgsubstate in (outer) repo with these subrepo states"""
151 lines = ['%s %s\n' % (state[s][1], s) for s in sorted(state)]
151 lines = ['%s %s\n' % (state[s][1], s) for s in sorted(state)]
152 repo.wwrite('.hgsubstate', ''.join(lines), '')
152 repo.wwrite('.hgsubstate', ''.join(lines), '')
153
153
154 def submerge(repo, wctx, mctx, actx, overwrite):
154 def submerge(repo, wctx, mctx, actx, overwrite):
155 """delegated from merge.applyupdates: merging of .hgsubstate file
155 """delegated from merge.applyupdates: merging of .hgsubstate file
156 in working context, merging context and ancestor context"""
156 in working context, merging context and ancestor context"""
157 if mctx == actx: # backwards?
157 if mctx == actx: # backwards?
158 actx = wctx.p1()
158 actx = wctx.p1()
159 s1 = wctx.substate
159 s1 = wctx.substate
160 s2 = mctx.substate
160 s2 = mctx.substate
161 sa = actx.substate
161 sa = actx.substate
162 sm = {}
162 sm = {}
163
163
164 repo.ui.debug("subrepo merge %s %s %s\n" % (wctx, mctx, actx))
164 repo.ui.debug("subrepo merge %s %s %s\n" % (wctx, mctx, actx))
165
165
166 def debug(s, msg, r=""):
166 def debug(s, msg, r=""):
167 if r:
167 if r:
168 r = "%s:%s:%s" % r
168 r = "%s:%s:%s" % r
169 repo.ui.debug(" subrepo %s: %s %s\n" % (s, msg, r))
169 repo.ui.debug(" subrepo %s: %s %s\n" % (s, msg, r))
170
170
171 for s, l in sorted(s1.iteritems()):
171 for s, l in sorted(s1.iteritems()):
172 a = sa.get(s, nullstate)
172 a = sa.get(s, nullstate)
173 ld = l # local state with possible dirty flag for compares
173 ld = l # local state with possible dirty flag for compares
174 if wctx.sub(s).dirty():
174 if wctx.sub(s).dirty():
175 ld = (l[0], l[1] + "+")
175 ld = (l[0], l[1] + "+")
176 if wctx == actx: # overwrite
176 if wctx == actx: # overwrite
177 a = ld
177 a = ld
178
178
179 if s in s2:
179 if s in s2:
180 r = s2[s]
180 r = s2[s]
181 if ld == r or r == a: # no change or local is newer
181 if ld == r or r == a: # no change or local is newer
182 sm[s] = l
182 sm[s] = l
183 continue
183 continue
184 elif ld == a: # other side changed
184 elif ld == a: # other side changed
185 debug(s, "other changed, get", r)
185 debug(s, "other changed, get", r)
186 wctx.sub(s).get(r, overwrite)
186 wctx.sub(s).get(r, overwrite)
187 sm[s] = r
187 sm[s] = r
188 elif ld[0] != r[0]: # sources differ
188 elif ld[0] != r[0]: # sources differ
189 if repo.ui.promptchoice(
189 if repo.ui.promptchoice(
190 _(' subrepository sources for %s differ\n'
190 _(' subrepository sources for %s differ\n'
191 'use (l)ocal source (%s) or (r)emote source (%s)?'
191 'use (l)ocal source (%s) or (r)emote source (%s)?'
192 '$$ &Local $$ &Remote') % (s, l[0], r[0]), 0):
192 '$$ &Local $$ &Remote') % (s, l[0], r[0]), 0):
193 debug(s, "prompt changed, get", r)
193 debug(s, "prompt changed, get", r)
194 wctx.sub(s).get(r, overwrite)
194 wctx.sub(s).get(r, overwrite)
195 sm[s] = r
195 sm[s] = r
196 elif ld[1] == a[1]: # local side is unchanged
196 elif ld[1] == a[1]: # local side is unchanged
197 debug(s, "other side changed, get", r)
197 debug(s, "other side changed, get", r)
198 wctx.sub(s).get(r, overwrite)
198 wctx.sub(s).get(r, overwrite)
199 sm[s] = r
199 sm[s] = r
200 else:
200 else:
201 debug(s, "both sides changed")
201 debug(s, "both sides changed")
202 srepo = wctx.sub(s)
202 srepo = wctx.sub(s)
203 option = repo.ui.promptchoice(
203 option = repo.ui.promptchoice(
204 _(' subrepository %s diverged (local revision: %s, '
204 _(' subrepository %s diverged (local revision: %s, '
205 'remote revision: %s)\n'
205 'remote revision: %s)\n'
206 '(M)erge, keep (l)ocal or keep (r)emote?'
206 '(M)erge, keep (l)ocal or keep (r)emote?'
207 '$$ &Merge $$ &Local $$ &Remote')
207 '$$ &Merge $$ &Local $$ &Remote')
208 % (s, srepo.shortid(l[1]), srepo.shortid(r[1])), 0)
208 % (s, srepo.shortid(l[1]), srepo.shortid(r[1])), 0)
209 if option == 0:
209 if option == 0:
210 wctx.sub(s).merge(r)
210 wctx.sub(s).merge(r)
211 sm[s] = l
211 sm[s] = l
212 debug(s, "merge with", r)
212 debug(s, "merge with", r)
213 elif option == 1:
213 elif option == 1:
214 sm[s] = l
214 sm[s] = l
215 debug(s, "keep local subrepo revision", l)
215 debug(s, "keep local subrepo revision", l)
216 else:
216 else:
217 wctx.sub(s).get(r, overwrite)
217 wctx.sub(s).get(r, overwrite)
218 sm[s] = r
218 sm[s] = r
219 debug(s, "get remote subrepo revision", r)
219 debug(s, "get remote subrepo revision", r)
220 elif ld == a: # remote removed, local unchanged
220 elif ld == a: # remote removed, local unchanged
221 debug(s, "remote removed, remove")
221 debug(s, "remote removed, remove")
222 wctx.sub(s).remove()
222 wctx.sub(s).remove()
223 elif a == nullstate: # not present in remote or ancestor
223 elif a == nullstate: # not present in remote or ancestor
224 debug(s, "local added, keep")
224 debug(s, "local added, keep")
225 sm[s] = l
225 sm[s] = l
226 continue
226 continue
227 else:
227 else:
228 if repo.ui.promptchoice(
228 if repo.ui.promptchoice(
229 _(' local changed subrepository %s which remote removed\n'
229 _(' local changed subrepository %s which remote removed\n'
230 'use (c)hanged version or (d)elete?'
230 'use (c)hanged version or (d)elete?'
231 '$$ &Changed $$ &Delete') % s, 0):
231 '$$ &Changed $$ &Delete') % s, 0):
232 debug(s, "prompt remove")
232 debug(s, "prompt remove")
233 wctx.sub(s).remove()
233 wctx.sub(s).remove()
234
234
235 for s, r in sorted(s2.items()):
235 for s, r in sorted(s2.items()):
236 if s in s1:
236 if s in s1:
237 continue
237 continue
238 elif s not in sa:
238 elif s not in sa:
239 debug(s, "remote added, get", r)
239 debug(s, "remote added, get", r)
240 mctx.sub(s).get(r)
240 mctx.sub(s).get(r)
241 sm[s] = r
241 sm[s] = r
242 elif r != sa[s]:
242 elif r != sa[s]:
243 if repo.ui.promptchoice(
243 if repo.ui.promptchoice(
244 _(' remote changed subrepository %s which local removed\n'
244 _(' remote changed subrepository %s which local removed\n'
245 'use (c)hanged version or (d)elete?'
245 'use (c)hanged version or (d)elete?'
246 '$$ &Changed $$ &Delete') % s, 0) == 0:
246 '$$ &Changed $$ &Delete') % s, 0) == 0:
247 debug(s, "prompt recreate", r)
247 debug(s, "prompt recreate", r)
248 wctx.sub(s).get(r)
248 wctx.sub(s).get(r)
249 sm[s] = r
249 sm[s] = r
250
250
251 # record merged .hgsubstate
251 # record merged .hgsubstate
252 writestate(repo, sm)
252 writestate(repo, sm)
253 return sm
253 return sm
254
254
255 def _updateprompt(ui, sub, dirty, local, remote):
255 def _updateprompt(ui, sub, dirty, local, remote):
256 if dirty:
256 if dirty:
257 msg = (_(' subrepository sources for %s differ\n'
257 msg = (_(' subrepository sources for %s differ\n'
258 'use (l)ocal source (%s) or (r)emote source (%s)?'
258 'use (l)ocal source (%s) or (r)emote source (%s)?'
259 '$$ &Local $$ &Remote')
259 '$$ &Local $$ &Remote')
260 % (subrelpath(sub), local, remote))
260 % (subrelpath(sub), local, remote))
261 else:
261 else:
262 msg = (_(' subrepository sources for %s differ (in checked out '
262 msg = (_(' subrepository sources for %s differ (in checked out '
263 'version)\n'
263 'version)\n'
264 'use (l)ocal source (%s) or (r)emote source (%s)?'
264 'use (l)ocal source (%s) or (r)emote source (%s)?'
265 '$$ &Local $$ &Remote')
265 '$$ &Local $$ &Remote')
266 % (subrelpath(sub), local, remote))
266 % (subrelpath(sub), local, remote))
267 return ui.promptchoice(msg, 0)
267 return ui.promptchoice(msg, 0)
268
268
269 def reporelpath(repo):
269 def reporelpath(repo):
270 """return path to this (sub)repo as seen from outermost repo"""
270 """return path to this (sub)repo as seen from outermost repo"""
271 parent = repo
271 parent = repo
272 while util.safehasattr(parent, '_subparent'):
272 while util.safehasattr(parent, '_subparent'):
273 parent = parent._subparent
273 parent = parent._subparent
274 return repo.root[len(pathutil.normasprefix(parent.root)):]
274 return repo.root[len(pathutil.normasprefix(parent.root)):]
275
275
276 def subrelpath(sub):
276 def subrelpath(sub):
277 """return path to this subrepo as seen from outermost repo"""
277 """return path to this subrepo as seen from outermost repo"""
278 if util.safehasattr(sub, '_relpath'):
278 if util.safehasattr(sub, '_relpath'):
279 return sub._relpath
279 return sub._relpath
280 if not util.safehasattr(sub, '_repo'):
280 if not util.safehasattr(sub, '_repo'):
281 return sub._path
281 return sub._path
282 return reporelpath(sub._repo)
282 return reporelpath(sub._repo)
283
283
284 def _abssource(repo, push=False, abort=True):
284 def _abssource(repo, push=False, abort=True):
285 """return pull/push path of repo - either based on parent repo .hgsub info
285 """return pull/push path of repo - either based on parent repo .hgsub info
286 or on the top repo config. Abort or return None if no source found."""
286 or on the top repo config. Abort or return None if no source found."""
287 if util.safehasattr(repo, '_subparent'):
287 if util.safehasattr(repo, '_subparent'):
288 source = util.url(repo._subsource)
288 source = util.url(repo._subsource)
289 if source.isabs():
289 if source.isabs():
290 return str(source)
290 return str(source)
291 source.path = posixpath.normpath(source.path)
291 source.path = posixpath.normpath(source.path)
292 parent = _abssource(repo._subparent, push, abort=False)
292 parent = _abssource(repo._subparent, push, abort=False)
293 if parent:
293 if parent:
294 parent = util.url(util.pconvert(parent))
294 parent = util.url(util.pconvert(parent))
295 parent.path = posixpath.join(parent.path or '', source.path)
295 parent.path = posixpath.join(parent.path or '', source.path)
296 parent.path = posixpath.normpath(parent.path)
296 parent.path = posixpath.normpath(parent.path)
297 return str(parent)
297 return str(parent)
298 else: # recursion reached top repo
298 else: # recursion reached top repo
299 if util.safehasattr(repo, '_subtoppath'):
299 if util.safehasattr(repo, '_subtoppath'):
300 return repo._subtoppath
300 return repo._subtoppath
301 if push and repo.ui.config('paths', 'default-push'):
301 if push and repo.ui.config('paths', 'default-push'):
302 return repo.ui.config('paths', 'default-push')
302 return repo.ui.config('paths', 'default-push')
303 if repo.ui.config('paths', 'default'):
303 if repo.ui.config('paths', 'default'):
304 return repo.ui.config('paths', 'default')
304 return repo.ui.config('paths', 'default')
305 if repo.shared():
305 if repo.shared():
306 # chop off the .hg component to get the default path form
306 # chop off the .hg component to get the default path form
307 return os.path.dirname(repo.sharedpath)
307 return os.path.dirname(repo.sharedpath)
308 if abort:
308 if abort:
309 raise util.Abort(_("default path for subrepository not found"))
309 raise util.Abort(_("default path for subrepository not found"))
310
310
311 def _sanitize(ui, path, ignore):
311 def _sanitize(ui, path, ignore):
312 for dirname, dirs, names in os.walk(path):
312 for dirname, dirs, names in os.walk(path):
313 for i, d in enumerate(dirs):
313 for i, d in enumerate(dirs):
314 if d.lower() == ignore:
314 if d.lower() == ignore:
315 del dirs[i]
315 del dirs[i]
316 break
316 break
317 if os.path.basename(dirname).lower() != '.hg':
317 if os.path.basename(dirname).lower() != '.hg':
318 continue
318 continue
319 for f in names:
319 for f in names:
320 if f.lower() == 'hgrc':
320 if f.lower() == 'hgrc':
321 ui.warn(_("warning: removing potentially hostile 'hgrc' "
321 ui.warn(_("warning: removing potentially hostile 'hgrc' "
322 "in '%s'\n") % dirname)
322 "in '%s'\n") % dirname)
323 os.unlink(os.path.join(dirname, f))
323 os.unlink(os.path.join(dirname, f))
324
324
325 def subrepo(ctx, path):
325 def subrepo(ctx, path):
326 """return instance of the right subrepo class for subrepo in path"""
326 """return instance of the right subrepo class for subrepo in path"""
327 # subrepo inherently violates our import layering rules
327 # subrepo inherently violates our import layering rules
328 # because it wants to make repo objects from deep inside the stack
328 # because it wants to make repo objects from deep inside the stack
329 # so we manually delay the circular imports to not break
329 # so we manually delay the circular imports to not break
330 # scripts that don't use our demand-loading
330 # scripts that don't use our demand-loading
331 global hg
331 global hg
332 import hg as h
332 import hg as h
333 hg = h
333 hg = h
334
334
335 pathutil.pathauditor(ctx._repo.root)(path)
335 pathutil.pathauditor(ctx._repo.root)(path)
336 state = ctx.substate[path]
336 state = ctx.substate[path]
337 if state[2] not in types:
337 if state[2] not in types:
338 raise util.Abort(_('unknown subrepo type %s') % state[2])
338 raise util.Abort(_('unknown subrepo type %s') % state[2])
339 return types[state[2]](ctx, path, state[:2])
339 return types[state[2]](ctx, path, state[:2])
340
340
341 def newcommitphase(ui, ctx):
341 def newcommitphase(ui, ctx):
342 commitphase = phases.newcommitphase(ui)
342 commitphase = phases.newcommitphase(ui)
343 substate = getattr(ctx, "substate", None)
343 substate = getattr(ctx, "substate", None)
344 if not substate:
344 if not substate:
345 return commitphase
345 return commitphase
346 check = ui.config('phases', 'checksubrepos', 'follow')
346 check = ui.config('phases', 'checksubrepos', 'follow')
347 if check not in ('ignore', 'follow', 'abort'):
347 if check not in ('ignore', 'follow', 'abort'):
348 raise util.Abort(_('invalid phases.checksubrepos configuration: %s')
348 raise util.Abort(_('invalid phases.checksubrepos configuration: %s')
349 % (check))
349 % (check))
350 if check == 'ignore':
350 if check == 'ignore':
351 return commitphase
351 return commitphase
352 maxphase = phases.public
352 maxphase = phases.public
353 maxsub = None
353 maxsub = None
354 for s in sorted(substate):
354 for s in sorted(substate):
355 sub = ctx.sub(s)
355 sub = ctx.sub(s)
356 subphase = sub.phase(substate[s][1])
356 subphase = sub.phase(substate[s][1])
357 if maxphase < subphase:
357 if maxphase < subphase:
358 maxphase = subphase
358 maxphase = subphase
359 maxsub = s
359 maxsub = s
360 if commitphase < maxphase:
360 if commitphase < maxphase:
361 if check == 'abort':
361 if check == 'abort':
362 raise util.Abort(_("can't commit in %s phase"
362 raise util.Abort(_("can't commit in %s phase"
363 " conflicting %s from subrepository %s") %
363 " conflicting %s from subrepository %s") %
364 (phases.phasenames[commitphase],
364 (phases.phasenames[commitphase],
365 phases.phasenames[maxphase], maxsub))
365 phases.phasenames[maxphase], maxsub))
366 ui.warn(_("warning: changes are committed in"
366 ui.warn(_("warning: changes are committed in"
367 " %s phase from subrepository %s\n") %
367 " %s phase from subrepository %s\n") %
368 (phases.phasenames[maxphase], maxsub))
368 (phases.phasenames[maxphase], maxsub))
369 return maxphase
369 return maxphase
370 return commitphase
370 return commitphase
371
371
372 # subrepo classes need to implement the following abstract class:
372 # subrepo classes need to implement the following abstract class:
373
373
374 class abstractsubrepo(object):
374 class abstractsubrepo(object):
375
375
376 def __init__(self, ui):
376 def __init__(self, ui):
377 self.ui = ui
377 self.ui = ui
378
378
379 def storeclean(self, path):
379 def storeclean(self, path):
380 """
380 """
381 returns true if the repository has not changed since it was last
381 returns true if the repository has not changed since it was last
382 cloned from or pushed to a given repository.
382 cloned from or pushed to a given repository.
383 """
383 """
384 return False
384 return False
385
385
386 def dirty(self, ignoreupdate=False):
386 def dirty(self, ignoreupdate=False):
387 """returns true if the dirstate of the subrepo is dirty or does not
387 """returns true if the dirstate of the subrepo is dirty or does not
388 match current stored state. If ignoreupdate is true, only check
388 match current stored state. If ignoreupdate is true, only check
389 whether the subrepo has uncommitted changes in its dirstate.
389 whether the subrepo has uncommitted changes in its dirstate.
390 """
390 """
391 raise NotImplementedError
391 raise NotImplementedError
392
392
393 def basestate(self):
393 def basestate(self):
394 """current working directory base state, disregarding .hgsubstate
394 """current working directory base state, disregarding .hgsubstate
395 state and working directory modifications"""
395 state and working directory modifications"""
396 raise NotImplementedError
396 raise NotImplementedError
397
397
398 def checknested(self, path):
398 def checknested(self, path):
399 """check if path is a subrepository within this repository"""
399 """check if path is a subrepository within this repository"""
400 return False
400 return False
401
401
402 def commit(self, text, user, date):
402 def commit(self, text, user, date):
403 """commit the current changes to the subrepo with the given
403 """commit the current changes to the subrepo with the given
404 log message. Use given user and date if possible. Return the
404 log message. Use given user and date if possible. Return the
405 new state of the subrepo.
405 new state of the subrepo.
406 """
406 """
407 raise NotImplementedError
407 raise NotImplementedError
408
408
409 def phase(self, state):
409 def phase(self, state):
410 """returns phase of specified state in the subrepository.
410 """returns phase of specified state in the subrepository.
411 """
411 """
412 return phases.public
412 return phases.public
413
413
414 def remove(self):
414 def remove(self):
415 """remove the subrepo
415 """remove the subrepo
416
416
417 (should verify the dirstate is not dirty first)
417 (should verify the dirstate is not dirty first)
418 """
418 """
419 raise NotImplementedError
419 raise NotImplementedError
420
420
421 def get(self, state, overwrite=False):
421 def get(self, state, overwrite=False):
422 """run whatever commands are needed to put the subrepo into
422 """run whatever commands are needed to put the subrepo into
423 this state
423 this state
424 """
424 """
425 raise NotImplementedError
425 raise NotImplementedError
426
426
427 def merge(self, state):
427 def merge(self, state):
428 """merge currently-saved state with the new state."""
428 """merge currently-saved state with the new state."""
429 raise NotImplementedError
429 raise NotImplementedError
430
430
431 def push(self, opts):
431 def push(self, opts):
432 """perform whatever action is analogous to 'hg push'
432 """perform whatever action is analogous to 'hg push'
433
433
434 This may be a no-op on some systems.
434 This may be a no-op on some systems.
435 """
435 """
436 raise NotImplementedError
436 raise NotImplementedError
437
437
438 def add(self, ui, match, dryrun, listsubrepos, prefix, explicitonly):
438 def add(self, ui, match, dryrun, listsubrepos, prefix, explicitonly):
439 return []
439 return []
440
440
441 def addremove(self, matcher, prefix, opts, dry_run, similarity):
441 def addremove(self, matcher, prefix, opts, dry_run, similarity):
442 self.ui.warn("%s: %s" % (prefix, _("addremove is not supported")))
442 self.ui.warn("%s: %s" % (prefix, _("addremove is not supported")))
443 return 1
443 return 1
444
444
445 def cat(self, match, prefix, **opts):
445 def cat(self, match, prefix, **opts):
446 return 1
446 return 1
447
447
448 def status(self, rev2, **opts):
448 def status(self, rev2, **opts):
449 return scmutil.status([], [], [], [], [], [], [])
449 return scmutil.status([], [], [], [], [], [], [])
450
450
451 def diff(self, ui, diffopts, node2, match, prefix, **opts):
451 def diff(self, ui, diffopts, node2, match, prefix, **opts):
452 pass
452 pass
453
453
454 def outgoing(self, ui, dest, opts):
454 def outgoing(self, ui, dest, opts):
455 return 1
455 return 1
456
456
457 def incoming(self, ui, source, opts):
457 def incoming(self, ui, source, opts):
458 return 1
458 return 1
459
459
460 def files(self):
460 def files(self):
461 """return filename iterator"""
461 """return filename iterator"""
462 raise NotImplementedError
462 raise NotImplementedError
463
463
464 def filedata(self, name):
464 def filedata(self, name):
465 """return file data"""
465 """return file data"""
466 raise NotImplementedError
466 raise NotImplementedError
467
467
468 def fileflags(self, name):
468 def fileflags(self, name):
469 """return file flags"""
469 """return file flags"""
470 return ''
470 return ''
471
471
472 def archive(self, archiver, prefix, match=None):
472 def archive(self, archiver, prefix, match=None):
473 if match is not None:
473 if match is not None:
474 files = [f for f in self.files() if match(f)]
474 files = [f for f in self.files() if match(f)]
475 else:
475 else:
476 files = self.files()
476 files = self.files()
477 total = len(files)
477 total = len(files)
478 relpath = subrelpath(self)
478 relpath = subrelpath(self)
479 self.ui.progress(_('archiving (%s)') % relpath, 0,
479 self.ui.progress(_('archiving (%s)') % relpath, 0,
480 unit=_('files'), total=total)
480 unit=_('files'), total=total)
481 for i, name in enumerate(files):
481 for i, name in enumerate(files):
482 flags = self.fileflags(name)
482 flags = self.fileflags(name)
483 mode = 'x' in flags and 0755 or 0644
483 mode = 'x' in flags and 0755 or 0644
484 symlink = 'l' in flags
484 symlink = 'l' in flags
485 archiver.addfile(os.path.join(prefix, self._path, name),
485 archiver.addfile(os.path.join(prefix, self._path, name),
486 mode, symlink, self.filedata(name))
486 mode, symlink, self.filedata(name))
487 self.ui.progress(_('archiving (%s)') % relpath, i + 1,
487 self.ui.progress(_('archiving (%s)') % relpath, i + 1,
488 unit=_('files'), total=total)
488 unit=_('files'), total=total)
489 self.ui.progress(_('archiving (%s)') % relpath, None)
489 self.ui.progress(_('archiving (%s)') % relpath, None)
490 return total
490 return total
491
491
492 def walk(self, match):
492 def walk(self, match):
493 '''
493 '''
494 walk recursively through the directory tree, finding all files
494 walk recursively through the directory tree, finding all files
495 matched by the match function
495 matched by the match function
496 '''
496 '''
497 pass
497 pass
498
498
499 def forget(self, match, prefix):
499 def forget(self, match, prefix):
500 return ([], [])
500 return ([], [])
501
501
502 def removefiles(self, matcher, prefix, after, force, subrepos):
502 def removefiles(self, matcher, prefix, after, force, subrepos):
503 """remove the matched files from the subrepository and the filesystem,
503 """remove the matched files from the subrepository and the filesystem,
504 possibly by force and/or after the file has been removed from the
504 possibly by force and/or after the file has been removed from the
505 filesystem. Return 0 on success, 1 on any warning.
505 filesystem. Return 0 on success, 1 on any warning.
506 """
506 """
507 return 1
507 return 1
508
508
509 def revert(self, substate, *pats, **opts):
509 def revert(self, substate, *pats, **opts):
510 self.ui.warn('%s: reverting %s subrepos is unsupported\n' \
510 self.ui.warn('%s: reverting %s subrepos is unsupported\n' \
511 % (substate[0], substate[2]))
511 % (substate[0], substate[2]))
512 return []
512 return []
513
513
514 def shortid(self, revid):
514 def shortid(self, revid):
515 return revid
515 return revid
516
516
517 class hgsubrepo(abstractsubrepo):
517 class hgsubrepo(abstractsubrepo):
518 def __init__(self, ctx, path, state):
518 def __init__(self, ctx, path, state):
519 super(hgsubrepo, self).__init__(ctx._repo.ui)
519 super(hgsubrepo, self).__init__(ctx._repo.ui)
520 self._path = path
520 self._path = path
521 self._state = state
521 self._state = state
522 r = ctx._repo
522 r = ctx._repo
523 root = r.wjoin(path)
523 root = r.wjoin(path)
524 create = not r.wvfs.exists('%s/.hg' % path)
524 create = not r.wvfs.exists('%s/.hg' % path)
525 self._repo = hg.repository(r.baseui, root, create=create)
525 self._repo = hg.repository(r.baseui, root, create=create)
526 self.ui = self._repo.ui
526 self.ui = self._repo.ui
527 for s, k in [('ui', 'commitsubrepos')]:
527 for s, k in [('ui', 'commitsubrepos')]:
528 v = r.ui.config(s, k)
528 v = r.ui.config(s, k)
529 if v:
529 if v:
530 self.ui.setconfig(s, k, v, 'subrepo')
530 self.ui.setconfig(s, k, v, 'subrepo')
531 self.ui.setconfig('ui', '_usedassubrepo', 'True', 'subrepo')
531 self.ui.setconfig('ui', '_usedassubrepo', 'True', 'subrepo')
532 self._initrepo(r, state[0], create)
532 self._initrepo(r, state[0], create)
533
533
534 def storeclean(self, path):
534 def storeclean(self, path):
535 lock = self._repo.lock()
535 lock = self._repo.lock()
536 try:
536 try:
537 return self._storeclean(path)
537 return self._storeclean(path)
538 finally:
538 finally:
539 lock.release()
539 lock.release()
540
540
541 def _storeclean(self, path):
541 def _storeclean(self, path):
542 clean = True
542 clean = True
543 itercache = self._calcstorehash(path)
543 itercache = self._calcstorehash(path)
544 try:
544 try:
545 for filehash in self._readstorehashcache(path):
545 for filehash in self._readstorehashcache(path):
546 if filehash != itercache.next():
546 if filehash != itercache.next():
547 clean = False
547 clean = False
548 break
548 break
549 except StopIteration:
549 except StopIteration:
550 # the cached and current pull states have a different size
550 # the cached and current pull states have a different size
551 clean = False
551 clean = False
552 if clean:
552 if clean:
553 try:
553 try:
554 itercache.next()
554 itercache.next()
555 # the cached and current pull states have a different size
555 # the cached and current pull states have a different size
556 clean = False
556 clean = False
557 except StopIteration:
557 except StopIteration:
558 pass
558 pass
559 return clean
559 return clean
560
560
561 def _calcstorehash(self, remotepath):
561 def _calcstorehash(self, remotepath):
562 '''calculate a unique "store hash"
562 '''calculate a unique "store hash"
563
563
564 This method is used to to detect when there are changes that may
564 This method is used to to detect when there are changes that may
565 require a push to a given remote path.'''
565 require a push to a given remote path.'''
566 # sort the files that will be hashed in increasing (likely) file size
566 # sort the files that will be hashed in increasing (likely) file size
567 filelist = ('bookmarks', 'store/phaseroots', 'store/00changelog.i')
567 filelist = ('bookmarks', 'store/phaseroots', 'store/00changelog.i')
568 yield '# %s\n' % _expandedabspath(remotepath)
568 yield '# %s\n' % _expandedabspath(remotepath)
569 vfs = self._repo.vfs
569 vfs = self._repo.vfs
570 for relname in filelist:
570 for relname in filelist:
571 filehash = util.sha1(vfs.tryread(relname)).hexdigest()
571 filehash = util.sha1(vfs.tryread(relname)).hexdigest()
572 yield '%s = %s\n' % (relname, filehash)
572 yield '%s = %s\n' % (relname, filehash)
573
573
574 @propertycache
574 @propertycache
575 def _cachestorehashvfs(self):
575 def _cachestorehashvfs(self):
576 return scmutil.vfs(self._repo.join('cache/storehash'))
576 return scmutil.vfs(self._repo.join('cache/storehash'))
577
577
578 def _readstorehashcache(self, remotepath):
578 def _readstorehashcache(self, remotepath):
579 '''read the store hash cache for a given remote repository'''
579 '''read the store hash cache for a given remote repository'''
580 cachefile = _getstorehashcachename(remotepath)
580 cachefile = _getstorehashcachename(remotepath)
581 return self._cachestorehashvfs.tryreadlines(cachefile, 'r')
581 return self._cachestorehashvfs.tryreadlines(cachefile, 'r')
582
582
583 def _cachestorehash(self, remotepath):
583 def _cachestorehash(self, remotepath):
584 '''cache the current store hash
584 '''cache the current store hash
585
585
586 Each remote repo requires its own store hash cache, because a subrepo
586 Each remote repo requires its own store hash cache, because a subrepo
587 store may be "clean" versus a given remote repo, but not versus another
587 store may be "clean" versus a given remote repo, but not versus another
588 '''
588 '''
589 cachefile = _getstorehashcachename(remotepath)
589 cachefile = _getstorehashcachename(remotepath)
590 lock = self._repo.lock()
590 lock = self._repo.lock()
591 try:
591 try:
592 storehash = list(self._calcstorehash(remotepath))
592 storehash = list(self._calcstorehash(remotepath))
593 vfs = self._cachestorehashvfs
593 vfs = self._cachestorehashvfs
594 vfs.writelines(cachefile, storehash, mode='w', notindexed=True)
594 vfs.writelines(cachefile, storehash, mode='w', notindexed=True)
595 finally:
595 finally:
596 lock.release()
596 lock.release()
597
597
598 @annotatesubrepoerror
598 @annotatesubrepoerror
599 def _initrepo(self, parentrepo, source, create):
599 def _initrepo(self, parentrepo, source, create):
600 self._repo._subparent = parentrepo
600 self._repo._subparent = parentrepo
601 self._repo._subsource = source
601 self._repo._subsource = source
602
602
603 if create:
603 if create:
604 lines = ['[paths]\n']
604 lines = ['[paths]\n']
605
605
606 def addpathconfig(key, value):
606 def addpathconfig(key, value):
607 if value:
607 if value:
608 lines.append('%s = %s\n' % (key, value))
608 lines.append('%s = %s\n' % (key, value))
609 self.ui.setconfig('paths', key, value, 'subrepo')
609 self.ui.setconfig('paths', key, value, 'subrepo')
610
610
611 defpath = _abssource(self._repo, abort=False)
611 defpath = _abssource(self._repo, abort=False)
612 defpushpath = _abssource(self._repo, True, abort=False)
612 defpushpath = _abssource(self._repo, True, abort=False)
613 addpathconfig('default', defpath)
613 addpathconfig('default', defpath)
614 if defpath != defpushpath:
614 if defpath != defpushpath:
615 addpathconfig('default-push', defpushpath)
615 addpathconfig('default-push', defpushpath)
616
616
617 fp = self._repo.opener("hgrc", "w", text=True)
617 fp = self._repo.opener("hgrc", "w", text=True)
618 try:
618 try:
619 fp.write(''.join(lines))
619 fp.write(''.join(lines))
620 finally:
620 finally:
621 fp.close()
621 fp.close()
622
622
623 @annotatesubrepoerror
623 @annotatesubrepoerror
624 def add(self, ui, match, dryrun, listsubrepos, prefix, explicitonly):
624 def add(self, ui, match, dryrun, listsubrepos, prefix, explicitonly):
625 return cmdutil.add(ui, self._repo, match, dryrun, listsubrepos,
625 return cmdutil.add(ui, self._repo, match, dryrun, listsubrepos,
626 os.path.join(prefix, self._path), explicitonly)
626 os.path.join(prefix, self._path), explicitonly)
627
627
628 def addremove(self, m, prefix, opts, dry_run, similarity):
628 def addremove(self, m, prefix, opts, dry_run, similarity):
629 # In the same way as sub directories are processed, once in a subrepo,
629 # In the same way as sub directories are processed, once in a subrepo,
630 # always entry any of its subrepos. Don't corrupt the options that will
630 # always entry any of its subrepos. Don't corrupt the options that will
631 # be used to process sibling subrepos however.
631 # be used to process sibling subrepos however.
632 opts = copy.copy(opts)
632 opts = copy.copy(opts)
633 opts['subrepos'] = True
633 opts['subrepos'] = True
634 return scmutil.addremove(self._repo, m,
634 return scmutil.addremove(self._repo, m,
635 os.path.join(prefix, self._path), opts,
635 os.path.join(prefix, self._path), opts,
636 dry_run, similarity)
636 dry_run, similarity)
637
637
638 @annotatesubrepoerror
638 @annotatesubrepoerror
639 def cat(self, match, prefix, **opts):
639 def cat(self, match, prefix, **opts):
640 rev = self._state[1]
640 rev = self._state[1]
641 ctx = self._repo[rev]
641 ctx = self._repo[rev]
642 return cmdutil.cat(self.ui, self._repo, ctx, match, prefix, **opts)
642 return cmdutil.cat(self.ui, self._repo, ctx, match, prefix, **opts)
643
643
644 @annotatesubrepoerror
644 @annotatesubrepoerror
645 def status(self, rev2, **opts):
645 def status(self, rev2, **opts):
646 try:
646 try:
647 rev1 = self._state[1]
647 rev1 = self._state[1]
648 ctx1 = self._repo[rev1]
648 ctx1 = self._repo[rev1]
649 ctx2 = self._repo[rev2]
649 ctx2 = self._repo[rev2]
650 return self._repo.status(ctx1, ctx2, **opts)
650 return self._repo.status(ctx1, ctx2, **opts)
651 except error.RepoLookupError, inst:
651 except error.RepoLookupError, inst:
652 self.ui.warn(_('warning: error "%s" in subrepository "%s"\n')
652 self.ui.warn(_('warning: error "%s" in subrepository "%s"\n')
653 % (inst, subrelpath(self)))
653 % (inst, subrelpath(self)))
654 return scmutil.status([], [], [], [], [], [], [])
654 return scmutil.status([], [], [], [], [], [], [])
655
655
656 @annotatesubrepoerror
656 @annotatesubrepoerror
657 def diff(self, ui, diffopts, node2, match, prefix, **opts):
657 def diff(self, ui, diffopts, node2, match, prefix, **opts):
658 try:
658 try:
659 node1 = node.bin(self._state[1])
659 node1 = node.bin(self._state[1])
660 # We currently expect node2 to come from substate and be
660 # We currently expect node2 to come from substate and be
661 # in hex format
661 # in hex format
662 if node2 is not None:
662 if node2 is not None:
663 node2 = node.bin(node2)
663 node2 = node.bin(node2)
664 cmdutil.diffordiffstat(ui, self._repo, diffopts,
664 cmdutil.diffordiffstat(ui, self._repo, diffopts,
665 node1, node2, match,
665 node1, node2, match,
666 prefix=posixpath.join(prefix, self._path),
666 prefix=posixpath.join(prefix, self._path),
667 listsubrepos=True, **opts)
667 listsubrepos=True, **opts)
668 except error.RepoLookupError, inst:
668 except error.RepoLookupError, inst:
669 self.ui.warn(_('warning: error "%s" in subrepository "%s"\n')
669 self.ui.warn(_('warning: error "%s" in subrepository "%s"\n')
670 % (inst, subrelpath(self)))
670 % (inst, subrelpath(self)))
671
671
672 @annotatesubrepoerror
672 @annotatesubrepoerror
673 def archive(self, archiver, prefix, match=None):
673 def archive(self, archiver, prefix, match=None):
674 self._get(self._state + ('hg',))
674 self._get(self._state + ('hg',))
675 total = abstractsubrepo.archive(self, archiver, prefix, match)
675 total = abstractsubrepo.archive(self, archiver, prefix, match)
676 rev = self._state[1]
676 rev = self._state[1]
677 ctx = self._repo[rev]
677 ctx = self._repo[rev]
678 for subpath in ctx.substate:
678 for subpath in ctx.substate:
679 s = subrepo(ctx, subpath)
679 s = subrepo(ctx, subpath)
680 submatch = matchmod.narrowmatcher(subpath, match)
680 submatch = matchmod.narrowmatcher(subpath, match)
681 total += s.archive(
681 total += s.archive(
682 archiver, os.path.join(prefix, self._path), submatch)
682 archiver, os.path.join(prefix, self._path), submatch)
683 return total
683 return total
684
684
685 @annotatesubrepoerror
685 @annotatesubrepoerror
686 def dirty(self, ignoreupdate=False):
686 def dirty(self, ignoreupdate=False):
687 r = self._state[1]
687 r = self._state[1]
688 if r == '' and not ignoreupdate: # no state recorded
688 if r == '' and not ignoreupdate: # no state recorded
689 return True
689 return True
690 w = self._repo[None]
690 w = self._repo[None]
691 if r != w.p1().hex() and not ignoreupdate:
691 if r != w.p1().hex() and not ignoreupdate:
692 # different version checked out
692 # different version checked out
693 return True
693 return True
694 return w.dirty() # working directory changed
694 return w.dirty() # working directory changed
695
695
696 def basestate(self):
696 def basestate(self):
697 return self._repo['.'].hex()
697 return self._repo['.'].hex()
698
698
699 def checknested(self, path):
699 def checknested(self, path):
700 return self._repo._checknested(self._repo.wjoin(path))
700 return self._repo._checknested(self._repo.wjoin(path))
701
701
702 @annotatesubrepoerror
702 @annotatesubrepoerror
703 def commit(self, text, user, date):
703 def commit(self, text, user, date):
704 # don't bother committing in the subrepo if it's only been
704 # don't bother committing in the subrepo if it's only been
705 # updated
705 # updated
706 if not self.dirty(True):
706 if not self.dirty(True):
707 return self._repo['.'].hex()
707 return self._repo['.'].hex()
708 self.ui.debug("committing subrepo %s\n" % subrelpath(self))
708 self.ui.debug("committing subrepo %s\n" % subrelpath(self))
709 n = self._repo.commit(text, user, date)
709 n = self._repo.commit(text, user, date)
710 if not n:
710 if not n:
711 return self._repo['.'].hex() # different version checked out
711 return self._repo['.'].hex() # different version checked out
712 return node.hex(n)
712 return node.hex(n)
713
713
714 @annotatesubrepoerror
714 @annotatesubrepoerror
715 def phase(self, state):
715 def phase(self, state):
716 return self._repo[state].phase()
716 return self._repo[state].phase()
717
717
718 @annotatesubrepoerror
718 @annotatesubrepoerror
719 def remove(self):
719 def remove(self):
720 # we can't fully delete the repository as it may contain
720 # we can't fully delete the repository as it may contain
721 # local-only history
721 # local-only history
722 self.ui.note(_('removing subrepo %s\n') % subrelpath(self))
722 self.ui.note(_('removing subrepo %s\n') % subrelpath(self))
723 hg.clean(self._repo, node.nullid, False)
723 hg.clean(self._repo, node.nullid, False)
724
724
725 def _get(self, state):
725 def _get(self, state):
726 source, revision, kind = state
726 source, revision, kind = state
727 if revision in self._repo.unfiltered():
727 if revision in self._repo.unfiltered():
728 return True
728 return True
729 self._repo._subsource = source
729 self._repo._subsource = source
730 srcurl = _abssource(self._repo)
730 srcurl = _abssource(self._repo)
731 other = hg.peer(self._repo, {}, srcurl)
731 other = hg.peer(self._repo, {}, srcurl)
732 if len(self._repo) == 0:
732 if len(self._repo) == 0:
733 self.ui.status(_('cloning subrepo %s from %s\n')
733 self.ui.status(_('cloning subrepo %s from %s\n')
734 % (subrelpath(self), srcurl))
734 % (subrelpath(self), srcurl))
735 parentrepo = self._repo._subparent
735 parentrepo = self._repo._subparent
736 shutil.rmtree(self._repo.path)
736 shutil.rmtree(self._repo.path)
737 other, cloned = hg.clone(self._repo._subparent.baseui, {},
737 other, cloned = hg.clone(self._repo._subparent.baseui, {},
738 other, self._repo.root,
738 other, self._repo.root,
739 update=False)
739 update=False)
740 self._repo = cloned.local()
740 self._repo = cloned.local()
741 self._initrepo(parentrepo, source, create=True)
741 self._initrepo(parentrepo, source, create=True)
742 self._cachestorehash(srcurl)
742 self._cachestorehash(srcurl)
743 else:
743 else:
744 self.ui.status(_('pulling subrepo %s from %s\n')
744 self.ui.status(_('pulling subrepo %s from %s\n')
745 % (subrelpath(self), srcurl))
745 % (subrelpath(self), srcurl))
746 cleansub = self.storeclean(srcurl)
746 cleansub = self.storeclean(srcurl)
747 exchange.pull(self._repo, other)
747 exchange.pull(self._repo, other)
748 if cleansub:
748 if cleansub:
749 # keep the repo clean after pull
749 # keep the repo clean after pull
750 self._cachestorehash(srcurl)
750 self._cachestorehash(srcurl)
751 return False
751 return False
752
752
753 @annotatesubrepoerror
753 @annotatesubrepoerror
754 def get(self, state, overwrite=False):
754 def get(self, state, overwrite=False):
755 inrepo = self._get(state)
755 inrepo = self._get(state)
756 source, revision, kind = state
756 source, revision, kind = state
757 repo = self._repo
757 repo = self._repo
758 repo.ui.debug("getting subrepo %s\n" % self._path)
758 repo.ui.debug("getting subrepo %s\n" % self._path)
759 if inrepo:
759 if inrepo:
760 urepo = repo.unfiltered()
760 urepo = repo.unfiltered()
761 ctx = urepo[revision]
761 ctx = urepo[revision]
762 if ctx.hidden():
762 if ctx.hidden():
763 urepo.ui.warn(
763 urepo.ui.warn(
764 _('revision %s in subrepo %s is hidden\n') \
764 _('revision %s in subrepo %s is hidden\n') \
765 % (revision[0:12], self._path))
765 % (revision[0:12], self._path))
766 repo = urepo
766 repo = urepo
767 hg.updaterepo(repo, revision, overwrite)
767 hg.updaterepo(repo, revision, overwrite)
768
768
769 @annotatesubrepoerror
769 @annotatesubrepoerror
770 def merge(self, state):
770 def merge(self, state):
771 self._get(state)
771 self._get(state)
772 cur = self._repo['.']
772 cur = self._repo['.']
773 dst = self._repo[state[1]]
773 dst = self._repo[state[1]]
774 anc = dst.ancestor(cur)
774 anc = dst.ancestor(cur)
775
775
776 def mergefunc():
776 def mergefunc():
777 if anc == cur and dst.branch() == cur.branch():
777 if anc == cur and dst.branch() == cur.branch():
778 self.ui.debug("updating subrepo %s\n" % subrelpath(self))
778 self.ui.debug("updating subrepo %s\n" % subrelpath(self))
779 hg.update(self._repo, state[1])
779 hg.update(self._repo, state[1])
780 elif anc == dst:
780 elif anc == dst:
781 self.ui.debug("skipping subrepo %s\n" % subrelpath(self))
781 self.ui.debug("skipping subrepo %s\n" % subrelpath(self))
782 else:
782 else:
783 self.ui.debug("merging subrepo %s\n" % subrelpath(self))
783 self.ui.debug("merging subrepo %s\n" % subrelpath(self))
784 hg.merge(self._repo, state[1], remind=False)
784 hg.merge(self._repo, state[1], remind=False)
785
785
786 wctx = self._repo[None]
786 wctx = self._repo[None]
787 if self.dirty():
787 if self.dirty():
788 if anc != dst:
788 if anc != dst:
789 if _updateprompt(self.ui, self, wctx.dirty(), cur, dst):
789 if _updateprompt(self.ui, self, wctx.dirty(), cur, dst):
790 mergefunc()
790 mergefunc()
791 else:
791 else:
792 mergefunc()
792 mergefunc()
793 else:
793 else:
794 mergefunc()
794 mergefunc()
795
795
796 @annotatesubrepoerror
796 @annotatesubrepoerror
797 def push(self, opts):
797 def push(self, opts):
798 force = opts.get('force')
798 force = opts.get('force')
799 newbranch = opts.get('new_branch')
799 newbranch = opts.get('new_branch')
800 ssh = opts.get('ssh')
800 ssh = opts.get('ssh')
801
801
802 # push subrepos depth-first for coherent ordering
802 # push subrepos depth-first for coherent ordering
803 c = self._repo['']
803 c = self._repo['']
804 subs = c.substate # only repos that are committed
804 subs = c.substate # only repos that are committed
805 for s in sorted(subs):
805 for s in sorted(subs):
806 if c.sub(s).push(opts) == 0:
806 if c.sub(s).push(opts) == 0:
807 return False
807 return False
808
808
809 dsturl = _abssource(self._repo, True)
809 dsturl = _abssource(self._repo, True)
810 if not force:
810 if not force:
811 if self.storeclean(dsturl):
811 if self.storeclean(dsturl):
812 self.ui.status(
812 self.ui.status(
813 _('no changes made to subrepo %s since last push to %s\n')
813 _('no changes made to subrepo %s since last push to %s\n')
814 % (subrelpath(self), dsturl))
814 % (subrelpath(self), dsturl))
815 return None
815 return None
816 self.ui.status(_('pushing subrepo %s to %s\n') %
816 self.ui.status(_('pushing subrepo %s to %s\n') %
817 (subrelpath(self), dsturl))
817 (subrelpath(self), dsturl))
818 other = hg.peer(self._repo, {'ssh': ssh}, dsturl)
818 other = hg.peer(self._repo, {'ssh': ssh}, dsturl)
819 res = exchange.push(self._repo, other, force, newbranch=newbranch)
819 res = exchange.push(self._repo, other, force, newbranch=newbranch)
820
820
821 # the repo is now clean
821 # the repo is now clean
822 self._cachestorehash(dsturl)
822 self._cachestorehash(dsturl)
823 return res.cgresult
823 return res.cgresult
824
824
825 @annotatesubrepoerror
825 @annotatesubrepoerror
826 def outgoing(self, ui, dest, opts):
826 def outgoing(self, ui, dest, opts):
827 return hg.outgoing(ui, self._repo, _abssource(self._repo, True), opts)
827 return hg.outgoing(ui, self._repo, _abssource(self._repo, True), opts)
828
828
829 @annotatesubrepoerror
829 @annotatesubrepoerror
830 def incoming(self, ui, source, opts):
830 def incoming(self, ui, source, opts):
831 return hg.incoming(ui, self._repo, _abssource(self._repo, False), opts)
831 return hg.incoming(ui, self._repo, _abssource(self._repo, False), opts)
832
832
833 @annotatesubrepoerror
833 @annotatesubrepoerror
834 def files(self):
834 def files(self):
835 rev = self._state[1]
835 rev = self._state[1]
836 ctx = self._repo[rev]
836 ctx = self._repo[rev]
837 return ctx.manifest()
837 return ctx.manifest()
838
838
839 def filedata(self, name):
839 def filedata(self, name):
840 rev = self._state[1]
840 rev = self._state[1]
841 return self._repo[rev][name].data()
841 return self._repo[rev][name].data()
842
842
843 def fileflags(self, name):
843 def fileflags(self, name):
844 rev = self._state[1]
844 rev = self._state[1]
845 ctx = self._repo[rev]
845 ctx = self._repo[rev]
846 return ctx.flags(name)
846 return ctx.flags(name)
847
847
848 def walk(self, match):
848 def walk(self, match):
849 ctx = self._repo[None]
849 ctx = self._repo[None]
850 return ctx.walk(match)
850 return ctx.walk(match)
851
851
852 @annotatesubrepoerror
852 @annotatesubrepoerror
853 def forget(self, match, prefix):
853 def forget(self, match, prefix):
854 return cmdutil.forget(self.ui, self._repo, match,
854 return cmdutil.forget(self.ui, self._repo, match,
855 os.path.join(prefix, self._path), True)
855 os.path.join(prefix, self._path), True)
856
856
857 @annotatesubrepoerror
857 @annotatesubrepoerror
858 def removefiles(self, matcher, prefix, after, force, subrepos):
858 def removefiles(self, matcher, prefix, after, force, subrepos):
859 return cmdutil.remove(self.ui, self._repo, matcher,
859 return cmdutil.remove(self.ui, self._repo, matcher,
860 os.path.join(prefix, self._path), after, force,
860 os.path.join(prefix, self._path), after, force,
861 subrepos)
861 subrepos)
862
862
863 @annotatesubrepoerror
863 @annotatesubrepoerror
864 def revert(self, substate, *pats, **opts):
864 def revert(self, substate, *pats, **opts):
865 # reverting a subrepo is a 2 step process:
865 # reverting a subrepo is a 2 step process:
866 # 1. if the no_backup is not set, revert all modified
866 # 1. if the no_backup is not set, revert all modified
867 # files inside the subrepo
867 # files inside the subrepo
868 # 2. update the subrepo to the revision specified in
868 # 2. update the subrepo to the revision specified in
869 # the corresponding substate dictionary
869 # the corresponding substate dictionary
870 self.ui.status(_('reverting subrepo %s\n') % substate[0])
870 self.ui.status(_('reverting subrepo %s\n') % substate[0])
871 if not opts.get('no_backup'):
871 if not opts.get('no_backup'):
872 # Revert all files on the subrepo, creating backups
872 # Revert all files on the subrepo, creating backups
873 # Note that this will not recursively revert subrepos
873 # Note that this will not recursively revert subrepos
874 # We could do it if there was a set:subrepos() predicate
874 # We could do it if there was a set:subrepos() predicate
875 opts = opts.copy()
875 opts = opts.copy()
876 opts['date'] = None
876 opts['date'] = None
877 opts['rev'] = substate[1]
877 opts['rev'] = substate[1]
878
878
879 pats = []
879 pats = []
880 if not opts.get('all'):
880 if not opts.get('all'):
881 pats = ['set:modified()']
881 pats = ['set:modified()']
882 self.filerevert(*pats, **opts)
882 self.filerevert(*pats, **opts)
883
883
884 # Update the repo to the revision specified in the given substate
884 # Update the repo to the revision specified in the given substate
885 self.get(substate, overwrite=True)
885 self.get(substate, overwrite=True)
886
886
887 def filerevert(self, *pats, **opts):
887 def filerevert(self, *pats, **opts):
888 ctx = self._repo[opts['rev']]
888 ctx = self._repo[opts['rev']]
889 parents = self._repo.dirstate.parents()
889 parents = self._repo.dirstate.parents()
890 if opts.get('all'):
890 if opts.get('all'):
891 pats = ['set:modified()']
891 pats = ['set:modified()']
892 else:
892 else:
893 pats = []
893 pats = []
894 cmdutil.revert(self.ui, self._repo, ctx, parents, *pats, **opts)
894 cmdutil.revert(self.ui, self._repo, ctx, parents, *pats, **opts)
895
895
896 def shortid(self, revid):
896 def shortid(self, revid):
897 return revid[:12]
897 return revid[:12]
898
898
899 class svnsubrepo(abstractsubrepo):
899 class svnsubrepo(abstractsubrepo):
900 def __init__(self, ctx, path, state):
900 def __init__(self, ctx, path, state):
901 super(svnsubrepo, self).__init__(ctx._repo.ui)
901 super(svnsubrepo, self).__init__(ctx._repo.ui)
902 self._path = path
902 self._path = path
903 self._state = state
903 self._state = state
904 self._ctx = ctx
904 self._ctx = ctx
905 self._exe = util.findexe('svn')
905 self._exe = util.findexe('svn')
906 if not self._exe:
906 if not self._exe:
907 raise util.Abort(_("'svn' executable not found for subrepo '%s'")
907 raise util.Abort(_("'svn' executable not found for subrepo '%s'")
908 % self._path)
908 % self._path)
909
909
910 def _svncommand(self, commands, filename='', failok=False):
910 def _svncommand(self, commands, filename='', failok=False):
911 cmd = [self._exe]
911 cmd = [self._exe]
912 extrakw = {}
912 extrakw = {}
913 if not self.ui.interactive():
913 if not self.ui.interactive():
914 # Making stdin be a pipe should prevent svn from behaving
914 # Making stdin be a pipe should prevent svn from behaving
915 # interactively even if we can't pass --non-interactive.
915 # interactively even if we can't pass --non-interactive.
916 extrakw['stdin'] = subprocess.PIPE
916 extrakw['stdin'] = subprocess.PIPE
917 # Starting in svn 1.5 --non-interactive is a global flag
917 # Starting in svn 1.5 --non-interactive is a global flag
918 # instead of being per-command, but we need to support 1.4 so
918 # instead of being per-command, but we need to support 1.4 so
919 # we have to be intelligent about what commands take
919 # we have to be intelligent about what commands take
920 # --non-interactive.
920 # --non-interactive.
921 if commands[0] in ('update', 'checkout', 'commit'):
921 if commands[0] in ('update', 'checkout', 'commit'):
922 cmd.append('--non-interactive')
922 cmd.append('--non-interactive')
923 cmd.extend(commands)
923 cmd.extend(commands)
924 if filename is not None:
924 if filename is not None:
925 path = os.path.join(self._ctx._repo.origroot, self._path, filename)
925 path = os.path.join(self._ctx._repo.origroot, self._path, filename)
926 cmd.append(path)
926 cmd.append(path)
927 env = dict(os.environ)
927 env = dict(os.environ)
928 # Avoid localized output, preserve current locale for everything else.
928 # Avoid localized output, preserve current locale for everything else.
929 lc_all = env.get('LC_ALL')
929 lc_all = env.get('LC_ALL')
930 if lc_all:
930 if lc_all:
931 env['LANG'] = lc_all
931 env['LANG'] = lc_all
932 del env['LC_ALL']
932 del env['LC_ALL']
933 env['LC_MESSAGES'] = 'C'
933 env['LC_MESSAGES'] = 'C'
934 p = subprocess.Popen(cmd, bufsize=-1, close_fds=util.closefds,
934 p = subprocess.Popen(cmd, bufsize=-1, close_fds=util.closefds,
935 stdout=subprocess.PIPE, stderr=subprocess.PIPE,
935 stdout=subprocess.PIPE, stderr=subprocess.PIPE,
936 universal_newlines=True, env=env, **extrakw)
936 universal_newlines=True, env=env, **extrakw)
937 stdout, stderr = p.communicate()
937 stdout, stderr = p.communicate()
938 stderr = stderr.strip()
938 stderr = stderr.strip()
939 if not failok:
939 if not failok:
940 if p.returncode:
940 if p.returncode:
941 raise util.Abort(stderr or 'exited with code %d' % p.returncode)
941 raise util.Abort(stderr or 'exited with code %d' % p.returncode)
942 if stderr:
942 if stderr:
943 self.ui.warn(stderr + '\n')
943 self.ui.warn(stderr + '\n')
944 return stdout, stderr
944 return stdout, stderr
945
945
946 @propertycache
946 @propertycache
947 def _svnversion(self):
947 def _svnversion(self):
948 output, err = self._svncommand(['--version', '--quiet'], filename=None)
948 output, err = self._svncommand(['--version', '--quiet'], filename=None)
949 m = re.search(r'^(\d+)\.(\d+)', output)
949 m = re.search(r'^(\d+)\.(\d+)', output)
950 if not m:
950 if not m:
951 raise util.Abort(_('cannot retrieve svn tool version'))
951 raise util.Abort(_('cannot retrieve svn tool version'))
952 return (int(m.group(1)), int(m.group(2)))
952 return (int(m.group(1)), int(m.group(2)))
953
953
954 def _wcrevs(self):
954 def _wcrevs(self):
955 # Get the working directory revision as well as the last
955 # Get the working directory revision as well as the last
956 # commit revision so we can compare the subrepo state with
956 # commit revision so we can compare the subrepo state with
957 # both. We used to store the working directory one.
957 # both. We used to store the working directory one.
958 output, err = self._svncommand(['info', '--xml'])
958 output, err = self._svncommand(['info', '--xml'])
959 doc = xml.dom.minidom.parseString(output)
959 doc = xml.dom.minidom.parseString(output)
960 entries = doc.getElementsByTagName('entry')
960 entries = doc.getElementsByTagName('entry')
961 lastrev, rev = '0', '0'
961 lastrev, rev = '0', '0'
962 if entries:
962 if entries:
963 rev = str(entries[0].getAttribute('revision')) or '0'
963 rev = str(entries[0].getAttribute('revision')) or '0'
964 commits = entries[0].getElementsByTagName('commit')
964 commits = entries[0].getElementsByTagName('commit')
965 if commits:
965 if commits:
966 lastrev = str(commits[0].getAttribute('revision')) or '0'
966 lastrev = str(commits[0].getAttribute('revision')) or '0'
967 return (lastrev, rev)
967 return (lastrev, rev)
968
968
969 def _wcrev(self):
969 def _wcrev(self):
970 return self._wcrevs()[0]
970 return self._wcrevs()[0]
971
971
972 def _wcchanged(self):
972 def _wcchanged(self):
973 """Return (changes, extchanges, missing) where changes is True
973 """Return (changes, extchanges, missing) where changes is True
974 if the working directory was changed, extchanges is
974 if the working directory was changed, extchanges is
975 True if any of these changes concern an external entry and missing
975 True if any of these changes concern an external entry and missing
976 is True if any change is a missing entry.
976 is True if any change is a missing entry.
977 """
977 """
978 output, err = self._svncommand(['status', '--xml'])
978 output, err = self._svncommand(['status', '--xml'])
979 externals, changes, missing = [], [], []
979 externals, changes, missing = [], [], []
980 doc = xml.dom.minidom.parseString(output)
980 doc = xml.dom.minidom.parseString(output)
981 for e in doc.getElementsByTagName('entry'):
981 for e in doc.getElementsByTagName('entry'):
982 s = e.getElementsByTagName('wc-status')
982 s = e.getElementsByTagName('wc-status')
983 if not s:
983 if not s:
984 continue
984 continue
985 item = s[0].getAttribute('item')
985 item = s[0].getAttribute('item')
986 props = s[0].getAttribute('props')
986 props = s[0].getAttribute('props')
987 path = e.getAttribute('path')
987 path = e.getAttribute('path')
988 if item == 'external':
988 if item == 'external':
989 externals.append(path)
989 externals.append(path)
990 elif item == 'missing':
990 elif item == 'missing':
991 missing.append(path)
991 missing.append(path)
992 if (item not in ('', 'normal', 'unversioned', 'external')
992 if (item not in ('', 'normal', 'unversioned', 'external')
993 or props not in ('', 'none', 'normal')):
993 or props not in ('', 'none', 'normal')):
994 changes.append(path)
994 changes.append(path)
995 for path in changes:
995 for path in changes:
996 for ext in externals:
996 for ext in externals:
997 if path == ext or path.startswith(ext + os.sep):
997 if path == ext or path.startswith(ext + os.sep):
998 return True, True, bool(missing)
998 return True, True, bool(missing)
999 return bool(changes), False, bool(missing)
999 return bool(changes), False, bool(missing)
1000
1000
1001 def dirty(self, ignoreupdate=False):
1001 def dirty(self, ignoreupdate=False):
1002 if not self._wcchanged()[0]:
1002 if not self._wcchanged()[0]:
1003 if self._state[1] in self._wcrevs() or ignoreupdate:
1003 if self._state[1] in self._wcrevs() or ignoreupdate:
1004 return False
1004 return False
1005 return True
1005 return True
1006
1006
1007 def basestate(self):
1007 def basestate(self):
1008 lastrev, rev = self._wcrevs()
1008 lastrev, rev = self._wcrevs()
1009 if lastrev != rev:
1009 if lastrev != rev:
1010 # Last committed rev is not the same than rev. We would
1010 # Last committed rev is not the same than rev. We would
1011 # like to take lastrev but we do not know if the subrepo
1011 # like to take lastrev but we do not know if the subrepo
1012 # URL exists at lastrev. Test it and fallback to rev it
1012 # URL exists at lastrev. Test it and fallback to rev it
1013 # is not there.
1013 # is not there.
1014 try:
1014 try:
1015 self._svncommand(['list', '%s@%s' % (self._state[0], lastrev)])
1015 self._svncommand(['list', '%s@%s' % (self._state[0], lastrev)])
1016 return lastrev
1016 return lastrev
1017 except error.Abort:
1017 except error.Abort:
1018 pass
1018 pass
1019 return rev
1019 return rev
1020
1020
1021 @annotatesubrepoerror
1021 @annotatesubrepoerror
1022 def commit(self, text, user, date):
1022 def commit(self, text, user, date):
1023 # user and date are out of our hands since svn is centralized
1023 # user and date are out of our hands since svn is centralized
1024 changed, extchanged, missing = self._wcchanged()
1024 changed, extchanged, missing = self._wcchanged()
1025 if not changed:
1025 if not changed:
1026 return self.basestate()
1026 return self.basestate()
1027 if extchanged:
1027 if extchanged:
1028 # Do not try to commit externals
1028 # Do not try to commit externals
1029 raise util.Abort(_('cannot commit svn externals'))
1029 raise util.Abort(_('cannot commit svn externals'))
1030 if missing:
1030 if missing:
1031 # svn can commit with missing entries but aborting like hg
1031 # svn can commit with missing entries but aborting like hg
1032 # seems a better approach.
1032 # seems a better approach.
1033 raise util.Abort(_('cannot commit missing svn entries'))
1033 raise util.Abort(_('cannot commit missing svn entries'))
1034 commitinfo, err = self._svncommand(['commit', '-m', text])
1034 commitinfo, err = self._svncommand(['commit', '-m', text])
1035 self.ui.status(commitinfo)
1035 self.ui.status(commitinfo)
1036 newrev = re.search('Committed revision ([0-9]+).', commitinfo)
1036 newrev = re.search('Committed revision ([0-9]+).', commitinfo)
1037 if not newrev:
1037 if not newrev:
1038 if not commitinfo.strip():
1038 if not commitinfo.strip():
1039 # Sometimes, our definition of "changed" differs from
1039 # Sometimes, our definition of "changed" differs from
1040 # svn one. For instance, svn ignores missing files
1040 # svn one. For instance, svn ignores missing files
1041 # when committing. If there are only missing files, no
1041 # when committing. If there are only missing files, no
1042 # commit is made, no output and no error code.
1042 # commit is made, no output and no error code.
1043 raise util.Abort(_('failed to commit svn changes'))
1043 raise util.Abort(_('failed to commit svn changes'))
1044 raise util.Abort(commitinfo.splitlines()[-1])
1044 raise util.Abort(commitinfo.splitlines()[-1])
1045 newrev = newrev.groups()[0]
1045 newrev = newrev.groups()[0]
1046 self.ui.status(self._svncommand(['update', '-r', newrev])[0])
1046 self.ui.status(self._svncommand(['update', '-r', newrev])[0])
1047 return newrev
1047 return newrev
1048
1048
1049 @annotatesubrepoerror
1049 @annotatesubrepoerror
1050 def remove(self):
1050 def remove(self):
1051 if self.dirty():
1051 if self.dirty():
1052 self.ui.warn(_('not removing repo %s because '
1052 self.ui.warn(_('not removing repo %s because '
1053 'it has changes.\n') % self._path)
1053 'it has changes.\n') % self._path)
1054 return
1054 return
1055 self.ui.note(_('removing subrepo %s\n') % self._path)
1055 self.ui.note(_('removing subrepo %s\n') % self._path)
1056
1056
1057 def onerror(function, path, excinfo):
1057 def onerror(function, path, excinfo):
1058 if function is not os.remove:
1058 if function is not os.remove:
1059 raise
1059 raise
1060 # read-only files cannot be unlinked under Windows
1060 # read-only files cannot be unlinked under Windows
1061 s = os.stat(path)
1061 s = os.stat(path)
1062 if (s.st_mode & stat.S_IWRITE) != 0:
1062 if (s.st_mode & stat.S_IWRITE) != 0:
1063 raise
1063 raise
1064 os.chmod(path, stat.S_IMODE(s.st_mode) | stat.S_IWRITE)
1064 os.chmod(path, stat.S_IMODE(s.st_mode) | stat.S_IWRITE)
1065 os.remove(path)
1065 os.remove(path)
1066
1066
1067 path = self._ctx._repo.wjoin(self._path)
1067 path = self._ctx._repo.wjoin(self._path)
1068 shutil.rmtree(path, onerror=onerror)
1068 shutil.rmtree(path, onerror=onerror)
1069 try:
1069 try:
1070 os.removedirs(os.path.dirname(path))
1070 os.removedirs(os.path.dirname(path))
1071 except OSError:
1071 except OSError:
1072 pass
1072 pass
1073
1073
1074 @annotatesubrepoerror
1074 @annotatesubrepoerror
1075 def get(self, state, overwrite=False):
1075 def get(self, state, overwrite=False):
1076 if overwrite:
1076 if overwrite:
1077 self._svncommand(['revert', '--recursive'])
1077 self._svncommand(['revert', '--recursive'])
1078 args = ['checkout']
1078 args = ['checkout']
1079 if self._svnversion >= (1, 5):
1079 if self._svnversion >= (1, 5):
1080 args.append('--force')
1080 args.append('--force')
1081 # The revision must be specified at the end of the URL to properly
1081 # The revision must be specified at the end of the URL to properly
1082 # update to a directory which has since been deleted and recreated.
1082 # update to a directory which has since been deleted and recreated.
1083 args.append('%s@%s' % (state[0], state[1]))
1083 args.append('%s@%s' % (state[0], state[1]))
1084 status, err = self._svncommand(args, failok=True)
1084 status, err = self._svncommand(args, failok=True)
1085 _sanitize(self.ui, self._ctx._repo.wjoin(self._path), '.svn')
1085 _sanitize(self.ui, self._ctx._repo.wjoin(self._path), '.svn')
1086 if not re.search('Checked out revision [0-9]+.', status):
1086 if not re.search('Checked out revision [0-9]+.', status):
1087 if ('is already a working copy for a different URL' in err
1087 if ('is already a working copy for a different URL' in err
1088 and (self._wcchanged()[:2] == (False, False))):
1088 and (self._wcchanged()[:2] == (False, False))):
1089 # obstructed but clean working copy, so just blow it away.
1089 # obstructed but clean working copy, so just blow it away.
1090 self.remove()
1090 self.remove()
1091 self.get(state, overwrite=False)
1091 self.get(state, overwrite=False)
1092 return
1092 return
1093 raise util.Abort((status or err).splitlines()[-1])
1093 raise util.Abort((status or err).splitlines()[-1])
1094 self.ui.status(status)
1094 self.ui.status(status)
1095
1095
1096 @annotatesubrepoerror
1096 @annotatesubrepoerror
1097 def merge(self, state):
1097 def merge(self, state):
1098 old = self._state[1]
1098 old = self._state[1]
1099 new = state[1]
1099 new = state[1]
1100 wcrev = self._wcrev()
1100 wcrev = self._wcrev()
1101 if new != wcrev:
1101 if new != wcrev:
1102 dirty = old == wcrev or self._wcchanged()[0]
1102 dirty = old == wcrev or self._wcchanged()[0]
1103 if _updateprompt(self.ui, self, dirty, wcrev, new):
1103 if _updateprompt(self.ui, self, dirty, wcrev, new):
1104 self.get(state, False)
1104 self.get(state, False)
1105
1105
1106 def push(self, opts):
1106 def push(self, opts):
1107 # push is a no-op for SVN
1107 # push is a no-op for SVN
1108 return True
1108 return True
1109
1109
1110 @annotatesubrepoerror
1110 @annotatesubrepoerror
1111 def files(self):
1111 def files(self):
1112 output = self._svncommand(['list', '--recursive', '--xml'])[0]
1112 output = self._svncommand(['list', '--recursive', '--xml'])[0]
1113 doc = xml.dom.minidom.parseString(output)
1113 doc = xml.dom.minidom.parseString(output)
1114 paths = []
1114 paths = []
1115 for e in doc.getElementsByTagName('entry'):
1115 for e in doc.getElementsByTagName('entry'):
1116 kind = str(e.getAttribute('kind'))
1116 kind = str(e.getAttribute('kind'))
1117 if kind != 'file':
1117 if kind != 'file':
1118 continue
1118 continue
1119 name = ''.join(c.data for c
1119 name = ''.join(c.data for c
1120 in e.getElementsByTagName('name')[0].childNodes
1120 in e.getElementsByTagName('name')[0].childNodes
1121 if c.nodeType == c.TEXT_NODE)
1121 if c.nodeType == c.TEXT_NODE)
1122 paths.append(name.encode('utf-8'))
1122 paths.append(name.encode('utf-8'))
1123 return paths
1123 return paths
1124
1124
1125 def filedata(self, name):
1125 def filedata(self, name):
1126 return self._svncommand(['cat'], name)[0]
1126 return self._svncommand(['cat'], name)[0]
1127
1127
1128
1128
1129 class gitsubrepo(abstractsubrepo):
1129 class gitsubrepo(abstractsubrepo):
1130 def __init__(self, ctx, path, state):
1130 def __init__(self, ctx, path, state):
1131 super(gitsubrepo, self).__init__(ctx._repo.ui)
1131 super(gitsubrepo, self).__init__(ctx._repo.ui)
1132 self._state = state
1132 self._state = state
1133 self._ctx = ctx
1133 self._ctx = ctx
1134 self._path = path
1134 self._path = path
1135 self._relpath = os.path.join(reporelpath(ctx._repo), path)
1135 self._relpath = os.path.join(reporelpath(ctx._repo), path)
1136 self._abspath = ctx._repo.wjoin(path)
1136 self._abspath = ctx._repo.wjoin(path)
1137 self._subparent = ctx._repo
1137 self._subparent = ctx._repo
1138 self._ensuregit()
1138 self._ensuregit()
1139
1139
1140 def _ensuregit(self):
1140 def _ensuregit(self):
1141 try:
1141 try:
1142 self._gitexecutable = 'git'
1142 self._gitexecutable = 'git'
1143 out, err = self._gitnodir(['--version'])
1143 out, err = self._gitnodir(['--version'])
1144 except OSError, e:
1144 except OSError, e:
1145 if e.errno != 2 or os.name != 'nt':
1145 if e.errno != 2 or os.name != 'nt':
1146 raise
1146 raise
1147 self._gitexecutable = 'git.cmd'
1147 self._gitexecutable = 'git.cmd'
1148 out, err = self._gitnodir(['--version'])
1148 out, err = self._gitnodir(['--version'])
1149 versionstatus = self._checkversion(out)
1149 versionstatus = self._checkversion(out)
1150 if versionstatus == 'unknown':
1150 if versionstatus == 'unknown':
1151 self.ui.warn(_('cannot retrieve git version\n'))
1151 self.ui.warn(_('cannot retrieve git version\n'))
1152 elif versionstatus == 'abort':
1152 elif versionstatus == 'abort':
1153 raise util.Abort(_('git subrepo requires at least 1.6.0 or later'))
1153 raise util.Abort(_('git subrepo requires at least 1.6.0 or later'))
1154 elif versionstatus == 'warning':
1154 elif versionstatus == 'warning':
1155 self.ui.warn(_('git subrepo requires at least 1.6.0 or later\n'))
1155 self.ui.warn(_('git subrepo requires at least 1.6.0 or later\n'))
1156
1156
1157 @staticmethod
1157 @staticmethod
1158 def _gitversion(out):
1158 def _gitversion(out):
1159 m = re.search(r'^git version (\d+)\.(\d+)\.(\d+)', out)
1159 m = re.search(r'^git version (\d+)\.(\d+)\.(\d+)', out)
1160 if m:
1160 if m:
1161 return (int(m.group(1)), int(m.group(2)), int(m.group(3)))
1161 return (int(m.group(1)), int(m.group(2)), int(m.group(3)))
1162
1162
1163 m = re.search(r'^git version (\d+)\.(\d+)', out)
1163 m = re.search(r'^git version (\d+)\.(\d+)', out)
1164 if m:
1164 if m:
1165 return (int(m.group(1)), int(m.group(2)), 0)
1165 return (int(m.group(1)), int(m.group(2)), 0)
1166
1166
1167 return -1
1167 return -1
1168
1168
1169 @staticmethod
1169 @staticmethod
1170 def _checkversion(out):
1170 def _checkversion(out):
1171 '''ensure git version is new enough
1171 '''ensure git version is new enough
1172
1172
1173 >>> _checkversion = gitsubrepo._checkversion
1173 >>> _checkversion = gitsubrepo._checkversion
1174 >>> _checkversion('git version 1.6.0')
1174 >>> _checkversion('git version 1.6.0')
1175 'ok'
1175 'ok'
1176 >>> _checkversion('git version 1.8.5')
1176 >>> _checkversion('git version 1.8.5')
1177 'ok'
1177 'ok'
1178 >>> _checkversion('git version 1.4.0')
1178 >>> _checkversion('git version 1.4.0')
1179 'abort'
1179 'abort'
1180 >>> _checkversion('git version 1.5.0')
1180 >>> _checkversion('git version 1.5.0')
1181 'warning'
1181 'warning'
1182 >>> _checkversion('git version 1.9-rc0')
1182 >>> _checkversion('git version 1.9-rc0')
1183 'ok'
1183 'ok'
1184 >>> _checkversion('git version 1.9.0.265.g81cdec2')
1184 >>> _checkversion('git version 1.9.0.265.g81cdec2')
1185 'ok'
1185 'ok'
1186 >>> _checkversion('git version 1.9.0.GIT')
1186 >>> _checkversion('git version 1.9.0.GIT')
1187 'ok'
1187 'ok'
1188 >>> _checkversion('git version 12345')
1188 >>> _checkversion('git version 12345')
1189 'unknown'
1189 'unknown'
1190 >>> _checkversion('no')
1190 >>> _checkversion('no')
1191 'unknown'
1191 'unknown'
1192 '''
1192 '''
1193 version = gitsubrepo._gitversion(out)
1193 version = gitsubrepo._gitversion(out)
1194 # git 1.4.0 can't work at all, but 1.5.X can in at least some cases,
1194 # git 1.4.0 can't work at all, but 1.5.X can in at least some cases,
1195 # despite the docstring comment. For now, error on 1.4.0, warn on
1195 # despite the docstring comment. For now, error on 1.4.0, warn on
1196 # 1.5.0 but attempt to continue.
1196 # 1.5.0 but attempt to continue.
1197 if version == -1:
1197 if version == -1:
1198 return 'unknown'
1198 return 'unknown'
1199 if version < (1, 5, 0):
1199 if version < (1, 5, 0):
1200 return 'abort'
1200 return 'abort'
1201 elif version < (1, 6, 0):
1201 elif version < (1, 6, 0):
1202 return 'warning'
1202 return 'warning'
1203 return 'ok'
1203 return 'ok'
1204
1204
1205 def _gitcommand(self, commands, env=None, stream=False):
1205 def _gitcommand(self, commands, env=None, stream=False):
1206 return self._gitdir(commands, env=env, stream=stream)[0]
1206 return self._gitdir(commands, env=env, stream=stream)[0]
1207
1207
1208 def _gitdir(self, commands, env=None, stream=False):
1208 def _gitdir(self, commands, env=None, stream=False):
1209 return self._gitnodir(commands, env=env, stream=stream,
1209 return self._gitnodir(commands, env=env, stream=stream,
1210 cwd=self._abspath)
1210 cwd=self._abspath)
1211
1211
1212 def _gitnodir(self, commands, env=None, stream=False, cwd=None):
1212 def _gitnodir(self, commands, env=None, stream=False, cwd=None):
1213 """Calls the git command
1213 """Calls the git command
1214
1214
1215 The methods tries to call the git command. versions prior to 1.6.0
1215 The methods tries to call the git command. versions prior to 1.6.0
1216 are not supported and very probably fail.
1216 are not supported and very probably fail.
1217 """
1217 """
1218 self.ui.debug('%s: git %s\n' % (self._relpath, ' '.join(commands)))
1218 self.ui.debug('%s: git %s\n' % (self._relpath, ' '.join(commands)))
1219 # unless ui.quiet is set, print git's stderr,
1219 # unless ui.quiet is set, print git's stderr,
1220 # which is mostly progress and useful info
1220 # which is mostly progress and useful info
1221 errpipe = None
1221 errpipe = None
1222 if self.ui.quiet:
1222 if self.ui.quiet:
1223 errpipe = open(os.devnull, 'w')
1223 errpipe = open(os.devnull, 'w')
1224 p = subprocess.Popen([self._gitexecutable] + commands, bufsize=-1,
1224 p = subprocess.Popen([self._gitexecutable] + commands, bufsize=-1,
1225 cwd=cwd, env=env, close_fds=util.closefds,
1225 cwd=cwd, env=env, close_fds=util.closefds,
1226 stdout=subprocess.PIPE, stderr=errpipe)
1226 stdout=subprocess.PIPE, stderr=errpipe)
1227 if stream:
1227 if stream:
1228 return p.stdout, None
1228 return p.stdout, None
1229
1229
1230 retdata = p.stdout.read().strip()
1230 retdata = p.stdout.read().strip()
1231 # wait for the child to exit to avoid race condition.
1231 # wait for the child to exit to avoid race condition.
1232 p.wait()
1232 p.wait()
1233
1233
1234 if p.returncode != 0 and p.returncode != 1:
1234 if p.returncode != 0 and p.returncode != 1:
1235 # there are certain error codes that are ok
1235 # there are certain error codes that are ok
1236 command = commands[0]
1236 command = commands[0]
1237 if command in ('cat-file', 'symbolic-ref'):
1237 if command in ('cat-file', 'symbolic-ref'):
1238 return retdata, p.returncode
1238 return retdata, p.returncode
1239 # for all others, abort
1239 # for all others, abort
1240 raise util.Abort('git %s error %d in %s' %
1240 raise util.Abort('git %s error %d in %s' %
1241 (command, p.returncode, self._relpath))
1241 (command, p.returncode, self._relpath))
1242
1242
1243 return retdata, p.returncode
1243 return retdata, p.returncode
1244
1244
1245 def _gitmissing(self):
1245 def _gitmissing(self):
1246 return not os.path.exists(os.path.join(self._abspath, '.git'))
1246 return not os.path.exists(os.path.join(self._abspath, '.git'))
1247
1247
1248 def _gitstate(self):
1248 def _gitstate(self):
1249 return self._gitcommand(['rev-parse', 'HEAD'])
1249 return self._gitcommand(['rev-parse', 'HEAD'])
1250
1250
1251 def _gitcurrentbranch(self):
1251 def _gitcurrentbranch(self):
1252 current, err = self._gitdir(['symbolic-ref', 'HEAD', '--quiet'])
1252 current, err = self._gitdir(['symbolic-ref', 'HEAD', '--quiet'])
1253 if err:
1253 if err:
1254 current = None
1254 current = None
1255 return current
1255 return current
1256
1256
1257 def _gitremote(self, remote):
1257 def _gitremote(self, remote):
1258 out = self._gitcommand(['remote', 'show', '-n', remote])
1258 out = self._gitcommand(['remote', 'show', '-n', remote])
1259 line = out.split('\n')[1]
1259 line = out.split('\n')[1]
1260 i = line.index('URL: ') + len('URL: ')
1260 i = line.index('URL: ') + len('URL: ')
1261 return line[i:]
1261 return line[i:]
1262
1262
1263 def _githavelocally(self, revision):
1263 def _githavelocally(self, revision):
1264 out, code = self._gitdir(['cat-file', '-e', revision])
1264 out, code = self._gitdir(['cat-file', '-e', revision])
1265 return code == 0
1265 return code == 0
1266
1266
1267 def _gitisancestor(self, r1, r2):
1267 def _gitisancestor(self, r1, r2):
1268 base = self._gitcommand(['merge-base', r1, r2])
1268 base = self._gitcommand(['merge-base', r1, r2])
1269 return base == r1
1269 return base == r1
1270
1270
1271 def _gitisbare(self):
1271 def _gitisbare(self):
1272 return self._gitcommand(['config', '--bool', 'core.bare']) == 'true'
1272 return self._gitcommand(['config', '--bool', 'core.bare']) == 'true'
1273
1273
1274 def _gitupdatestat(self):
1274 def _gitupdatestat(self):
1275 """This must be run before git diff-index.
1275 """This must be run before git diff-index.
1276 diff-index only looks at changes to file stat;
1276 diff-index only looks at changes to file stat;
1277 this command looks at file contents and updates the stat."""
1277 this command looks at file contents and updates the stat."""
1278 self._gitcommand(['update-index', '-q', '--refresh'])
1278 self._gitcommand(['update-index', '-q', '--refresh'])
1279
1279
1280 def _gitbranchmap(self):
1280 def _gitbranchmap(self):
1281 '''returns 2 things:
1281 '''returns 2 things:
1282 a map from git branch to revision
1282 a map from git branch to revision
1283 a map from revision to branches'''
1283 a map from revision to branches'''
1284 branch2rev = {}
1284 branch2rev = {}
1285 rev2branch = {}
1285 rev2branch = {}
1286
1286
1287 out = self._gitcommand(['for-each-ref', '--format',
1287 out = self._gitcommand(['for-each-ref', '--format',
1288 '%(objectname) %(refname)'])
1288 '%(objectname) %(refname)'])
1289 for line in out.split('\n'):
1289 for line in out.split('\n'):
1290 revision, ref = line.split(' ')
1290 revision, ref = line.split(' ')
1291 if (not ref.startswith('refs/heads/') and
1291 if (not ref.startswith('refs/heads/') and
1292 not ref.startswith('refs/remotes/')):
1292 not ref.startswith('refs/remotes/')):
1293 continue
1293 continue
1294 if ref.startswith('refs/remotes/') and ref.endswith('/HEAD'):
1294 if ref.startswith('refs/remotes/') and ref.endswith('/HEAD'):
1295 continue # ignore remote/HEAD redirects
1295 continue # ignore remote/HEAD redirects
1296 branch2rev[ref] = revision
1296 branch2rev[ref] = revision
1297 rev2branch.setdefault(revision, []).append(ref)
1297 rev2branch.setdefault(revision, []).append(ref)
1298 return branch2rev, rev2branch
1298 return branch2rev, rev2branch
1299
1299
1300 def _gittracking(self, branches):
1300 def _gittracking(self, branches):
1301 'return map of remote branch to local tracking branch'
1301 'return map of remote branch to local tracking branch'
1302 # assumes no more than one local tracking branch for each remote
1302 # assumes no more than one local tracking branch for each remote
1303 tracking = {}
1303 tracking = {}
1304 for b in branches:
1304 for b in branches:
1305 if b.startswith('refs/remotes/'):
1305 if b.startswith('refs/remotes/'):
1306 continue
1306 continue
1307 bname = b.split('/', 2)[2]
1307 bname = b.split('/', 2)[2]
1308 remote = self._gitcommand(['config', 'branch.%s.remote' % bname])
1308 remote = self._gitcommand(['config', 'branch.%s.remote' % bname])
1309 if remote:
1309 if remote:
1310 ref = self._gitcommand(['config', 'branch.%s.merge' % bname])
1310 ref = self._gitcommand(['config', 'branch.%s.merge' % bname])
1311 tracking['refs/remotes/%s/%s' %
1311 tracking['refs/remotes/%s/%s' %
1312 (remote, ref.split('/', 2)[2])] = b
1312 (remote, ref.split('/', 2)[2])] = b
1313 return tracking
1313 return tracking
1314
1314
1315 def _abssource(self, source):
1315 def _abssource(self, source):
1316 if '://' not in source:
1316 if '://' not in source:
1317 # recognize the scp syntax as an absolute source
1317 # recognize the scp syntax as an absolute source
1318 colon = source.find(':')
1318 colon = source.find(':')
1319 if colon != -1 and '/' not in source[:colon]:
1319 if colon != -1 and '/' not in source[:colon]:
1320 return source
1320 return source
1321 self._subsource = source
1321 self._subsource = source
1322 return _abssource(self)
1322 return _abssource(self)
1323
1323
1324 def _fetch(self, source, revision):
1324 def _fetch(self, source, revision):
1325 if self._gitmissing():
1325 if self._gitmissing():
1326 source = self._abssource(source)
1326 source = self._abssource(source)
1327 self.ui.status(_('cloning subrepo %s from %s\n') %
1327 self.ui.status(_('cloning subrepo %s from %s\n') %
1328 (self._relpath, source))
1328 (self._relpath, source))
1329 self._gitnodir(['clone', source, self._abspath])
1329 self._gitnodir(['clone', source, self._abspath])
1330 if self._githavelocally(revision):
1330 if self._githavelocally(revision):
1331 return
1331 return
1332 self.ui.status(_('pulling subrepo %s from %s\n') %
1332 self.ui.status(_('pulling subrepo %s from %s\n') %
1333 (self._relpath, self._gitremote('origin')))
1333 (self._relpath, self._gitremote('origin')))
1334 # try only origin: the originally cloned repo
1334 # try only origin: the originally cloned repo
1335 self._gitcommand(['fetch'])
1335 self._gitcommand(['fetch'])
1336 if not self._githavelocally(revision):
1336 if not self._githavelocally(revision):
1337 raise util.Abort(_("revision %s does not exist in subrepo %s\n") %
1337 raise util.Abort(_("revision %s does not exist in subrepo %s\n") %
1338 (revision, self._relpath))
1338 (revision, self._relpath))
1339
1339
1340 @annotatesubrepoerror
1340 @annotatesubrepoerror
1341 def dirty(self, ignoreupdate=False):
1341 def dirty(self, ignoreupdate=False):
1342 if self._gitmissing():
1342 if self._gitmissing():
1343 return self._state[1] != ''
1343 return self._state[1] != ''
1344 if self._gitisbare():
1344 if self._gitisbare():
1345 return True
1345 return True
1346 if not ignoreupdate and self._state[1] != self._gitstate():
1346 if not ignoreupdate and self._state[1] != self._gitstate():
1347 # different version checked out
1347 # different version checked out
1348 return True
1348 return True
1349 # check for staged changes or modified files; ignore untracked files
1349 # check for staged changes or modified files; ignore untracked files
1350 self._gitupdatestat()
1350 self._gitupdatestat()
1351 out, code = self._gitdir(['diff-index', '--quiet', 'HEAD'])
1351 out, code = self._gitdir(['diff-index', '--quiet', 'HEAD'])
1352 return code == 1
1352 return code == 1
1353
1353
1354 def basestate(self):
1354 def basestate(self):
1355 return self._gitstate()
1355 return self._gitstate()
1356
1356
1357 @annotatesubrepoerror
1357 @annotatesubrepoerror
1358 def get(self, state, overwrite=False):
1358 def get(self, state, overwrite=False):
1359 source, revision, kind = state
1359 source, revision, kind = state
1360 if not revision:
1360 if not revision:
1361 self.remove()
1361 self.remove()
1362 return
1362 return
1363 self._fetch(source, revision)
1363 self._fetch(source, revision)
1364 # if the repo was set to be bare, unbare it
1364 # if the repo was set to be bare, unbare it
1365 if self._gitisbare():
1365 if self._gitisbare():
1366 self._gitcommand(['config', 'core.bare', 'false'])
1366 self._gitcommand(['config', 'core.bare', 'false'])
1367 if self._gitstate() == revision:
1367 if self._gitstate() == revision:
1368 self._gitcommand(['reset', '--hard', 'HEAD'])
1368 self._gitcommand(['reset', '--hard', 'HEAD'])
1369 return
1369 return
1370 elif self._gitstate() == revision:
1370 elif self._gitstate() == revision:
1371 if overwrite:
1371 if overwrite:
1372 # first reset the index to unmark new files for commit, because
1372 # first reset the index to unmark new files for commit, because
1373 # reset --hard will otherwise throw away files added for commit,
1373 # reset --hard will otherwise throw away files added for commit,
1374 # not just unmark them.
1374 # not just unmark them.
1375 self._gitcommand(['reset', 'HEAD'])
1375 self._gitcommand(['reset', 'HEAD'])
1376 self._gitcommand(['reset', '--hard', 'HEAD'])
1376 self._gitcommand(['reset', '--hard', 'HEAD'])
1377 return
1377 return
1378 branch2rev, rev2branch = self._gitbranchmap()
1378 branch2rev, rev2branch = self._gitbranchmap()
1379
1379
1380 def checkout(args):
1380 def checkout(args):
1381 cmd = ['checkout']
1381 cmd = ['checkout']
1382 if overwrite:
1382 if overwrite:
1383 # first reset the index to unmark new files for commit, because
1383 # first reset the index to unmark new files for commit, because
1384 # the -f option will otherwise throw away files added for
1384 # the -f option will otherwise throw away files added for
1385 # commit, not just unmark them.
1385 # commit, not just unmark them.
1386 self._gitcommand(['reset', 'HEAD'])
1386 self._gitcommand(['reset', 'HEAD'])
1387 cmd.append('-f')
1387 cmd.append('-f')
1388 self._gitcommand(cmd + args)
1388 self._gitcommand(cmd + args)
1389 _sanitize(self.ui, self._abspath, '.git')
1389 _sanitize(self.ui, self._abspath, '.git')
1390
1390
1391 def rawcheckout():
1391 def rawcheckout():
1392 # no branch to checkout, check it out with no branch
1392 # no branch to checkout, check it out with no branch
1393 self.ui.warn(_('checking out detached HEAD in subrepo %s\n') %
1393 self.ui.warn(_('checking out detached HEAD in subrepo %s\n') %
1394 self._relpath)
1394 self._relpath)
1395 self.ui.warn(_('check out a git branch if you intend '
1395 self.ui.warn(_('check out a git branch if you intend '
1396 'to make changes\n'))
1396 'to make changes\n'))
1397 checkout(['-q', revision])
1397 checkout(['-q', revision])
1398
1398
1399 if revision not in rev2branch:
1399 if revision not in rev2branch:
1400 rawcheckout()
1400 rawcheckout()
1401 return
1401 return
1402 branches = rev2branch[revision]
1402 branches = rev2branch[revision]
1403 firstlocalbranch = None
1403 firstlocalbranch = None
1404 for b in branches:
1404 for b in branches:
1405 if b == 'refs/heads/master':
1405 if b == 'refs/heads/master':
1406 # master trumps all other branches
1406 # master trumps all other branches
1407 checkout(['refs/heads/master'])
1407 checkout(['refs/heads/master'])
1408 return
1408 return
1409 if not firstlocalbranch and not b.startswith('refs/remotes/'):
1409 if not firstlocalbranch and not b.startswith('refs/remotes/'):
1410 firstlocalbranch = b
1410 firstlocalbranch = b
1411 if firstlocalbranch:
1411 if firstlocalbranch:
1412 checkout([firstlocalbranch])
1412 checkout([firstlocalbranch])
1413 return
1413 return
1414
1414
1415 tracking = self._gittracking(branch2rev.keys())
1415 tracking = self._gittracking(branch2rev.keys())
1416 # choose a remote branch already tracked if possible
1416 # choose a remote branch already tracked if possible
1417 remote = branches[0]
1417 remote = branches[0]
1418 if remote not in tracking:
1418 if remote not in tracking:
1419 for b in branches:
1419 for b in branches:
1420 if b in tracking:
1420 if b in tracking:
1421 remote = b
1421 remote = b
1422 break
1422 break
1423
1423
1424 if remote not in tracking:
1424 if remote not in tracking:
1425 # create a new local tracking branch
1425 # create a new local tracking branch
1426 local = remote.split('/', 3)[3]
1426 local = remote.split('/', 3)[3]
1427 checkout(['-b', local, remote])
1427 checkout(['-b', local, remote])
1428 elif self._gitisancestor(branch2rev[tracking[remote]], remote):
1428 elif self._gitisancestor(branch2rev[tracking[remote]], remote):
1429 # When updating to a tracked remote branch,
1429 # When updating to a tracked remote branch,
1430 # if the local tracking branch is downstream of it,
1430 # if the local tracking branch is downstream of it,
1431 # a normal `git pull` would have performed a "fast-forward merge"
1431 # a normal `git pull` would have performed a "fast-forward merge"
1432 # which is equivalent to updating the local branch to the remote.
1432 # which is equivalent to updating the local branch to the remote.
1433 # Since we are only looking at branching at update, we need to
1433 # Since we are only looking at branching at update, we need to
1434 # detect this situation and perform this action lazily.
1434 # detect this situation and perform this action lazily.
1435 if tracking[remote] != self._gitcurrentbranch():
1435 if tracking[remote] != self._gitcurrentbranch():
1436 checkout([tracking[remote]])
1436 checkout([tracking[remote]])
1437 self._gitcommand(['merge', '--ff', remote])
1437 self._gitcommand(['merge', '--ff', remote])
1438 _sanitize(self.ui, self._abspath, '.git')
1438 _sanitize(self.ui, self._abspath, '.git')
1439 else:
1439 else:
1440 # a real merge would be required, just checkout the revision
1440 # a real merge would be required, just checkout the revision
1441 rawcheckout()
1441 rawcheckout()
1442
1442
1443 @annotatesubrepoerror
1443 @annotatesubrepoerror
1444 def commit(self, text, user, date):
1444 def commit(self, text, user, date):
1445 if self._gitmissing():
1445 if self._gitmissing():
1446 raise util.Abort(_("subrepo %s is missing") % self._relpath)
1446 raise util.Abort(_("subrepo %s is missing") % self._relpath)
1447 cmd = ['commit', '-a', '-m', text]
1447 cmd = ['commit', '-a', '-m', text]
1448 env = os.environ.copy()
1448 env = os.environ.copy()
1449 if user:
1449 if user:
1450 cmd += ['--author', user]
1450 cmd += ['--author', user]
1451 if date:
1451 if date:
1452 # git's date parser silently ignores when seconds < 1e9
1452 # git's date parser silently ignores when seconds < 1e9
1453 # convert to ISO8601
1453 # convert to ISO8601
1454 env['GIT_AUTHOR_DATE'] = util.datestr(date,
1454 env['GIT_AUTHOR_DATE'] = util.datestr(date,
1455 '%Y-%m-%dT%H:%M:%S %1%2')
1455 '%Y-%m-%dT%H:%M:%S %1%2')
1456 self._gitcommand(cmd, env=env)
1456 self._gitcommand(cmd, env=env)
1457 # make sure commit works otherwise HEAD might not exist under certain
1457 # make sure commit works otherwise HEAD might not exist under certain
1458 # circumstances
1458 # circumstances
1459 return self._gitstate()
1459 return self._gitstate()
1460
1460
1461 @annotatesubrepoerror
1461 @annotatesubrepoerror
1462 def merge(self, state):
1462 def merge(self, state):
1463 source, revision, kind = state
1463 source, revision, kind = state
1464 self._fetch(source, revision)
1464 self._fetch(source, revision)
1465 base = self._gitcommand(['merge-base', revision, self._state[1]])
1465 base = self._gitcommand(['merge-base', revision, self._state[1]])
1466 self._gitupdatestat()
1466 self._gitupdatestat()
1467 out, code = self._gitdir(['diff-index', '--quiet', 'HEAD'])
1467 out, code = self._gitdir(['diff-index', '--quiet', 'HEAD'])
1468
1468
1469 def mergefunc():
1469 def mergefunc():
1470 if base == revision:
1470 if base == revision:
1471 self.get(state) # fast forward merge
1471 self.get(state) # fast forward merge
1472 elif base != self._state[1]:
1472 elif base != self._state[1]:
1473 self._gitcommand(['merge', '--no-commit', revision])
1473 self._gitcommand(['merge', '--no-commit', revision])
1474 _sanitize(self.ui, self._abspath, '.git')
1474 _sanitize(self.ui, self._abspath, '.git')
1475
1475
1476 if self.dirty():
1476 if self.dirty():
1477 if self._gitstate() != revision:
1477 if self._gitstate() != revision:
1478 dirty = self._gitstate() == self._state[1] or code != 0
1478 dirty = self._gitstate() == self._state[1] or code != 0
1479 if _updateprompt(self.ui, self, dirty,
1479 if _updateprompt(self.ui, self, dirty,
1480 self._state[1][:7], revision[:7]):
1480 self._state[1][:7], revision[:7]):
1481 mergefunc()
1481 mergefunc()
1482 else:
1482 else:
1483 mergefunc()
1483 mergefunc()
1484
1484
1485 @annotatesubrepoerror
1485 @annotatesubrepoerror
1486 def push(self, opts):
1486 def push(self, opts):
1487 force = opts.get('force')
1487 force = opts.get('force')
1488
1488
1489 if not self._state[1]:
1489 if not self._state[1]:
1490 return True
1490 return True
1491 if self._gitmissing():
1491 if self._gitmissing():
1492 raise util.Abort(_("subrepo %s is missing") % self._relpath)
1492 raise util.Abort(_("subrepo %s is missing") % self._relpath)
1493 # if a branch in origin contains the revision, nothing to do
1493 # if a branch in origin contains the revision, nothing to do
1494 branch2rev, rev2branch = self._gitbranchmap()
1494 branch2rev, rev2branch = self._gitbranchmap()
1495 if self._state[1] in rev2branch:
1495 if self._state[1] in rev2branch:
1496 for b in rev2branch[self._state[1]]:
1496 for b in rev2branch[self._state[1]]:
1497 if b.startswith('refs/remotes/origin/'):
1497 if b.startswith('refs/remotes/origin/'):
1498 return True
1498 return True
1499 for b, revision in branch2rev.iteritems():
1499 for b, revision in branch2rev.iteritems():
1500 if b.startswith('refs/remotes/origin/'):
1500 if b.startswith('refs/remotes/origin/'):
1501 if self._gitisancestor(self._state[1], revision):
1501 if self._gitisancestor(self._state[1], revision):
1502 return True
1502 return True
1503 # otherwise, try to push the currently checked out branch
1503 # otherwise, try to push the currently checked out branch
1504 cmd = ['push']
1504 cmd = ['push']
1505 if force:
1505 if force:
1506 cmd.append('--force')
1506 cmd.append('--force')
1507
1507
1508 current = self._gitcurrentbranch()
1508 current = self._gitcurrentbranch()
1509 if current:
1509 if current:
1510 # determine if the current branch is even useful
1510 # determine if the current branch is even useful
1511 if not self._gitisancestor(self._state[1], current):
1511 if not self._gitisancestor(self._state[1], current):
1512 self.ui.warn(_('unrelated git branch checked out '
1512 self.ui.warn(_('unrelated git branch checked out '
1513 'in subrepo %s\n') % self._relpath)
1513 'in subrepo %s\n') % self._relpath)
1514 return False
1514 return False
1515 self.ui.status(_('pushing branch %s of subrepo %s\n') %
1515 self.ui.status(_('pushing branch %s of subrepo %s\n') %
1516 (current.split('/', 2)[2], self._relpath))
1516 (current.split('/', 2)[2], self._relpath))
1517 ret = self._gitdir(cmd + ['origin', current])
1517 ret = self._gitdir(cmd + ['origin', current])
1518 return ret[1] == 0
1518 return ret[1] == 0
1519 else:
1519 else:
1520 self.ui.warn(_('no branch checked out in subrepo %s\n'
1520 self.ui.warn(_('no branch checked out in subrepo %s\n'
1521 'cannot push revision %s\n') %
1521 'cannot push revision %s\n') %
1522 (self._relpath, self._state[1]))
1522 (self._relpath, self._state[1]))
1523 return False
1523 return False
1524
1524
1525 @annotatesubrepoerror
1525 @annotatesubrepoerror
1526 def remove(self):
1526 def remove(self):
1527 if self._gitmissing():
1527 if self._gitmissing():
1528 return
1528 return
1529 if self.dirty():
1529 if self.dirty():
1530 self.ui.warn(_('not removing repo %s because '
1530 self.ui.warn(_('not removing repo %s because '
1531 'it has changes.\n') % self._relpath)
1531 'it has changes.\n') % self._relpath)
1532 return
1532 return
1533 # we can't fully delete the repository as it may contain
1533 # we can't fully delete the repository as it may contain
1534 # local-only history
1534 # local-only history
1535 self.ui.note(_('removing subrepo %s\n') % self._relpath)
1535 self.ui.note(_('removing subrepo %s\n') % self._relpath)
1536 self._gitcommand(['config', 'core.bare', 'true'])
1536 self._gitcommand(['config', 'core.bare', 'true'])
1537 for f in os.listdir(self._abspath):
1537 for f in os.listdir(self._abspath):
1538 if f == '.git':
1538 if f == '.git':
1539 continue
1539 continue
1540 path = os.path.join(self._abspath, f)
1540 path = os.path.join(self._abspath, f)
1541 if os.path.isdir(path) and not os.path.islink(path):
1541 if os.path.isdir(path) and not os.path.islink(path):
1542 shutil.rmtree(path)
1542 shutil.rmtree(path)
1543 else:
1543 else:
1544 os.remove(path)
1544 os.remove(path)
1545
1545
1546 def archive(self, archiver, prefix, match=None):
1546 def archive(self, archiver, prefix, match=None):
1547 total = 0
1547 total = 0
1548 source, revision = self._state
1548 source, revision = self._state
1549 if not revision:
1549 if not revision:
1550 return total
1550 return total
1551 self._fetch(source, revision)
1551 self._fetch(source, revision)
1552
1552
1553 # Parse git's native archive command.
1553 # Parse git's native archive command.
1554 # This should be much faster than manually traversing the trees
1554 # This should be much faster than manually traversing the trees
1555 # and objects with many subprocess calls.
1555 # and objects with many subprocess calls.
1556 tarstream = self._gitcommand(['archive', revision], stream=True)
1556 tarstream = self._gitcommand(['archive', revision], stream=True)
1557 tar = tarfile.open(fileobj=tarstream, mode='r|')
1557 tar = tarfile.open(fileobj=tarstream, mode='r|')
1558 relpath = subrelpath(self)
1558 relpath = subrelpath(self)
1559 self.ui.progress(_('archiving (%s)') % relpath, 0, unit=_('files'))
1559 self.ui.progress(_('archiving (%s)') % relpath, 0, unit=_('files'))
1560 for i, info in enumerate(tar):
1560 for i, info in enumerate(tar):
1561 if info.isdir():
1561 if info.isdir():
1562 continue
1562 continue
1563 if match and not match(info.name):
1563 if match and not match(info.name):
1564 continue
1564 continue
1565 if info.issym():
1565 if info.issym():
1566 data = info.linkname
1566 data = info.linkname
1567 else:
1567 else:
1568 data = tar.extractfile(info).read()
1568 data = tar.extractfile(info).read()
1569 archiver.addfile(os.path.join(prefix, self._path, info.name),
1569 archiver.addfile(os.path.join(prefix, self._path, info.name),
1570 info.mode, info.issym(), data)
1570 info.mode, info.issym(), data)
1571 total += 1
1571 total += 1
1572 self.ui.progress(_('archiving (%s)') % relpath, i + 1,
1572 self.ui.progress(_('archiving (%s)') % relpath, i + 1,
1573 unit=_('files'))
1573 unit=_('files'))
1574 self.ui.progress(_('archiving (%s)') % relpath, None)
1574 self.ui.progress(_('archiving (%s)') % relpath, None)
1575 return total
1575 return total
1576
1576
1577
1577
1578 @annotatesubrepoerror
1578 @annotatesubrepoerror
1579 def status(self, rev2, **opts):
1579 def status(self, rev2, **opts):
1580 rev1 = self._state[1]
1580 rev1 = self._state[1]
1581 if self._gitmissing() or not rev1:
1581 if self._gitmissing() or not rev1:
1582 # if the repo is missing, return no results
1582 # if the repo is missing, return no results
1583 return [], [], [], [], [], [], []
1583 return [], [], [], [], [], [], []
1584 modified, added, removed = [], [], []
1584 modified, added, removed = [], [], []
1585 self._gitupdatestat()
1585 self._gitupdatestat()
1586 if rev2:
1586 if rev2:
1587 command = ['diff-tree', rev1, rev2]
1587 command = ['diff-tree', rev1, rev2]
1588 else:
1588 else:
1589 command = ['diff-index', rev1]
1589 command = ['diff-index', rev1]
1590 out = self._gitcommand(command)
1590 out = self._gitcommand(command)
1591 for line in out.split('\n'):
1591 for line in out.split('\n'):
1592 tab = line.find('\t')
1592 tab = line.find('\t')
1593 if tab == -1:
1593 if tab == -1:
1594 continue
1594 continue
1595 status, f = line[tab - 1], line[tab + 1:]
1595 status, f = line[tab - 1], line[tab + 1:]
1596 if status == 'M':
1596 if status == 'M':
1597 modified.append(f)
1597 modified.append(f)
1598 elif status == 'A':
1598 elif status == 'A':
1599 added.append(f)
1599 added.append(f)
1600 elif status == 'D':
1600 elif status == 'D':
1601 removed.append(f)
1601 removed.append(f)
1602
1602
1603 deleted, unknown, ignored, clean = [], [], [], []
1603 deleted, unknown, ignored, clean = [], [], [], []
1604
1604
1605 if not rev2:
1605 if not rev2:
1606 command = ['ls-files', '--others', '--exclude-standard']
1606 command = ['ls-files', '--others', '--exclude-standard']
1607 out = self._gitcommand(command)
1607 out = self._gitcommand(command)
1608 for line in out.split('\n'):
1608 for line in out.split('\n'):
1609 if len(line) == 0:
1609 if len(line) == 0:
1610 continue
1610 continue
1611 unknown.append(line)
1611 unknown.append(line)
1612
1612
1613 return scmutil.status(modified, added, removed, deleted,
1613 return scmutil.status(modified, added, removed, deleted,
1614 unknown, ignored, clean)
1614 unknown, ignored, clean)
1615
1615
1616 @annotatesubrepoerror
1616 @annotatesubrepoerror
1617 def diff(self, ui, diffopts, node2, match, prefix, **opts):
1617 def diff(self, ui, diffopts, node2, match, prefix, **opts):
1618 node1 = self._state[1]
1618 node1 = self._state[1]
1619 cmd = ['diff']
1619 cmd = ['diff']
1620 if opts['stat']:
1620 if opts['stat']:
1621 cmd.append('--stat')
1621 cmd.append('--stat')
1622 else:
1622 else:
1623 # for Git, this also implies '-p'
1623 # for Git, this also implies '-p'
1624 cmd.append('-U%d' % diffopts.context)
1624 cmd.append('-U%d' % diffopts.context)
1625
1625
1626 gitprefix = os.path.join(prefix, self._path)
1626 gitprefix = os.path.join(prefix, self._path)
1627
1627
1628 if diffopts.noprefix:
1628 if diffopts.noprefix:
1629 cmd.extend(['--src-prefix=%s/' % gitprefix,
1629 cmd.extend(['--src-prefix=%s/' % gitprefix,
1630 '--dst-prefix=%s/' % gitprefix])
1630 '--dst-prefix=%s/' % gitprefix])
1631 else:
1631 else:
1632 cmd.extend(['--src-prefix=a/%s/' % gitprefix,
1632 cmd.extend(['--src-prefix=a/%s/' % gitprefix,
1633 '--dst-prefix=b/%s/' % gitprefix])
1633 '--dst-prefix=b/%s/' % gitprefix])
1634
1634
1635 if diffopts.ignorews:
1635 if diffopts.ignorews:
1636 cmd.append('--ignore-all-space')
1636 cmd.append('--ignore-all-space')
1637 if diffopts.ignorewsamount:
1637 if diffopts.ignorewsamount:
1638 cmd.append('--ignore-space-change')
1638 cmd.append('--ignore-space-change')
1639 if self._gitversion(self._gitcommand(['--version'])) >= (1, 8, 4) \
1639 if self._gitversion(self._gitcommand(['--version'])) >= (1, 8, 4) \
1640 and diffopts.ignoreblanklines:
1640 and diffopts.ignoreblanklines:
1641 cmd.append('--ignore-blank-lines')
1641 cmd.append('--ignore-blank-lines')
1642
1642
1643 cmd.append(node1)
1643 cmd.append(node1)
1644 if node2:
1644 if node2:
1645 cmd.append(node2)
1645 cmd.append(node2)
1646
1646
1647 if match.anypats():
1647 if match.anypats():
1648 return #No support for include/exclude yet
1648 return #No support for include/exclude yet
1649
1649
1650 if match.always():
1650 if match.always():
1651 ui.write(self._gitcommand(cmd))
1651 ui.write(self._gitcommand(cmd))
1652 elif match.files():
1652 elif match.files():
1653 for f in match.files():
1653 for f in match.files():
1654 ui.write(self._gitcommand(cmd + [f]))
1654 ui.write(self._gitcommand(cmd + [f]))
1655 elif match(gitprefix): #Subrepo is matched
1655 elif match(gitprefix): #Subrepo is matched
1656 ui.write(self._gitcommand(cmd))
1656 ui.write(self._gitcommand(cmd))
1657
1657
1658 @annotatesubrepoerror
1658 def revert(self, substate, *pats, **opts):
1659 def revert(self, substate, *pats, **opts):
1659 self.ui.status(_('reverting subrepo %s\n') % substate[0])
1660 self.ui.status(_('reverting subrepo %s\n') % substate[0])
1660 if not opts.get('no_backup'):
1661 if not opts.get('no_backup'):
1661 status = self.status(None)
1662 status = self.status(None)
1662 names = status.modified
1663 names = status.modified
1663 for name in names:
1664 for name in names:
1664 bakname = "%s.orig" % name
1665 bakname = "%s.orig" % name
1665 self.ui.note(_('saving current version of %s as %s\n') %
1666 self.ui.note(_('saving current version of %s as %s\n') %
1666 (name, bakname))
1667 (name, bakname))
1667 util.rename(os.path.join(self._abspath, name),
1668 util.rename(os.path.join(self._abspath, name),
1668 os.path.join(self._abspath, bakname))
1669 os.path.join(self._abspath, bakname))
1669
1670
1670 self.get(substate, overwrite=True)
1671 self.get(substate, overwrite=True)
1671 return []
1672 return []
1672
1673
1673 def shortid(self, revid):
1674 def shortid(self, revid):
1674 return revid[:7]
1675 return revid[:7]
1675
1676
1676 types = {
1677 types = {
1677 'hg': hgsubrepo,
1678 'hg': hgsubrepo,
1678 'svn': svnsubrepo,
1679 'svn': svnsubrepo,
1679 'git': gitsubrepo,
1680 'git': gitsubrepo,
1680 }
1681 }
General Comments 0
You need to be logged in to leave comments. Login now