##// END OF EJS Templates
merge.recordupdates: mark 'a' files as added unconditionally...
Siddharth Agarwal -
r27132:baa7571f default
parent child Browse files
Show More
@@ -1,1517 +1,1516 b''
1 # merge.py - directory-level update/merge handling for Mercurial
1 # merge.py - directory-level update/merge handling for Mercurial
2 #
2 #
3 # Copyright 2006, 2007 Matt Mackall <mpm@selenic.com>
3 # Copyright 2006, 2007 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 from __future__ import absolute_import
8 from __future__ import absolute_import
9
9
10 import errno
10 import errno
11 import os
11 import os
12 import shutil
12 import shutil
13 import struct
13 import struct
14
14
15 from .i18n import _
15 from .i18n import _
16 from .node import (
16 from .node import (
17 bin,
17 bin,
18 hex,
18 hex,
19 nullhex,
19 nullhex,
20 nullid,
20 nullid,
21 nullrev,
21 nullrev,
22 )
22 )
23 from . import (
23 from . import (
24 copies,
24 copies,
25 destutil,
25 destutil,
26 error,
26 error,
27 filemerge,
27 filemerge,
28 obsolete,
28 obsolete,
29 subrepo,
29 subrepo,
30 util,
30 util,
31 worker,
31 worker,
32 )
32 )
33
33
34 _pack = struct.pack
34 _pack = struct.pack
35 _unpack = struct.unpack
35 _unpack = struct.unpack
36
36
37 def _droponode(data):
37 def _droponode(data):
38 # used for compatibility for v1
38 # used for compatibility for v1
39 bits = data.split('\0')
39 bits = data.split('\0')
40 bits = bits[:-2] + bits[-1:]
40 bits = bits[:-2] + bits[-1:]
41 return '\0'.join(bits)
41 return '\0'.join(bits)
42
42
43 class mergestate(object):
43 class mergestate(object):
44 '''track 3-way merge state of individual files
44 '''track 3-way merge state of individual files
45
45
46 The merge state is stored on disk when needed. Two files are used: one with
46 The merge state is stored on disk when needed. Two files are used: one with
47 an old format (version 1), and one with a new format (version 2). Version 2
47 an old format (version 1), and one with a new format (version 2). Version 2
48 stores a superset of the data in version 1, including new kinds of records
48 stores a superset of the data in version 1, including new kinds of records
49 in the future. For more about the new format, see the documentation for
49 in the future. For more about the new format, see the documentation for
50 `_readrecordsv2`.
50 `_readrecordsv2`.
51
51
52 Each record can contain arbitrary content, and has an associated type. This
52 Each record can contain arbitrary content, and has an associated type. This
53 `type` should be a letter. If `type` is uppercase, the record is mandatory:
53 `type` should be a letter. If `type` is uppercase, the record is mandatory:
54 versions of Mercurial that don't support it should abort. If `type` is
54 versions of Mercurial that don't support it should abort. If `type` is
55 lowercase, the record can be safely ignored.
55 lowercase, the record can be safely ignored.
56
56
57 Currently known records:
57 Currently known records:
58
58
59 L: the node of the "local" part of the merge (hexified version)
59 L: the node of the "local" part of the merge (hexified version)
60 O: the node of the "other" part of the merge (hexified version)
60 O: the node of the "other" part of the merge (hexified version)
61 F: a file to be merged entry
61 F: a file to be merged entry
62 C: a change/delete or delete/change conflict
62 C: a change/delete or delete/change conflict
63 D: a file that the external merge driver will merge internally
63 D: a file that the external merge driver will merge internally
64 (experimental)
64 (experimental)
65 m: the external merge driver defined for this merge plus its run state
65 m: the external merge driver defined for this merge plus its run state
66 (experimental)
66 (experimental)
67 X: unsupported mandatory record type (used in tests)
67 X: unsupported mandatory record type (used in tests)
68 x: unsupported advisory record type (used in tests)
68 x: unsupported advisory record type (used in tests)
69
69
70 Merge driver run states (experimental):
70 Merge driver run states (experimental):
71 u: driver-resolved files unmarked -- needs to be run next time we're about
71 u: driver-resolved files unmarked -- needs to be run next time we're about
72 to resolve or commit
72 to resolve or commit
73 m: driver-resolved files marked -- only needs to be run before commit
73 m: driver-resolved files marked -- only needs to be run before commit
74 s: success/skipped -- does not need to be run any more
74 s: success/skipped -- does not need to be run any more
75
75
76 '''
76 '''
77 statepathv1 = 'merge/state'
77 statepathv1 = 'merge/state'
78 statepathv2 = 'merge/state2'
78 statepathv2 = 'merge/state2'
79
79
80 @staticmethod
80 @staticmethod
81 def clean(repo, node=None, other=None):
81 def clean(repo, node=None, other=None):
82 """Initialize a brand new merge state, removing any existing state on
82 """Initialize a brand new merge state, removing any existing state on
83 disk."""
83 disk."""
84 ms = mergestate(repo)
84 ms = mergestate(repo)
85 ms.reset(node, other)
85 ms.reset(node, other)
86 return ms
86 return ms
87
87
88 @staticmethod
88 @staticmethod
89 def read(repo):
89 def read(repo):
90 """Initialize the merge state, reading it from disk."""
90 """Initialize the merge state, reading it from disk."""
91 ms = mergestate(repo)
91 ms = mergestate(repo)
92 ms._read()
92 ms._read()
93 return ms
93 return ms
94
94
95 def __init__(self, repo):
95 def __init__(self, repo):
96 """Initialize the merge state.
96 """Initialize the merge state.
97
97
98 Do not use this directly! Instead call read() or clean()."""
98 Do not use this directly! Instead call read() or clean()."""
99 self._repo = repo
99 self._repo = repo
100 self._dirty = False
100 self._dirty = False
101
101
102 def reset(self, node=None, other=None):
102 def reset(self, node=None, other=None):
103 self._state = {}
103 self._state = {}
104 self._local = None
104 self._local = None
105 self._other = None
105 self._other = None
106 for var in ('localctx', 'otherctx'):
106 for var in ('localctx', 'otherctx'):
107 if var in vars(self):
107 if var in vars(self):
108 delattr(self, var)
108 delattr(self, var)
109 if node:
109 if node:
110 self._local = node
110 self._local = node
111 self._other = other
111 self._other = other
112 self._readmergedriver = None
112 self._readmergedriver = None
113 if self.mergedriver:
113 if self.mergedriver:
114 self._mdstate = 's'
114 self._mdstate = 's'
115 else:
115 else:
116 self._mdstate = 'u'
116 self._mdstate = 'u'
117 shutil.rmtree(self._repo.join('merge'), True)
117 shutil.rmtree(self._repo.join('merge'), True)
118 self._results = {}
118 self._results = {}
119 self._dirty = False
119 self._dirty = False
120
120
121 def _read(self):
121 def _read(self):
122 """Analyse each record content to restore a serialized state from disk
122 """Analyse each record content to restore a serialized state from disk
123
123
124 This function process "record" entry produced by the de-serialization
124 This function process "record" entry produced by the de-serialization
125 of on disk file.
125 of on disk file.
126 """
126 """
127 self._state = {}
127 self._state = {}
128 self._local = None
128 self._local = None
129 self._other = None
129 self._other = None
130 for var in ('localctx', 'otherctx'):
130 for var in ('localctx', 'otherctx'):
131 if var in vars(self):
131 if var in vars(self):
132 delattr(self, var)
132 delattr(self, var)
133 self._readmergedriver = None
133 self._readmergedriver = None
134 self._mdstate = 's'
134 self._mdstate = 's'
135 unsupported = set()
135 unsupported = set()
136 records = self._readrecords()
136 records = self._readrecords()
137 for rtype, record in records:
137 for rtype, record in records:
138 if rtype == 'L':
138 if rtype == 'L':
139 self._local = bin(record)
139 self._local = bin(record)
140 elif rtype == 'O':
140 elif rtype == 'O':
141 self._other = bin(record)
141 self._other = bin(record)
142 elif rtype == 'm':
142 elif rtype == 'm':
143 bits = record.split('\0', 1)
143 bits = record.split('\0', 1)
144 mdstate = bits[1]
144 mdstate = bits[1]
145 if len(mdstate) != 1 or mdstate not in 'ums':
145 if len(mdstate) != 1 or mdstate not in 'ums':
146 # the merge driver should be idempotent, so just rerun it
146 # the merge driver should be idempotent, so just rerun it
147 mdstate = 'u'
147 mdstate = 'u'
148
148
149 self._readmergedriver = bits[0]
149 self._readmergedriver = bits[0]
150 self._mdstate = mdstate
150 self._mdstate = mdstate
151 elif rtype in 'FDC':
151 elif rtype in 'FDC':
152 bits = record.split('\0')
152 bits = record.split('\0')
153 self._state[bits[0]] = bits[1:]
153 self._state[bits[0]] = bits[1:]
154 elif not rtype.islower():
154 elif not rtype.islower():
155 unsupported.add(rtype)
155 unsupported.add(rtype)
156 self._results = {}
156 self._results = {}
157 self._dirty = False
157 self._dirty = False
158
158
159 if unsupported:
159 if unsupported:
160 raise error.UnsupportedMergeRecords(unsupported)
160 raise error.UnsupportedMergeRecords(unsupported)
161
161
162 def _readrecords(self):
162 def _readrecords(self):
163 """Read merge state from disk and return a list of record (TYPE, data)
163 """Read merge state from disk and return a list of record (TYPE, data)
164
164
165 We read data from both v1 and v2 files and decide which one to use.
165 We read data from both v1 and v2 files and decide which one to use.
166
166
167 V1 has been used by version prior to 2.9.1 and contains less data than
167 V1 has been used by version prior to 2.9.1 and contains less data than
168 v2. We read both versions and check if no data in v2 contradicts
168 v2. We read both versions and check if no data in v2 contradicts
169 v1. If there is not contradiction we can safely assume that both v1
169 v1. If there is not contradiction we can safely assume that both v1
170 and v2 were written at the same time and use the extract data in v2. If
170 and v2 were written at the same time and use the extract data in v2. If
171 there is contradiction we ignore v2 content as we assume an old version
171 there is contradiction we ignore v2 content as we assume an old version
172 of Mercurial has overwritten the mergestate file and left an old v2
172 of Mercurial has overwritten the mergestate file and left an old v2
173 file around.
173 file around.
174
174
175 returns list of record [(TYPE, data), ...]"""
175 returns list of record [(TYPE, data), ...]"""
176 v1records = self._readrecordsv1()
176 v1records = self._readrecordsv1()
177 v2records = self._readrecordsv2()
177 v2records = self._readrecordsv2()
178 if self._v1v2match(v1records, v2records):
178 if self._v1v2match(v1records, v2records):
179 return v2records
179 return v2records
180 else:
180 else:
181 # v1 file is newer than v2 file, use it
181 # v1 file is newer than v2 file, use it
182 # we have to infer the "other" changeset of the merge
182 # we have to infer the "other" changeset of the merge
183 # we cannot do better than that with v1 of the format
183 # we cannot do better than that with v1 of the format
184 mctx = self._repo[None].parents()[-1]
184 mctx = self._repo[None].parents()[-1]
185 v1records.append(('O', mctx.hex()))
185 v1records.append(('O', mctx.hex()))
186 # add place holder "other" file node information
186 # add place holder "other" file node information
187 # nobody is using it yet so we do no need to fetch the data
187 # nobody is using it yet so we do no need to fetch the data
188 # if mctx was wrong `mctx[bits[-2]]` may fails.
188 # if mctx was wrong `mctx[bits[-2]]` may fails.
189 for idx, r in enumerate(v1records):
189 for idx, r in enumerate(v1records):
190 if r[0] == 'F':
190 if r[0] == 'F':
191 bits = r[1].split('\0')
191 bits = r[1].split('\0')
192 bits.insert(-2, '')
192 bits.insert(-2, '')
193 v1records[idx] = (r[0], '\0'.join(bits))
193 v1records[idx] = (r[0], '\0'.join(bits))
194 return v1records
194 return v1records
195
195
196 def _v1v2match(self, v1records, v2records):
196 def _v1v2match(self, v1records, v2records):
197 oldv2 = set() # old format version of v2 record
197 oldv2 = set() # old format version of v2 record
198 for rec in v2records:
198 for rec in v2records:
199 if rec[0] == 'L':
199 if rec[0] == 'L':
200 oldv2.add(rec)
200 oldv2.add(rec)
201 elif rec[0] == 'F':
201 elif rec[0] == 'F':
202 # drop the onode data (not contained in v1)
202 # drop the onode data (not contained in v1)
203 oldv2.add(('F', _droponode(rec[1])))
203 oldv2.add(('F', _droponode(rec[1])))
204 for rec in v1records:
204 for rec in v1records:
205 if rec not in oldv2:
205 if rec not in oldv2:
206 return False
206 return False
207 else:
207 else:
208 return True
208 return True
209
209
210 def _readrecordsv1(self):
210 def _readrecordsv1(self):
211 """read on disk merge state for version 1 file
211 """read on disk merge state for version 1 file
212
212
213 returns list of record [(TYPE, data), ...]
213 returns list of record [(TYPE, data), ...]
214
214
215 Note: the "F" data from this file are one entry short
215 Note: the "F" data from this file are one entry short
216 (no "other file node" entry)
216 (no "other file node" entry)
217 """
217 """
218 records = []
218 records = []
219 try:
219 try:
220 f = self._repo.vfs(self.statepathv1)
220 f = self._repo.vfs(self.statepathv1)
221 for i, l in enumerate(f):
221 for i, l in enumerate(f):
222 if i == 0:
222 if i == 0:
223 records.append(('L', l[:-1]))
223 records.append(('L', l[:-1]))
224 else:
224 else:
225 records.append(('F', l[:-1]))
225 records.append(('F', l[:-1]))
226 f.close()
226 f.close()
227 except IOError as err:
227 except IOError as err:
228 if err.errno != errno.ENOENT:
228 if err.errno != errno.ENOENT:
229 raise
229 raise
230 return records
230 return records
231
231
232 def _readrecordsv2(self):
232 def _readrecordsv2(self):
233 """read on disk merge state for version 2 file
233 """read on disk merge state for version 2 file
234
234
235 This format is a list of arbitrary records of the form:
235 This format is a list of arbitrary records of the form:
236
236
237 [type][length][content]
237 [type][length][content]
238
238
239 `type` is a single character, `length` is a 4 byte integer, and
239 `type` is a single character, `length` is a 4 byte integer, and
240 `content` is an arbitrary byte sequence of length `length`.
240 `content` is an arbitrary byte sequence of length `length`.
241
241
242 Mercurial versions prior to 3.7 have a bug where if there are
242 Mercurial versions prior to 3.7 have a bug where if there are
243 unsupported mandatory merge records, attempting to clear out the merge
243 unsupported mandatory merge records, attempting to clear out the merge
244 state with hg update --clean or similar aborts. The 't' record type
244 state with hg update --clean or similar aborts. The 't' record type
245 works around that by writing out what those versions treat as an
245 works around that by writing out what those versions treat as an
246 advisory record, but later versions interpret as special: the first
246 advisory record, but later versions interpret as special: the first
247 character is the 'real' record type and everything onwards is the data.
247 character is the 'real' record type and everything onwards is the data.
248
248
249 Returns list of records [(TYPE, data), ...]."""
249 Returns list of records [(TYPE, data), ...]."""
250 records = []
250 records = []
251 try:
251 try:
252 f = self._repo.vfs(self.statepathv2)
252 f = self._repo.vfs(self.statepathv2)
253 data = f.read()
253 data = f.read()
254 off = 0
254 off = 0
255 end = len(data)
255 end = len(data)
256 while off < end:
256 while off < end:
257 rtype = data[off]
257 rtype = data[off]
258 off += 1
258 off += 1
259 length = _unpack('>I', data[off:(off + 4)])[0]
259 length = _unpack('>I', data[off:(off + 4)])[0]
260 off += 4
260 off += 4
261 record = data[off:(off + length)]
261 record = data[off:(off + length)]
262 off += length
262 off += length
263 if rtype == 't':
263 if rtype == 't':
264 rtype, record = record[0], record[1:]
264 rtype, record = record[0], record[1:]
265 records.append((rtype, record))
265 records.append((rtype, record))
266 f.close()
266 f.close()
267 except IOError as err:
267 except IOError as err:
268 if err.errno != errno.ENOENT:
268 if err.errno != errno.ENOENT:
269 raise
269 raise
270 return records
270 return records
271
271
272 @util.propertycache
272 @util.propertycache
273 def mergedriver(self):
273 def mergedriver(self):
274 # protect against the following:
274 # protect against the following:
275 # - A configures a malicious merge driver in their hgrc, then
275 # - A configures a malicious merge driver in their hgrc, then
276 # pauses the merge
276 # pauses the merge
277 # - A edits their hgrc to remove references to the merge driver
277 # - A edits their hgrc to remove references to the merge driver
278 # - A gives a copy of their entire repo, including .hg, to B
278 # - A gives a copy of their entire repo, including .hg, to B
279 # - B inspects .hgrc and finds it to be clean
279 # - B inspects .hgrc and finds it to be clean
280 # - B then continues the merge and the malicious merge driver
280 # - B then continues the merge and the malicious merge driver
281 # gets invoked
281 # gets invoked
282 configmergedriver = self._repo.ui.config('experimental', 'mergedriver')
282 configmergedriver = self._repo.ui.config('experimental', 'mergedriver')
283 if (self._readmergedriver is not None
283 if (self._readmergedriver is not None
284 and self._readmergedriver != configmergedriver):
284 and self._readmergedriver != configmergedriver):
285 raise error.ConfigError(
285 raise error.ConfigError(
286 _("merge driver changed since merge started"),
286 _("merge driver changed since merge started"),
287 hint=_("revert merge driver change or abort merge"))
287 hint=_("revert merge driver change or abort merge"))
288
288
289 return configmergedriver
289 return configmergedriver
290
290
291 @util.propertycache
291 @util.propertycache
292 def localctx(self):
292 def localctx(self):
293 if self._local is None:
293 if self._local is None:
294 raise RuntimeError("localctx accessed but self._local isn't set")
294 raise RuntimeError("localctx accessed but self._local isn't set")
295 return self._repo[self._local]
295 return self._repo[self._local]
296
296
297 @util.propertycache
297 @util.propertycache
298 def otherctx(self):
298 def otherctx(self):
299 if self._other is None:
299 if self._other is None:
300 raise RuntimeError("localctx accessed but self._local isn't set")
300 raise RuntimeError("localctx accessed but self._local isn't set")
301 return self._repo[self._other]
301 return self._repo[self._other]
302
302
303 def active(self):
303 def active(self):
304 """Whether mergestate is active.
304 """Whether mergestate is active.
305
305
306 Returns True if there appears to be mergestate. This is a rough proxy
306 Returns True if there appears to be mergestate. This is a rough proxy
307 for "is a merge in progress."
307 for "is a merge in progress."
308 """
308 """
309 # Check local variables before looking at filesystem for performance
309 # Check local variables before looking at filesystem for performance
310 # reasons.
310 # reasons.
311 return bool(self._local) or bool(self._state) or \
311 return bool(self._local) or bool(self._state) or \
312 self._repo.vfs.exists(self.statepathv1) or \
312 self._repo.vfs.exists(self.statepathv1) or \
313 self._repo.vfs.exists(self.statepathv2)
313 self._repo.vfs.exists(self.statepathv2)
314
314
315 def commit(self):
315 def commit(self):
316 """Write current state on disk (if necessary)"""
316 """Write current state on disk (if necessary)"""
317 if self._dirty:
317 if self._dirty:
318 records = self._makerecords()
318 records = self._makerecords()
319 self._writerecords(records)
319 self._writerecords(records)
320 self._dirty = False
320 self._dirty = False
321
321
322 def _makerecords(self):
322 def _makerecords(self):
323 records = []
323 records = []
324 records.append(('L', hex(self._local)))
324 records.append(('L', hex(self._local)))
325 records.append(('O', hex(self._other)))
325 records.append(('O', hex(self._other)))
326 if self.mergedriver:
326 if self.mergedriver:
327 records.append(('m', '\0'.join([
327 records.append(('m', '\0'.join([
328 self.mergedriver, self._mdstate])))
328 self.mergedriver, self._mdstate])))
329 for d, v in self._state.iteritems():
329 for d, v in self._state.iteritems():
330 if v[0] == 'd':
330 if v[0] == 'd':
331 records.append(('D', '\0'.join([d] + v)))
331 records.append(('D', '\0'.join([d] + v)))
332 # v[1] == local ('cd'), v[6] == other ('dc') -- not supported by
332 # v[1] == local ('cd'), v[6] == other ('dc') -- not supported by
333 # older versions of Mercurial
333 # older versions of Mercurial
334 elif v[1] == nullhex or v[6] == nullhex:
334 elif v[1] == nullhex or v[6] == nullhex:
335 records.append(('C', '\0'.join([d] + v)))
335 records.append(('C', '\0'.join([d] + v)))
336 else:
336 else:
337 records.append(('F', '\0'.join([d] + v)))
337 records.append(('F', '\0'.join([d] + v)))
338 return records
338 return records
339
339
340 def _writerecords(self, records):
340 def _writerecords(self, records):
341 """Write current state on disk (both v1 and v2)"""
341 """Write current state on disk (both v1 and v2)"""
342 self._writerecordsv1(records)
342 self._writerecordsv1(records)
343 self._writerecordsv2(records)
343 self._writerecordsv2(records)
344
344
345 def _writerecordsv1(self, records):
345 def _writerecordsv1(self, records):
346 """Write current state on disk in a version 1 file"""
346 """Write current state on disk in a version 1 file"""
347 f = self._repo.vfs(self.statepathv1, 'w')
347 f = self._repo.vfs(self.statepathv1, 'w')
348 irecords = iter(records)
348 irecords = iter(records)
349 lrecords = irecords.next()
349 lrecords = irecords.next()
350 assert lrecords[0] == 'L'
350 assert lrecords[0] == 'L'
351 f.write(hex(self._local) + '\n')
351 f.write(hex(self._local) + '\n')
352 for rtype, data in irecords:
352 for rtype, data in irecords:
353 if rtype == 'F':
353 if rtype == 'F':
354 f.write('%s\n' % _droponode(data))
354 f.write('%s\n' % _droponode(data))
355 f.close()
355 f.close()
356
356
357 def _writerecordsv2(self, records):
357 def _writerecordsv2(self, records):
358 """Write current state on disk in a version 2 file
358 """Write current state on disk in a version 2 file
359
359
360 See the docstring for _readrecordsv2 for why we use 't'."""
360 See the docstring for _readrecordsv2 for why we use 't'."""
361 # these are the records that all version 2 clients can read
361 # these are the records that all version 2 clients can read
362 whitelist = 'LOF'
362 whitelist = 'LOF'
363 f = self._repo.vfs(self.statepathv2, 'w')
363 f = self._repo.vfs(self.statepathv2, 'w')
364 for key, data in records:
364 for key, data in records:
365 assert len(key) == 1
365 assert len(key) == 1
366 if key not in whitelist:
366 if key not in whitelist:
367 key, data = 't', '%s%s' % (key, data)
367 key, data = 't', '%s%s' % (key, data)
368 format = '>sI%is' % len(data)
368 format = '>sI%is' % len(data)
369 f.write(_pack(format, key, len(data), data))
369 f.write(_pack(format, key, len(data), data))
370 f.close()
370 f.close()
371
371
372 def add(self, fcl, fco, fca, fd):
372 def add(self, fcl, fco, fca, fd):
373 """add a new (potentially?) conflicting file the merge state
373 """add a new (potentially?) conflicting file the merge state
374 fcl: file context for local,
374 fcl: file context for local,
375 fco: file context for remote,
375 fco: file context for remote,
376 fca: file context for ancestors,
376 fca: file context for ancestors,
377 fd: file path of the resulting merge.
377 fd: file path of the resulting merge.
378
378
379 note: also write the local version to the `.hg/merge` directory.
379 note: also write the local version to the `.hg/merge` directory.
380 """
380 """
381 if fcl.isabsent():
381 if fcl.isabsent():
382 hash = nullhex
382 hash = nullhex
383 else:
383 else:
384 hash = util.sha1(fcl.path()).hexdigest()
384 hash = util.sha1(fcl.path()).hexdigest()
385 self._repo.vfs.write('merge/' + hash, fcl.data())
385 self._repo.vfs.write('merge/' + hash, fcl.data())
386 self._state[fd] = ['u', hash, fcl.path(),
386 self._state[fd] = ['u', hash, fcl.path(),
387 fca.path(), hex(fca.filenode()),
387 fca.path(), hex(fca.filenode()),
388 fco.path(), hex(fco.filenode()),
388 fco.path(), hex(fco.filenode()),
389 fcl.flags()]
389 fcl.flags()]
390 self._dirty = True
390 self._dirty = True
391
391
392 def __contains__(self, dfile):
392 def __contains__(self, dfile):
393 return dfile in self._state
393 return dfile in self._state
394
394
395 def __getitem__(self, dfile):
395 def __getitem__(self, dfile):
396 return self._state[dfile][0]
396 return self._state[dfile][0]
397
397
398 def __iter__(self):
398 def __iter__(self):
399 return iter(sorted(self._state))
399 return iter(sorted(self._state))
400
400
401 def files(self):
401 def files(self):
402 return self._state.keys()
402 return self._state.keys()
403
403
404 def mark(self, dfile, state):
404 def mark(self, dfile, state):
405 self._state[dfile][0] = state
405 self._state[dfile][0] = state
406 self._dirty = True
406 self._dirty = True
407
407
408 def mdstate(self):
408 def mdstate(self):
409 return self._mdstate
409 return self._mdstate
410
410
411 def unresolved(self):
411 def unresolved(self):
412 """Obtain the paths of unresolved files."""
412 """Obtain the paths of unresolved files."""
413
413
414 for f, entry in self._state.items():
414 for f, entry in self._state.items():
415 if entry[0] == 'u':
415 if entry[0] == 'u':
416 yield f
416 yield f
417
417
418 def driverresolved(self):
418 def driverresolved(self):
419 """Obtain the paths of driver-resolved files."""
419 """Obtain the paths of driver-resolved files."""
420
420
421 for f, entry in self._state.items():
421 for f, entry in self._state.items():
422 if entry[0] == 'd':
422 if entry[0] == 'd':
423 yield f
423 yield f
424
424
425 def _resolve(self, preresolve, dfile, wctx, labels=None):
425 def _resolve(self, preresolve, dfile, wctx, labels=None):
426 """rerun merge process for file path `dfile`"""
426 """rerun merge process for file path `dfile`"""
427 if self[dfile] in 'rd':
427 if self[dfile] in 'rd':
428 return True, 0
428 return True, 0
429 stateentry = self._state[dfile]
429 stateentry = self._state[dfile]
430 state, hash, lfile, afile, anode, ofile, onode, flags = stateentry
430 state, hash, lfile, afile, anode, ofile, onode, flags = stateentry
431 octx = self._repo[self._other]
431 octx = self._repo[self._other]
432 fcd = self._filectxorabsent(hash, wctx, dfile)
432 fcd = self._filectxorabsent(hash, wctx, dfile)
433 fco = self._filectxorabsent(onode, octx, ofile)
433 fco = self._filectxorabsent(onode, octx, ofile)
434 # TODO: move this to filectxorabsent
434 # TODO: move this to filectxorabsent
435 fca = self._repo.filectx(afile, fileid=anode)
435 fca = self._repo.filectx(afile, fileid=anode)
436 # "premerge" x flags
436 # "premerge" x flags
437 flo = fco.flags()
437 flo = fco.flags()
438 fla = fca.flags()
438 fla = fca.flags()
439 if 'x' in flags + flo + fla and 'l' not in flags + flo + fla:
439 if 'x' in flags + flo + fla and 'l' not in flags + flo + fla:
440 if fca.node() == nullid:
440 if fca.node() == nullid:
441 if preresolve:
441 if preresolve:
442 self._repo.ui.warn(
442 self._repo.ui.warn(
443 _('warning: cannot merge flags for %s\n') % afile)
443 _('warning: cannot merge flags for %s\n') % afile)
444 elif flags == fla:
444 elif flags == fla:
445 flags = flo
445 flags = flo
446 if preresolve:
446 if preresolve:
447 # restore local
447 # restore local
448 if hash != nullhex:
448 if hash != nullhex:
449 f = self._repo.vfs('merge/' + hash)
449 f = self._repo.vfs('merge/' + hash)
450 self._repo.wwrite(dfile, f.read(), flags)
450 self._repo.wwrite(dfile, f.read(), flags)
451 f.close()
451 f.close()
452 else:
452 else:
453 self._repo.wvfs.unlinkpath(dfile, ignoremissing=True)
453 self._repo.wvfs.unlinkpath(dfile, ignoremissing=True)
454 complete, r, deleted = filemerge.premerge(self._repo, self._local,
454 complete, r, deleted = filemerge.premerge(self._repo, self._local,
455 lfile, fcd, fco, fca,
455 lfile, fcd, fco, fca,
456 labels=labels)
456 labels=labels)
457 else:
457 else:
458 complete, r, deleted = filemerge.filemerge(self._repo, self._local,
458 complete, r, deleted = filemerge.filemerge(self._repo, self._local,
459 lfile, fcd, fco, fca,
459 lfile, fcd, fco, fca,
460 labels=labels)
460 labels=labels)
461 if r is None:
461 if r is None:
462 # no real conflict
462 # no real conflict
463 del self._state[dfile]
463 del self._state[dfile]
464 self._dirty = True
464 self._dirty = True
465 elif not r:
465 elif not r:
466 self.mark(dfile, 'r')
466 self.mark(dfile, 'r')
467
467
468 if complete:
468 if complete:
469 action = None
469 action = None
470 if deleted:
470 if deleted:
471 if fcd.isabsent():
471 if fcd.isabsent():
472 # dc: local picked. Need to drop if present, which may
472 # dc: local picked. Need to drop if present, which may
473 # happen on re-resolves.
473 # happen on re-resolves.
474 action = 'f'
474 action = 'f'
475 else:
475 else:
476 # cd: remote picked (or otherwise deleted)
476 # cd: remote picked (or otherwise deleted)
477 action = 'r'
477 action = 'r'
478 else:
478 else:
479 if fcd.isabsent(): # dc: remote picked
479 if fcd.isabsent(): # dc: remote picked
480 action = 'g'
480 action = 'g'
481 elif fco.isabsent(): # cd: local picked
481 elif fco.isabsent(): # cd: local picked
482 if dfile in self.localctx:
482 if dfile in self.localctx:
483 action = 'am'
483 action = 'am'
484 else:
484 else:
485 action = 'a'
485 action = 'a'
486 # else: regular merges (no action necessary)
486 # else: regular merges (no action necessary)
487 self._results[dfile] = r, action
487 self._results[dfile] = r, action
488
488
489 return complete, r
489 return complete, r
490
490
491 def _filectxorabsent(self, hexnode, ctx, f):
491 def _filectxorabsent(self, hexnode, ctx, f):
492 if hexnode == nullhex:
492 if hexnode == nullhex:
493 return filemerge.absentfilectx(ctx, f)
493 return filemerge.absentfilectx(ctx, f)
494 else:
494 else:
495 return ctx[f]
495 return ctx[f]
496
496
497 def preresolve(self, dfile, wctx, labels=None):
497 def preresolve(self, dfile, wctx, labels=None):
498 """run premerge process for dfile
498 """run premerge process for dfile
499
499
500 Returns whether the merge is complete, and the exit code."""
500 Returns whether the merge is complete, and the exit code."""
501 return self._resolve(True, dfile, wctx, labels=labels)
501 return self._resolve(True, dfile, wctx, labels=labels)
502
502
503 def resolve(self, dfile, wctx, labels=None):
503 def resolve(self, dfile, wctx, labels=None):
504 """run merge process (assuming premerge was run) for dfile
504 """run merge process (assuming premerge was run) for dfile
505
505
506 Returns the exit code of the merge."""
506 Returns the exit code of the merge."""
507 return self._resolve(False, dfile, wctx, labels=labels)[1]
507 return self._resolve(False, dfile, wctx, labels=labels)[1]
508
508
509 def counts(self):
509 def counts(self):
510 """return counts for updated, merged and removed files in this
510 """return counts for updated, merged and removed files in this
511 session"""
511 session"""
512 updated, merged, removed = 0, 0, 0
512 updated, merged, removed = 0, 0, 0
513 for r, action in self._results.itervalues():
513 for r, action in self._results.itervalues():
514 if r is None:
514 if r is None:
515 updated += 1
515 updated += 1
516 elif r == 0:
516 elif r == 0:
517 if action == 'r':
517 if action == 'r':
518 removed += 1
518 removed += 1
519 else:
519 else:
520 merged += 1
520 merged += 1
521 return updated, merged, removed
521 return updated, merged, removed
522
522
523 def unresolvedcount(self):
523 def unresolvedcount(self):
524 """get unresolved count for this merge (persistent)"""
524 """get unresolved count for this merge (persistent)"""
525 return len([True for f, entry in self._state.iteritems()
525 return len([True for f, entry in self._state.iteritems()
526 if entry[0] == 'u'])
526 if entry[0] == 'u'])
527
527
528 def actions(self):
528 def actions(self):
529 """return lists of actions to perform on the dirstate"""
529 """return lists of actions to perform on the dirstate"""
530 actions = {'r': [], 'f': [], 'a': [], 'am': [], 'g': []}
530 actions = {'r': [], 'f': [], 'a': [], 'am': [], 'g': []}
531 for f, (r, action) in self._results.iteritems():
531 for f, (r, action) in self._results.iteritems():
532 if action is not None:
532 if action is not None:
533 actions[action].append((f, None, "merge result"))
533 actions[action].append((f, None, "merge result"))
534 return actions
534 return actions
535
535
536 def recordactions(self):
536 def recordactions(self):
537 """record remove/add/get actions in the dirstate"""
537 """record remove/add/get actions in the dirstate"""
538 branchmerge = self._repo.dirstate.p2() != nullid
538 branchmerge = self._repo.dirstate.p2() != nullid
539 recordupdates(self._repo, self.actions(), branchmerge)
539 recordupdates(self._repo, self.actions(), branchmerge)
540
540
541 def queueremove(self, f):
541 def queueremove(self, f):
542 """queues a file to be removed from the dirstate
542 """queues a file to be removed from the dirstate
543
543
544 Meant for use by custom merge drivers."""
544 Meant for use by custom merge drivers."""
545 self._results[f] = 0, 'r'
545 self._results[f] = 0, 'r'
546
546
547 def queueadd(self, f):
547 def queueadd(self, f):
548 """queues a file to be added to the dirstate
548 """queues a file to be added to the dirstate
549
549
550 Meant for use by custom merge drivers."""
550 Meant for use by custom merge drivers."""
551 self._results[f] = 0, 'a'
551 self._results[f] = 0, 'a'
552
552
553 def queueget(self, f):
553 def queueget(self, f):
554 """queues a file to be marked modified in the dirstate
554 """queues a file to be marked modified in the dirstate
555
555
556 Meant for use by custom merge drivers."""
556 Meant for use by custom merge drivers."""
557 self._results[f] = 0, 'g'
557 self._results[f] = 0, 'g'
558
558
559 def _checkunknownfile(repo, wctx, mctx, f, f2=None):
559 def _checkunknownfile(repo, wctx, mctx, f, f2=None):
560 if f2 is None:
560 if f2 is None:
561 f2 = f
561 f2 = f
562 return (os.path.isfile(repo.wjoin(f))
562 return (os.path.isfile(repo.wjoin(f))
563 and repo.wvfs.audit.check(f)
563 and repo.wvfs.audit.check(f)
564 and repo.dirstate.normalize(f) not in repo.dirstate
564 and repo.dirstate.normalize(f) not in repo.dirstate
565 and mctx[f2].cmp(wctx[f]))
565 and mctx[f2].cmp(wctx[f]))
566
566
567 def _checkunknownfiles(repo, wctx, mctx, force, actions):
567 def _checkunknownfiles(repo, wctx, mctx, force, actions):
568 """
568 """
569 Considers any actions that care about the presence of conflicting unknown
569 Considers any actions that care about the presence of conflicting unknown
570 files. For some actions, the result is to abort; for others, it is to
570 files. For some actions, the result is to abort; for others, it is to
571 choose a different action.
571 choose a different action.
572 """
572 """
573 aborts = []
573 aborts = []
574 if not force:
574 if not force:
575 for f, (m, args, msg) in actions.iteritems():
575 for f, (m, args, msg) in actions.iteritems():
576 if m in ('c', 'dc'):
576 if m in ('c', 'dc'):
577 if _checkunknownfile(repo, wctx, mctx, f):
577 if _checkunknownfile(repo, wctx, mctx, f):
578 aborts.append(f)
578 aborts.append(f)
579 elif m == 'dg':
579 elif m == 'dg':
580 if _checkunknownfile(repo, wctx, mctx, f, args[0]):
580 if _checkunknownfile(repo, wctx, mctx, f, args[0]):
581 aborts.append(f)
581 aborts.append(f)
582
582
583 for f in sorted(aborts):
583 for f in sorted(aborts):
584 repo.ui.warn(_("%s: untracked file differs\n") % f)
584 repo.ui.warn(_("%s: untracked file differs\n") % f)
585 if aborts:
585 if aborts:
586 raise error.Abort(_("untracked files in working directory differ "
586 raise error.Abort(_("untracked files in working directory differ "
587 "from files in requested revision"))
587 "from files in requested revision"))
588
588
589 for f, (m, args, msg) in actions.iteritems():
589 for f, (m, args, msg) in actions.iteritems():
590 if m == 'c':
590 if m == 'c':
591 actions[f] = ('g', args, msg)
591 actions[f] = ('g', args, msg)
592 elif m == 'cm':
592 elif m == 'cm':
593 fl2, anc = args
593 fl2, anc = args
594 different = _checkunknownfile(repo, wctx, mctx, f)
594 different = _checkunknownfile(repo, wctx, mctx, f)
595 if different:
595 if different:
596 actions[f] = ('m', (f, f, None, False, anc),
596 actions[f] = ('m', (f, f, None, False, anc),
597 "remote differs from untracked local")
597 "remote differs from untracked local")
598 else:
598 else:
599 actions[f] = ('g', (fl2,), "remote created")
599 actions[f] = ('g', (fl2,), "remote created")
600
600
601 def _forgetremoved(wctx, mctx, branchmerge):
601 def _forgetremoved(wctx, mctx, branchmerge):
602 """
602 """
603 Forget removed files
603 Forget removed files
604
604
605 If we're jumping between revisions (as opposed to merging), and if
605 If we're jumping between revisions (as opposed to merging), and if
606 neither the working directory nor the target rev has the file,
606 neither the working directory nor the target rev has the file,
607 then we need to remove it from the dirstate, to prevent the
607 then we need to remove it from the dirstate, to prevent the
608 dirstate from listing the file when it is no longer in the
608 dirstate from listing the file when it is no longer in the
609 manifest.
609 manifest.
610
610
611 If we're merging, and the other revision has removed a file
611 If we're merging, and the other revision has removed a file
612 that is not present in the working directory, we need to mark it
612 that is not present in the working directory, we need to mark it
613 as removed.
613 as removed.
614 """
614 """
615
615
616 actions = {}
616 actions = {}
617 m = 'f'
617 m = 'f'
618 if branchmerge:
618 if branchmerge:
619 m = 'r'
619 m = 'r'
620 for f in wctx.deleted():
620 for f in wctx.deleted():
621 if f not in mctx:
621 if f not in mctx:
622 actions[f] = m, None, "forget deleted"
622 actions[f] = m, None, "forget deleted"
623
623
624 if not branchmerge:
624 if not branchmerge:
625 for f in wctx.removed():
625 for f in wctx.removed():
626 if f not in mctx:
626 if f not in mctx:
627 actions[f] = 'f', None, "forget removed"
627 actions[f] = 'f', None, "forget removed"
628
628
629 return actions
629 return actions
630
630
631 def _checkcollision(repo, wmf, actions):
631 def _checkcollision(repo, wmf, actions):
632 # build provisional merged manifest up
632 # build provisional merged manifest up
633 pmmf = set(wmf)
633 pmmf = set(wmf)
634
634
635 if actions:
635 if actions:
636 # k, dr, e and rd are no-op
636 # k, dr, e and rd are no-op
637 for m in 'a', 'am', 'f', 'g', 'cd', 'dc':
637 for m in 'a', 'am', 'f', 'g', 'cd', 'dc':
638 for f, args, msg in actions[m]:
638 for f, args, msg in actions[m]:
639 pmmf.add(f)
639 pmmf.add(f)
640 for f, args, msg in actions['r']:
640 for f, args, msg in actions['r']:
641 pmmf.discard(f)
641 pmmf.discard(f)
642 for f, args, msg in actions['dm']:
642 for f, args, msg in actions['dm']:
643 f2, flags = args
643 f2, flags = args
644 pmmf.discard(f2)
644 pmmf.discard(f2)
645 pmmf.add(f)
645 pmmf.add(f)
646 for f, args, msg in actions['dg']:
646 for f, args, msg in actions['dg']:
647 pmmf.add(f)
647 pmmf.add(f)
648 for f, args, msg in actions['m']:
648 for f, args, msg in actions['m']:
649 f1, f2, fa, move, anc = args
649 f1, f2, fa, move, anc = args
650 if move:
650 if move:
651 pmmf.discard(f1)
651 pmmf.discard(f1)
652 pmmf.add(f)
652 pmmf.add(f)
653
653
654 # check case-folding collision in provisional merged manifest
654 # check case-folding collision in provisional merged manifest
655 foldmap = {}
655 foldmap = {}
656 for f in sorted(pmmf):
656 for f in sorted(pmmf):
657 fold = util.normcase(f)
657 fold = util.normcase(f)
658 if fold in foldmap:
658 if fold in foldmap:
659 raise error.Abort(_("case-folding collision between %s and %s")
659 raise error.Abort(_("case-folding collision between %s and %s")
660 % (f, foldmap[fold]))
660 % (f, foldmap[fold]))
661 foldmap[fold] = f
661 foldmap[fold] = f
662
662
663 # check case-folding of directories
663 # check case-folding of directories
664 foldprefix = unfoldprefix = lastfull = ''
664 foldprefix = unfoldprefix = lastfull = ''
665 for fold, f in sorted(foldmap.items()):
665 for fold, f in sorted(foldmap.items()):
666 if fold.startswith(foldprefix) and not f.startswith(unfoldprefix):
666 if fold.startswith(foldprefix) and not f.startswith(unfoldprefix):
667 # the folded prefix matches but actual casing is different
667 # the folded prefix matches but actual casing is different
668 raise error.Abort(_("case-folding collision between "
668 raise error.Abort(_("case-folding collision between "
669 "%s and directory of %s") % (lastfull, f))
669 "%s and directory of %s") % (lastfull, f))
670 foldprefix = fold + '/'
670 foldprefix = fold + '/'
671 unfoldprefix = f + '/'
671 unfoldprefix = f + '/'
672 lastfull = f
672 lastfull = f
673
673
674 def driverpreprocess(repo, ms, wctx, labels=None):
674 def driverpreprocess(repo, ms, wctx, labels=None):
675 """run the preprocess step of the merge driver, if any
675 """run the preprocess step of the merge driver, if any
676
676
677 This is currently not implemented -- it's an extension point."""
677 This is currently not implemented -- it's an extension point."""
678 return True
678 return True
679
679
680 def driverconclude(repo, ms, wctx, labels=None):
680 def driverconclude(repo, ms, wctx, labels=None):
681 """run the conclude step of the merge driver, if any
681 """run the conclude step of the merge driver, if any
682
682
683 This is currently not implemented -- it's an extension point."""
683 This is currently not implemented -- it's an extension point."""
684 return True
684 return True
685
685
686 def manifestmerge(repo, wctx, p2, pa, branchmerge, force, partial,
686 def manifestmerge(repo, wctx, p2, pa, branchmerge, force, partial,
687 acceptremote, followcopies):
687 acceptremote, followcopies):
688 """
688 """
689 Merge p1 and p2 with ancestor pa and generate merge action list
689 Merge p1 and p2 with ancestor pa and generate merge action list
690
690
691 branchmerge and force are as passed in to update
691 branchmerge and force are as passed in to update
692 partial = function to filter file lists
692 partial = function to filter file lists
693 acceptremote = accept the incoming changes without prompting
693 acceptremote = accept the incoming changes without prompting
694 """
694 """
695
695
696 copy, movewithdir, diverge, renamedelete = {}, {}, {}, {}
696 copy, movewithdir, diverge, renamedelete = {}, {}, {}, {}
697
697
698 # manifests fetched in order are going to be faster, so prime the caches
698 # manifests fetched in order are going to be faster, so prime the caches
699 [x.manifest() for x in
699 [x.manifest() for x in
700 sorted(wctx.parents() + [p2, pa], key=lambda x: x.rev())]
700 sorted(wctx.parents() + [p2, pa], key=lambda x: x.rev())]
701
701
702 if followcopies:
702 if followcopies:
703 ret = copies.mergecopies(repo, wctx, p2, pa)
703 ret = copies.mergecopies(repo, wctx, p2, pa)
704 copy, movewithdir, diverge, renamedelete = ret
704 copy, movewithdir, diverge, renamedelete = ret
705
705
706 repo.ui.note(_("resolving manifests\n"))
706 repo.ui.note(_("resolving manifests\n"))
707 repo.ui.debug(" branchmerge: %s, force: %s, partial: %s\n"
707 repo.ui.debug(" branchmerge: %s, force: %s, partial: %s\n"
708 % (bool(branchmerge), bool(force), bool(partial)))
708 % (bool(branchmerge), bool(force), bool(partial)))
709 repo.ui.debug(" ancestor: %s, local: %s, remote: %s\n" % (pa, wctx, p2))
709 repo.ui.debug(" ancestor: %s, local: %s, remote: %s\n" % (pa, wctx, p2))
710
710
711 m1, m2, ma = wctx.manifest(), p2.manifest(), pa.manifest()
711 m1, m2, ma = wctx.manifest(), p2.manifest(), pa.manifest()
712 copied = set(copy.values())
712 copied = set(copy.values())
713 copied.update(movewithdir.values())
713 copied.update(movewithdir.values())
714
714
715 if '.hgsubstate' in m1:
715 if '.hgsubstate' in m1:
716 # check whether sub state is modified
716 # check whether sub state is modified
717 for s in sorted(wctx.substate):
717 for s in sorted(wctx.substate):
718 if wctx.sub(s).dirty():
718 if wctx.sub(s).dirty():
719 m1['.hgsubstate'] += '+'
719 m1['.hgsubstate'] += '+'
720 break
720 break
721
721
722 # Compare manifests
722 # Compare manifests
723 diff = m1.diff(m2)
723 diff = m1.diff(m2)
724
724
725 actions = {}
725 actions = {}
726 for f, ((n1, fl1), (n2, fl2)) in diff.iteritems():
726 for f, ((n1, fl1), (n2, fl2)) in diff.iteritems():
727 if partial and not partial(f):
727 if partial and not partial(f):
728 continue
728 continue
729 if n1 and n2: # file exists on both local and remote side
729 if n1 and n2: # file exists on both local and remote side
730 if f not in ma:
730 if f not in ma:
731 fa = copy.get(f, None)
731 fa = copy.get(f, None)
732 if fa is not None:
732 if fa is not None:
733 actions[f] = ('m', (f, f, fa, False, pa.node()),
733 actions[f] = ('m', (f, f, fa, False, pa.node()),
734 "both renamed from " + fa)
734 "both renamed from " + fa)
735 else:
735 else:
736 actions[f] = ('m', (f, f, None, False, pa.node()),
736 actions[f] = ('m', (f, f, None, False, pa.node()),
737 "both created")
737 "both created")
738 else:
738 else:
739 a = ma[f]
739 a = ma[f]
740 fla = ma.flags(f)
740 fla = ma.flags(f)
741 nol = 'l' not in fl1 + fl2 + fla
741 nol = 'l' not in fl1 + fl2 + fla
742 if n2 == a and fl2 == fla:
742 if n2 == a and fl2 == fla:
743 actions[f] = ('k' , (), "remote unchanged")
743 actions[f] = ('k' , (), "remote unchanged")
744 elif n1 == a and fl1 == fla: # local unchanged - use remote
744 elif n1 == a and fl1 == fla: # local unchanged - use remote
745 if n1 == n2: # optimization: keep local content
745 if n1 == n2: # optimization: keep local content
746 actions[f] = ('e', (fl2,), "update permissions")
746 actions[f] = ('e', (fl2,), "update permissions")
747 else:
747 else:
748 actions[f] = ('g', (fl2,), "remote is newer")
748 actions[f] = ('g', (fl2,), "remote is newer")
749 elif nol and n2 == a: # remote only changed 'x'
749 elif nol and n2 == a: # remote only changed 'x'
750 actions[f] = ('e', (fl2,), "update permissions")
750 actions[f] = ('e', (fl2,), "update permissions")
751 elif nol and n1 == a: # local only changed 'x'
751 elif nol and n1 == a: # local only changed 'x'
752 actions[f] = ('g', (fl1,), "remote is newer")
752 actions[f] = ('g', (fl1,), "remote is newer")
753 else: # both changed something
753 else: # both changed something
754 actions[f] = ('m', (f, f, f, False, pa.node()),
754 actions[f] = ('m', (f, f, f, False, pa.node()),
755 "versions differ")
755 "versions differ")
756 elif n1: # file exists only on local side
756 elif n1: # file exists only on local side
757 if f in copied:
757 if f in copied:
758 pass # we'll deal with it on m2 side
758 pass # we'll deal with it on m2 side
759 elif f in movewithdir: # directory rename, move local
759 elif f in movewithdir: # directory rename, move local
760 f2 = movewithdir[f]
760 f2 = movewithdir[f]
761 if f2 in m2:
761 if f2 in m2:
762 actions[f2] = ('m', (f, f2, None, True, pa.node()),
762 actions[f2] = ('m', (f, f2, None, True, pa.node()),
763 "remote directory rename, both created")
763 "remote directory rename, both created")
764 else:
764 else:
765 actions[f2] = ('dm', (f, fl1),
765 actions[f2] = ('dm', (f, fl1),
766 "remote directory rename - move from " + f)
766 "remote directory rename - move from " + f)
767 elif f in copy:
767 elif f in copy:
768 f2 = copy[f]
768 f2 = copy[f]
769 actions[f] = ('m', (f, f2, f2, False, pa.node()),
769 actions[f] = ('m', (f, f2, f2, False, pa.node()),
770 "local copied/moved from " + f2)
770 "local copied/moved from " + f2)
771 elif f in ma: # clean, a different, no remote
771 elif f in ma: # clean, a different, no remote
772 if n1 != ma[f]:
772 if n1 != ma[f]:
773 if acceptremote:
773 if acceptremote:
774 actions[f] = ('r', None, "remote delete")
774 actions[f] = ('r', None, "remote delete")
775 else:
775 else:
776 actions[f] = ('cd', (f, None, f, False, pa.node()),
776 actions[f] = ('cd', (f, None, f, False, pa.node()),
777 "prompt changed/deleted")
777 "prompt changed/deleted")
778 elif n1[20:] == 'a':
778 elif n1[20:] == 'a':
779 # This extra 'a' is added by working copy manifest to mark
779 # This extra 'a' is added by working copy manifest to mark
780 # the file as locally added. We should forget it instead of
780 # the file as locally added. We should forget it instead of
781 # deleting it.
781 # deleting it.
782 actions[f] = ('f', None, "remote deleted")
782 actions[f] = ('f', None, "remote deleted")
783 else:
783 else:
784 actions[f] = ('r', None, "other deleted")
784 actions[f] = ('r', None, "other deleted")
785 elif n2: # file exists only on remote side
785 elif n2: # file exists only on remote side
786 if f in copied:
786 if f in copied:
787 pass # we'll deal with it on m1 side
787 pass # we'll deal with it on m1 side
788 elif f in movewithdir:
788 elif f in movewithdir:
789 f2 = movewithdir[f]
789 f2 = movewithdir[f]
790 if f2 in m1:
790 if f2 in m1:
791 actions[f2] = ('m', (f2, f, None, False, pa.node()),
791 actions[f2] = ('m', (f2, f, None, False, pa.node()),
792 "local directory rename, both created")
792 "local directory rename, both created")
793 else:
793 else:
794 actions[f2] = ('dg', (f, fl2),
794 actions[f2] = ('dg', (f, fl2),
795 "local directory rename - get from " + f)
795 "local directory rename - get from " + f)
796 elif f in copy:
796 elif f in copy:
797 f2 = copy[f]
797 f2 = copy[f]
798 if f2 in m2:
798 if f2 in m2:
799 actions[f] = ('m', (f2, f, f2, False, pa.node()),
799 actions[f] = ('m', (f2, f, f2, False, pa.node()),
800 "remote copied from " + f2)
800 "remote copied from " + f2)
801 else:
801 else:
802 actions[f] = ('m', (f2, f, f2, True, pa.node()),
802 actions[f] = ('m', (f2, f, f2, True, pa.node()),
803 "remote moved from " + f2)
803 "remote moved from " + f2)
804 elif f not in ma:
804 elif f not in ma:
805 # local unknown, remote created: the logic is described by the
805 # local unknown, remote created: the logic is described by the
806 # following table:
806 # following table:
807 #
807 #
808 # force branchmerge different | action
808 # force branchmerge different | action
809 # n * * | create
809 # n * * | create
810 # y n * | create
810 # y n * | create
811 # y y n | create
811 # y y n | create
812 # y y y | merge
812 # y y y | merge
813 #
813 #
814 # Checking whether the files are different is expensive, so we
814 # Checking whether the files are different is expensive, so we
815 # don't do that when we can avoid it.
815 # don't do that when we can avoid it.
816 if not force:
816 if not force:
817 actions[f] = ('c', (fl2,), "remote created")
817 actions[f] = ('c', (fl2,), "remote created")
818 elif not branchmerge:
818 elif not branchmerge:
819 actions[f] = ('c', (fl2,), "remote created")
819 actions[f] = ('c', (fl2,), "remote created")
820 else:
820 else:
821 actions[f] = ('cm', (fl2, pa.node()),
821 actions[f] = ('cm', (fl2, pa.node()),
822 "remote created, get or merge")
822 "remote created, get or merge")
823 elif n2 != ma[f]:
823 elif n2 != ma[f]:
824 if acceptremote:
824 if acceptremote:
825 actions[f] = ('c', (fl2,), "remote recreating")
825 actions[f] = ('c', (fl2,), "remote recreating")
826 else:
826 else:
827 actions[f] = ('dc', (None, f, f, False, pa.node()),
827 actions[f] = ('dc', (None, f, f, False, pa.node()),
828 "prompt deleted/changed")
828 "prompt deleted/changed")
829
829
830 return actions, diverge, renamedelete
830 return actions, diverge, renamedelete
831
831
832 def _resolvetrivial(repo, wctx, mctx, ancestor, actions):
832 def _resolvetrivial(repo, wctx, mctx, ancestor, actions):
833 """Resolves false conflicts where the nodeid changed but the content
833 """Resolves false conflicts where the nodeid changed but the content
834 remained the same."""
834 remained the same."""
835
835
836 for f, (m, args, msg) in actions.items():
836 for f, (m, args, msg) in actions.items():
837 if m == 'cd' and f in ancestor and not wctx[f].cmp(ancestor[f]):
837 if m == 'cd' and f in ancestor and not wctx[f].cmp(ancestor[f]):
838 # local did change but ended up with same content
838 # local did change but ended up with same content
839 actions[f] = 'r', None, "prompt same"
839 actions[f] = 'r', None, "prompt same"
840 elif m == 'dc' and f in ancestor and not mctx[f].cmp(ancestor[f]):
840 elif m == 'dc' and f in ancestor and not mctx[f].cmp(ancestor[f]):
841 # remote did change but ended up with same content
841 # remote did change but ended up with same content
842 del actions[f] # don't get = keep local deleted
842 del actions[f] # don't get = keep local deleted
843
843
844 def calculateupdates(repo, wctx, mctx, ancestors, branchmerge, force, partial,
844 def calculateupdates(repo, wctx, mctx, ancestors, branchmerge, force, partial,
845 acceptremote, followcopies):
845 acceptremote, followcopies):
846 "Calculate the actions needed to merge mctx into wctx using ancestors"
846 "Calculate the actions needed to merge mctx into wctx using ancestors"
847
847
848 if len(ancestors) == 1: # default
848 if len(ancestors) == 1: # default
849 actions, diverge, renamedelete = manifestmerge(
849 actions, diverge, renamedelete = manifestmerge(
850 repo, wctx, mctx, ancestors[0], branchmerge, force, partial,
850 repo, wctx, mctx, ancestors[0], branchmerge, force, partial,
851 acceptremote, followcopies)
851 acceptremote, followcopies)
852 _checkunknownfiles(repo, wctx, mctx, force, actions)
852 _checkunknownfiles(repo, wctx, mctx, force, actions)
853
853
854 else: # only when merge.preferancestor=* - the default
854 else: # only when merge.preferancestor=* - the default
855 repo.ui.note(
855 repo.ui.note(
856 _("note: merging %s and %s using bids from ancestors %s\n") %
856 _("note: merging %s and %s using bids from ancestors %s\n") %
857 (wctx, mctx, _(' and ').join(str(anc) for anc in ancestors)))
857 (wctx, mctx, _(' and ').join(str(anc) for anc in ancestors)))
858
858
859 # Call for bids
859 # Call for bids
860 fbids = {} # mapping filename to bids (action method to list af actions)
860 fbids = {} # mapping filename to bids (action method to list af actions)
861 diverge, renamedelete = None, None
861 diverge, renamedelete = None, None
862 for ancestor in ancestors:
862 for ancestor in ancestors:
863 repo.ui.note(_('\ncalculating bids for ancestor %s\n') % ancestor)
863 repo.ui.note(_('\ncalculating bids for ancestor %s\n') % ancestor)
864 actions, diverge1, renamedelete1 = manifestmerge(
864 actions, diverge1, renamedelete1 = manifestmerge(
865 repo, wctx, mctx, ancestor, branchmerge, force, partial,
865 repo, wctx, mctx, ancestor, branchmerge, force, partial,
866 acceptremote, followcopies)
866 acceptremote, followcopies)
867 _checkunknownfiles(repo, wctx, mctx, force, actions)
867 _checkunknownfiles(repo, wctx, mctx, force, actions)
868
868
869 # Track the shortest set of warning on the theory that bid
869 # Track the shortest set of warning on the theory that bid
870 # merge will correctly incorporate more information
870 # merge will correctly incorporate more information
871 if diverge is None or len(diverge1) < len(diverge):
871 if diverge is None or len(diverge1) < len(diverge):
872 diverge = diverge1
872 diverge = diverge1
873 if renamedelete is None or len(renamedelete) < len(renamedelete1):
873 if renamedelete is None or len(renamedelete) < len(renamedelete1):
874 renamedelete = renamedelete1
874 renamedelete = renamedelete1
875
875
876 for f, a in sorted(actions.iteritems()):
876 for f, a in sorted(actions.iteritems()):
877 m, args, msg = a
877 m, args, msg = a
878 repo.ui.debug(' %s: %s -> %s\n' % (f, msg, m))
878 repo.ui.debug(' %s: %s -> %s\n' % (f, msg, m))
879 if f in fbids:
879 if f in fbids:
880 d = fbids[f]
880 d = fbids[f]
881 if m in d:
881 if m in d:
882 d[m].append(a)
882 d[m].append(a)
883 else:
883 else:
884 d[m] = [a]
884 d[m] = [a]
885 else:
885 else:
886 fbids[f] = {m: [a]}
886 fbids[f] = {m: [a]}
887
887
888 # Pick the best bid for each file
888 # Pick the best bid for each file
889 repo.ui.note(_('\nauction for merging merge bids\n'))
889 repo.ui.note(_('\nauction for merging merge bids\n'))
890 actions = {}
890 actions = {}
891 for f, bids in sorted(fbids.items()):
891 for f, bids in sorted(fbids.items()):
892 # bids is a mapping from action method to list af actions
892 # bids is a mapping from action method to list af actions
893 # Consensus?
893 # Consensus?
894 if len(bids) == 1: # all bids are the same kind of method
894 if len(bids) == 1: # all bids are the same kind of method
895 m, l = bids.items()[0]
895 m, l = bids.items()[0]
896 if all(a == l[0] for a in l[1:]): # len(bids) is > 1
896 if all(a == l[0] for a in l[1:]): # len(bids) is > 1
897 repo.ui.note(" %s: consensus for %s\n" % (f, m))
897 repo.ui.note(" %s: consensus for %s\n" % (f, m))
898 actions[f] = l[0]
898 actions[f] = l[0]
899 continue
899 continue
900 # If keep is an option, just do it.
900 # If keep is an option, just do it.
901 if 'k' in bids:
901 if 'k' in bids:
902 repo.ui.note(" %s: picking 'keep' action\n" % f)
902 repo.ui.note(" %s: picking 'keep' action\n" % f)
903 actions[f] = bids['k'][0]
903 actions[f] = bids['k'][0]
904 continue
904 continue
905 # If there are gets and they all agree [how could they not?], do it.
905 # If there are gets and they all agree [how could they not?], do it.
906 if 'g' in bids:
906 if 'g' in bids:
907 ga0 = bids['g'][0]
907 ga0 = bids['g'][0]
908 if all(a == ga0 for a in bids['g'][1:]):
908 if all(a == ga0 for a in bids['g'][1:]):
909 repo.ui.note(" %s: picking 'get' action\n" % f)
909 repo.ui.note(" %s: picking 'get' action\n" % f)
910 actions[f] = ga0
910 actions[f] = ga0
911 continue
911 continue
912 # TODO: Consider other simple actions such as mode changes
912 # TODO: Consider other simple actions such as mode changes
913 # Handle inefficient democrazy.
913 # Handle inefficient democrazy.
914 repo.ui.note(_(' %s: multiple bids for merge action:\n') % f)
914 repo.ui.note(_(' %s: multiple bids for merge action:\n') % f)
915 for m, l in sorted(bids.items()):
915 for m, l in sorted(bids.items()):
916 for _f, args, msg in l:
916 for _f, args, msg in l:
917 repo.ui.note(' %s -> %s\n' % (msg, m))
917 repo.ui.note(' %s -> %s\n' % (msg, m))
918 # Pick random action. TODO: Instead, prompt user when resolving
918 # Pick random action. TODO: Instead, prompt user when resolving
919 m, l = bids.items()[0]
919 m, l = bids.items()[0]
920 repo.ui.warn(_(' %s: ambiguous merge - picked %s action\n') %
920 repo.ui.warn(_(' %s: ambiguous merge - picked %s action\n') %
921 (f, m))
921 (f, m))
922 actions[f] = l[0]
922 actions[f] = l[0]
923 continue
923 continue
924 repo.ui.note(_('end of auction\n\n'))
924 repo.ui.note(_('end of auction\n\n'))
925
925
926 _resolvetrivial(repo, wctx, mctx, ancestors[0], actions)
926 _resolvetrivial(repo, wctx, mctx, ancestors[0], actions)
927
927
928 if wctx.rev() is None:
928 if wctx.rev() is None:
929 fractions = _forgetremoved(wctx, mctx, branchmerge)
929 fractions = _forgetremoved(wctx, mctx, branchmerge)
930 actions.update(fractions)
930 actions.update(fractions)
931
931
932 return actions, diverge, renamedelete
932 return actions, diverge, renamedelete
933
933
934 def batchremove(repo, actions):
934 def batchremove(repo, actions):
935 """apply removes to the working directory
935 """apply removes to the working directory
936
936
937 yields tuples for progress updates
937 yields tuples for progress updates
938 """
938 """
939 verbose = repo.ui.verbose
939 verbose = repo.ui.verbose
940 unlink = util.unlinkpath
940 unlink = util.unlinkpath
941 wjoin = repo.wjoin
941 wjoin = repo.wjoin
942 audit = repo.wvfs.audit
942 audit = repo.wvfs.audit
943 i = 0
943 i = 0
944 for f, args, msg in actions:
944 for f, args, msg in actions:
945 repo.ui.debug(" %s: %s -> r\n" % (f, msg))
945 repo.ui.debug(" %s: %s -> r\n" % (f, msg))
946 if verbose:
946 if verbose:
947 repo.ui.note(_("removing %s\n") % f)
947 repo.ui.note(_("removing %s\n") % f)
948 audit(f)
948 audit(f)
949 try:
949 try:
950 unlink(wjoin(f), ignoremissing=True)
950 unlink(wjoin(f), ignoremissing=True)
951 except OSError as inst:
951 except OSError as inst:
952 repo.ui.warn(_("update failed to remove %s: %s!\n") %
952 repo.ui.warn(_("update failed to remove %s: %s!\n") %
953 (f, inst.strerror))
953 (f, inst.strerror))
954 if i == 100:
954 if i == 100:
955 yield i, f
955 yield i, f
956 i = 0
956 i = 0
957 i += 1
957 i += 1
958 if i > 0:
958 if i > 0:
959 yield i, f
959 yield i, f
960
960
961 def batchget(repo, mctx, actions):
961 def batchget(repo, mctx, actions):
962 """apply gets to the working directory
962 """apply gets to the working directory
963
963
964 mctx is the context to get from
964 mctx is the context to get from
965
965
966 yields tuples for progress updates
966 yields tuples for progress updates
967 """
967 """
968 verbose = repo.ui.verbose
968 verbose = repo.ui.verbose
969 fctx = mctx.filectx
969 fctx = mctx.filectx
970 wwrite = repo.wwrite
970 wwrite = repo.wwrite
971 i = 0
971 i = 0
972 for f, args, msg in actions:
972 for f, args, msg in actions:
973 repo.ui.debug(" %s: %s -> g\n" % (f, msg))
973 repo.ui.debug(" %s: %s -> g\n" % (f, msg))
974 if verbose:
974 if verbose:
975 repo.ui.note(_("getting %s\n") % f)
975 repo.ui.note(_("getting %s\n") % f)
976 wwrite(f, fctx(f).data(), args[0])
976 wwrite(f, fctx(f).data(), args[0])
977 if i == 100:
977 if i == 100:
978 yield i, f
978 yield i, f
979 i = 0
979 i = 0
980 i += 1
980 i += 1
981 if i > 0:
981 if i > 0:
982 yield i, f
982 yield i, f
983
983
984 def applyupdates(repo, actions, wctx, mctx, overwrite, labels=None):
984 def applyupdates(repo, actions, wctx, mctx, overwrite, labels=None):
985 """apply the merge action list to the working directory
985 """apply the merge action list to the working directory
986
986
987 wctx is the working copy context
987 wctx is the working copy context
988 mctx is the context to be merged into the working copy
988 mctx is the context to be merged into the working copy
989
989
990 Return a tuple of counts (updated, merged, removed, unresolved) that
990 Return a tuple of counts (updated, merged, removed, unresolved) that
991 describes how many files were affected by the update.
991 describes how many files were affected by the update.
992 """
992 """
993
993
994 updated, merged, removed = 0, 0, 0
994 updated, merged, removed = 0, 0, 0
995 ms = mergestate.clean(repo, wctx.p1().node(), mctx.node())
995 ms = mergestate.clean(repo, wctx.p1().node(), mctx.node())
996 moves = []
996 moves = []
997 for m, l in actions.items():
997 for m, l in actions.items():
998 l.sort()
998 l.sort()
999
999
1000 # prescan for merges
1000 # prescan for merges
1001 for f, args, msg in actions['m']:
1001 for f, args, msg in actions['m']:
1002 f1, f2, fa, move, anc = args
1002 f1, f2, fa, move, anc = args
1003 if f == '.hgsubstate': # merged internally
1003 if f == '.hgsubstate': # merged internally
1004 continue
1004 continue
1005 if f1 is None:
1005 if f1 is None:
1006 fcl = filemerge.absentfilectx(wctx, fa)
1006 fcl = filemerge.absentfilectx(wctx, fa)
1007 else:
1007 else:
1008 repo.ui.debug(" preserving %s for resolve of %s\n" % (f1, f))
1008 repo.ui.debug(" preserving %s for resolve of %s\n" % (f1, f))
1009 fcl = wctx[f1]
1009 fcl = wctx[f1]
1010 if f2 is None:
1010 if f2 is None:
1011 fco = filemerge.absentfilectx(mctx, fa)
1011 fco = filemerge.absentfilectx(mctx, fa)
1012 else:
1012 else:
1013 fco = mctx[f2]
1013 fco = mctx[f2]
1014 actx = repo[anc]
1014 actx = repo[anc]
1015 if fa in actx:
1015 if fa in actx:
1016 fca = actx[fa]
1016 fca = actx[fa]
1017 else:
1017 else:
1018 # TODO: move to absentfilectx
1018 # TODO: move to absentfilectx
1019 fca = repo.filectx(f1, fileid=nullrev)
1019 fca = repo.filectx(f1, fileid=nullrev)
1020 ms.add(fcl, fco, fca, f)
1020 ms.add(fcl, fco, fca, f)
1021 if f1 != f and move:
1021 if f1 != f and move:
1022 moves.append(f1)
1022 moves.append(f1)
1023
1023
1024 audit = repo.wvfs.audit
1024 audit = repo.wvfs.audit
1025 _updating = _('updating')
1025 _updating = _('updating')
1026 _files = _('files')
1026 _files = _('files')
1027 progress = repo.ui.progress
1027 progress = repo.ui.progress
1028
1028
1029 # remove renamed files after safely stored
1029 # remove renamed files after safely stored
1030 for f in moves:
1030 for f in moves:
1031 if os.path.lexists(repo.wjoin(f)):
1031 if os.path.lexists(repo.wjoin(f)):
1032 repo.ui.debug("removing %s\n" % f)
1032 repo.ui.debug("removing %s\n" % f)
1033 audit(f)
1033 audit(f)
1034 util.unlinkpath(repo.wjoin(f))
1034 util.unlinkpath(repo.wjoin(f))
1035
1035
1036 numupdates = sum(len(l) for m, l in actions.items() if m != 'k')
1036 numupdates = sum(len(l) for m, l in actions.items() if m != 'k')
1037
1037
1038 if [a for a in actions['r'] if a[0] == '.hgsubstate']:
1038 if [a for a in actions['r'] if a[0] == '.hgsubstate']:
1039 subrepo.submerge(repo, wctx, mctx, wctx, overwrite)
1039 subrepo.submerge(repo, wctx, mctx, wctx, overwrite)
1040
1040
1041 # remove in parallel (must come first)
1041 # remove in parallel (must come first)
1042 z = 0
1042 z = 0
1043 prog = worker.worker(repo.ui, 0.001, batchremove, (repo,), actions['r'])
1043 prog = worker.worker(repo.ui, 0.001, batchremove, (repo,), actions['r'])
1044 for i, item in prog:
1044 for i, item in prog:
1045 z += i
1045 z += i
1046 progress(_updating, z, item=item, total=numupdates, unit=_files)
1046 progress(_updating, z, item=item, total=numupdates, unit=_files)
1047 removed = len(actions['r'])
1047 removed = len(actions['r'])
1048
1048
1049 # get in parallel
1049 # get in parallel
1050 prog = worker.worker(repo.ui, 0.001, batchget, (repo, mctx), actions['g'])
1050 prog = worker.worker(repo.ui, 0.001, batchget, (repo, mctx), actions['g'])
1051 for i, item in prog:
1051 for i, item in prog:
1052 z += i
1052 z += i
1053 progress(_updating, z, item=item, total=numupdates, unit=_files)
1053 progress(_updating, z, item=item, total=numupdates, unit=_files)
1054 updated = len(actions['g'])
1054 updated = len(actions['g'])
1055
1055
1056 if [a for a in actions['g'] if a[0] == '.hgsubstate']:
1056 if [a for a in actions['g'] if a[0] == '.hgsubstate']:
1057 subrepo.submerge(repo, wctx, mctx, wctx, overwrite)
1057 subrepo.submerge(repo, wctx, mctx, wctx, overwrite)
1058
1058
1059 # forget (manifest only, just log it) (must come first)
1059 # forget (manifest only, just log it) (must come first)
1060 for f, args, msg in actions['f']:
1060 for f, args, msg in actions['f']:
1061 repo.ui.debug(" %s: %s -> f\n" % (f, msg))
1061 repo.ui.debug(" %s: %s -> f\n" % (f, msg))
1062 z += 1
1062 z += 1
1063 progress(_updating, z, item=f, total=numupdates, unit=_files)
1063 progress(_updating, z, item=f, total=numupdates, unit=_files)
1064
1064
1065 # re-add (manifest only, just log it)
1065 # re-add (manifest only, just log it)
1066 for f, args, msg in actions['a']:
1066 for f, args, msg in actions['a']:
1067 repo.ui.debug(" %s: %s -> a\n" % (f, msg))
1067 repo.ui.debug(" %s: %s -> a\n" % (f, msg))
1068 z += 1
1068 z += 1
1069 progress(_updating, z, item=f, total=numupdates, unit=_files)
1069 progress(_updating, z, item=f, total=numupdates, unit=_files)
1070
1070
1071 # re-add/mark as modified (manifest only, just log it)
1071 # re-add/mark as modified (manifest only, just log it)
1072 for f, args, msg in actions['am']:
1072 for f, args, msg in actions['am']:
1073 repo.ui.debug(" %s: %s -> am\n" % (f, msg))
1073 repo.ui.debug(" %s: %s -> am\n" % (f, msg))
1074 z += 1
1074 z += 1
1075 progress(_updating, z, item=f, total=numupdates, unit=_files)
1075 progress(_updating, z, item=f, total=numupdates, unit=_files)
1076
1076
1077 # keep (noop, just log it)
1077 # keep (noop, just log it)
1078 for f, args, msg in actions['k']:
1078 for f, args, msg in actions['k']:
1079 repo.ui.debug(" %s: %s -> k\n" % (f, msg))
1079 repo.ui.debug(" %s: %s -> k\n" % (f, msg))
1080 # no progress
1080 # no progress
1081
1081
1082 # directory rename, move local
1082 # directory rename, move local
1083 for f, args, msg in actions['dm']:
1083 for f, args, msg in actions['dm']:
1084 repo.ui.debug(" %s: %s -> dm\n" % (f, msg))
1084 repo.ui.debug(" %s: %s -> dm\n" % (f, msg))
1085 z += 1
1085 z += 1
1086 progress(_updating, z, item=f, total=numupdates, unit=_files)
1086 progress(_updating, z, item=f, total=numupdates, unit=_files)
1087 f0, flags = args
1087 f0, flags = args
1088 repo.ui.note(_("moving %s to %s\n") % (f0, f))
1088 repo.ui.note(_("moving %s to %s\n") % (f0, f))
1089 audit(f)
1089 audit(f)
1090 repo.wwrite(f, wctx.filectx(f0).data(), flags)
1090 repo.wwrite(f, wctx.filectx(f0).data(), flags)
1091 util.unlinkpath(repo.wjoin(f0))
1091 util.unlinkpath(repo.wjoin(f0))
1092 updated += 1
1092 updated += 1
1093
1093
1094 # local directory rename, get
1094 # local directory rename, get
1095 for f, args, msg in actions['dg']:
1095 for f, args, msg in actions['dg']:
1096 repo.ui.debug(" %s: %s -> dg\n" % (f, msg))
1096 repo.ui.debug(" %s: %s -> dg\n" % (f, msg))
1097 z += 1
1097 z += 1
1098 progress(_updating, z, item=f, total=numupdates, unit=_files)
1098 progress(_updating, z, item=f, total=numupdates, unit=_files)
1099 f0, flags = args
1099 f0, flags = args
1100 repo.ui.note(_("getting %s to %s\n") % (f0, f))
1100 repo.ui.note(_("getting %s to %s\n") % (f0, f))
1101 repo.wwrite(f, mctx.filectx(f0).data(), flags)
1101 repo.wwrite(f, mctx.filectx(f0).data(), flags)
1102 updated += 1
1102 updated += 1
1103
1103
1104 # exec
1104 # exec
1105 for f, args, msg in actions['e']:
1105 for f, args, msg in actions['e']:
1106 repo.ui.debug(" %s: %s -> e\n" % (f, msg))
1106 repo.ui.debug(" %s: %s -> e\n" % (f, msg))
1107 z += 1
1107 z += 1
1108 progress(_updating, z, item=f, total=numupdates, unit=_files)
1108 progress(_updating, z, item=f, total=numupdates, unit=_files)
1109 flags, = args
1109 flags, = args
1110 audit(f)
1110 audit(f)
1111 util.setflags(repo.wjoin(f), 'l' in flags, 'x' in flags)
1111 util.setflags(repo.wjoin(f), 'l' in flags, 'x' in flags)
1112 updated += 1
1112 updated += 1
1113
1113
1114 mergeactions = actions['m']
1114 mergeactions = actions['m']
1115 # the ordering is important here -- ms.mergedriver will raise if the merge
1115 # the ordering is important here -- ms.mergedriver will raise if the merge
1116 # driver has changed, and we want to be able to bypass it when overwrite is
1116 # driver has changed, and we want to be able to bypass it when overwrite is
1117 # True
1117 # True
1118 usemergedriver = not overwrite and mergeactions and ms.mergedriver
1118 usemergedriver = not overwrite and mergeactions and ms.mergedriver
1119
1119
1120 if usemergedriver:
1120 if usemergedriver:
1121 ms.commit()
1121 ms.commit()
1122 proceed = driverpreprocess(repo, ms, wctx, labels=labels)
1122 proceed = driverpreprocess(repo, ms, wctx, labels=labels)
1123 # the driver might leave some files unresolved
1123 # the driver might leave some files unresolved
1124 unresolvedf = set(ms.unresolved())
1124 unresolvedf = set(ms.unresolved())
1125 if not proceed:
1125 if not proceed:
1126 # XXX setting unresolved to at least 1 is a hack to make sure we
1126 # XXX setting unresolved to at least 1 is a hack to make sure we
1127 # error out
1127 # error out
1128 return updated, merged, removed, max(len(unresolvedf), 1)
1128 return updated, merged, removed, max(len(unresolvedf), 1)
1129 newactions = []
1129 newactions = []
1130 for f, args, msg in mergeactions:
1130 for f, args, msg in mergeactions:
1131 if f in unresolvedf:
1131 if f in unresolvedf:
1132 newactions.append((f, args, msg))
1132 newactions.append((f, args, msg))
1133 mergeactions = newactions
1133 mergeactions = newactions
1134
1134
1135 # premerge
1135 # premerge
1136 tocomplete = []
1136 tocomplete = []
1137 for f, args, msg in mergeactions:
1137 for f, args, msg in mergeactions:
1138 repo.ui.debug(" %s: %s -> m (premerge)\n" % (f, msg))
1138 repo.ui.debug(" %s: %s -> m (premerge)\n" % (f, msg))
1139 z += 1
1139 z += 1
1140 progress(_updating, z, item=f, total=numupdates, unit=_files)
1140 progress(_updating, z, item=f, total=numupdates, unit=_files)
1141 if f == '.hgsubstate': # subrepo states need updating
1141 if f == '.hgsubstate': # subrepo states need updating
1142 subrepo.submerge(repo, wctx, mctx, wctx.ancestor(mctx),
1142 subrepo.submerge(repo, wctx, mctx, wctx.ancestor(mctx),
1143 overwrite)
1143 overwrite)
1144 continue
1144 continue
1145 audit(f)
1145 audit(f)
1146 complete, r = ms.preresolve(f, wctx, labels=labels)
1146 complete, r = ms.preresolve(f, wctx, labels=labels)
1147 if not complete:
1147 if not complete:
1148 numupdates += 1
1148 numupdates += 1
1149 tocomplete.append((f, args, msg))
1149 tocomplete.append((f, args, msg))
1150
1150
1151 # merge
1151 # merge
1152 for f, args, msg in tocomplete:
1152 for f, args, msg in tocomplete:
1153 repo.ui.debug(" %s: %s -> m (merge)\n" % (f, msg))
1153 repo.ui.debug(" %s: %s -> m (merge)\n" % (f, msg))
1154 z += 1
1154 z += 1
1155 progress(_updating, z, item=f, total=numupdates, unit=_files)
1155 progress(_updating, z, item=f, total=numupdates, unit=_files)
1156 ms.resolve(f, wctx, labels=labels)
1156 ms.resolve(f, wctx, labels=labels)
1157
1157
1158 ms.commit()
1158 ms.commit()
1159
1159
1160 unresolved = ms.unresolvedcount()
1160 unresolved = ms.unresolvedcount()
1161
1161
1162 if usemergedriver and not unresolved and ms.mdstate() != 's':
1162 if usemergedriver and not unresolved and ms.mdstate() != 's':
1163 if not driverconclude(repo, ms, wctx, labels=labels):
1163 if not driverconclude(repo, ms, wctx, labels=labels):
1164 # XXX setting unresolved to at least 1 is a hack to make sure we
1164 # XXX setting unresolved to at least 1 is a hack to make sure we
1165 # error out
1165 # error out
1166 unresolved = max(unresolved, 1)
1166 unresolved = max(unresolved, 1)
1167
1167
1168 ms.commit()
1168 ms.commit()
1169
1169
1170 msupdated, msmerged, msremoved = ms.counts()
1170 msupdated, msmerged, msremoved = ms.counts()
1171 updated += msupdated
1171 updated += msupdated
1172 merged += msmerged
1172 merged += msmerged
1173 removed += msremoved
1173 removed += msremoved
1174
1174
1175 extraactions = ms.actions()
1175 extraactions = ms.actions()
1176 for k, acts in extraactions.iteritems():
1176 for k, acts in extraactions.iteritems():
1177 actions[k].extend(acts)
1177 actions[k].extend(acts)
1178
1178
1179 progress(_updating, None, total=numupdates, unit=_files)
1179 progress(_updating, None, total=numupdates, unit=_files)
1180
1180
1181 return updated, merged, removed, unresolved
1181 return updated, merged, removed, unresolved
1182
1182
1183 def recordupdates(repo, actions, branchmerge):
1183 def recordupdates(repo, actions, branchmerge):
1184 "record merge actions to the dirstate"
1184 "record merge actions to the dirstate"
1185 # remove (must come first)
1185 # remove (must come first)
1186 for f, args, msg in actions.get('r', []):
1186 for f, args, msg in actions.get('r', []):
1187 if branchmerge:
1187 if branchmerge:
1188 repo.dirstate.remove(f)
1188 repo.dirstate.remove(f)
1189 else:
1189 else:
1190 repo.dirstate.drop(f)
1190 repo.dirstate.drop(f)
1191
1191
1192 # forget (must come first)
1192 # forget (must come first)
1193 for f, args, msg in actions.get('f', []):
1193 for f, args, msg in actions.get('f', []):
1194 repo.dirstate.drop(f)
1194 repo.dirstate.drop(f)
1195
1195
1196 # re-add
1196 # re-add
1197 for f, args, msg in actions.get('a', []):
1197 for f, args, msg in actions.get('a', []):
1198 if not branchmerge:
1198 repo.dirstate.add(f)
1199 repo.dirstate.add(f)
1200
1199
1201 # re-add/mark as modified
1200 # re-add/mark as modified
1202 for f, args, msg in actions.get('am', []):
1201 for f, args, msg in actions.get('am', []):
1203 if branchmerge:
1202 if branchmerge:
1204 repo.dirstate.normallookup(f)
1203 repo.dirstate.normallookup(f)
1205 else:
1204 else:
1206 repo.dirstate.add(f)
1205 repo.dirstate.add(f)
1207
1206
1208 # exec change
1207 # exec change
1209 for f, args, msg in actions.get('e', []):
1208 for f, args, msg in actions.get('e', []):
1210 repo.dirstate.normallookup(f)
1209 repo.dirstate.normallookup(f)
1211
1210
1212 # keep
1211 # keep
1213 for f, args, msg in actions.get('k', []):
1212 for f, args, msg in actions.get('k', []):
1214 pass
1213 pass
1215
1214
1216 # get
1215 # get
1217 for f, args, msg in actions.get('g', []):
1216 for f, args, msg in actions.get('g', []):
1218 if branchmerge:
1217 if branchmerge:
1219 repo.dirstate.otherparent(f)
1218 repo.dirstate.otherparent(f)
1220 else:
1219 else:
1221 repo.dirstate.normal(f)
1220 repo.dirstate.normal(f)
1222
1221
1223 # merge
1222 # merge
1224 for f, args, msg in actions.get('m', []):
1223 for f, args, msg in actions.get('m', []):
1225 f1, f2, fa, move, anc = args
1224 f1, f2, fa, move, anc = args
1226 if branchmerge:
1225 if branchmerge:
1227 # We've done a branch merge, mark this file as merged
1226 # We've done a branch merge, mark this file as merged
1228 # so that we properly record the merger later
1227 # so that we properly record the merger later
1229 repo.dirstate.merge(f)
1228 repo.dirstate.merge(f)
1230 if f1 != f2: # copy/rename
1229 if f1 != f2: # copy/rename
1231 if move:
1230 if move:
1232 repo.dirstate.remove(f1)
1231 repo.dirstate.remove(f1)
1233 if f1 != f:
1232 if f1 != f:
1234 repo.dirstate.copy(f1, f)
1233 repo.dirstate.copy(f1, f)
1235 else:
1234 else:
1236 repo.dirstate.copy(f2, f)
1235 repo.dirstate.copy(f2, f)
1237 else:
1236 else:
1238 # We've update-merged a locally modified file, so
1237 # We've update-merged a locally modified file, so
1239 # we set the dirstate to emulate a normal checkout
1238 # we set the dirstate to emulate a normal checkout
1240 # of that file some time in the past. Thus our
1239 # of that file some time in the past. Thus our
1241 # merge will appear as a normal local file
1240 # merge will appear as a normal local file
1242 # modification.
1241 # modification.
1243 if f2 == f: # file not locally copied/moved
1242 if f2 == f: # file not locally copied/moved
1244 repo.dirstate.normallookup(f)
1243 repo.dirstate.normallookup(f)
1245 if move:
1244 if move:
1246 repo.dirstate.drop(f1)
1245 repo.dirstate.drop(f1)
1247
1246
1248 # directory rename, move local
1247 # directory rename, move local
1249 for f, args, msg in actions.get('dm', []):
1248 for f, args, msg in actions.get('dm', []):
1250 f0, flag = args
1249 f0, flag = args
1251 if branchmerge:
1250 if branchmerge:
1252 repo.dirstate.add(f)
1251 repo.dirstate.add(f)
1253 repo.dirstate.remove(f0)
1252 repo.dirstate.remove(f0)
1254 repo.dirstate.copy(f0, f)
1253 repo.dirstate.copy(f0, f)
1255 else:
1254 else:
1256 repo.dirstate.normal(f)
1255 repo.dirstate.normal(f)
1257 repo.dirstate.drop(f0)
1256 repo.dirstate.drop(f0)
1258
1257
1259 # directory rename, get
1258 # directory rename, get
1260 for f, args, msg in actions.get('dg', []):
1259 for f, args, msg in actions.get('dg', []):
1261 f0, flag = args
1260 f0, flag = args
1262 if branchmerge:
1261 if branchmerge:
1263 repo.dirstate.add(f)
1262 repo.dirstate.add(f)
1264 repo.dirstate.copy(f0, f)
1263 repo.dirstate.copy(f0, f)
1265 else:
1264 else:
1266 repo.dirstate.normal(f)
1265 repo.dirstate.normal(f)
1267
1266
1268 def update(repo, node, branchmerge, force, partial, ancestor=None,
1267 def update(repo, node, branchmerge, force, partial, ancestor=None,
1269 mergeancestor=False, labels=None):
1268 mergeancestor=False, labels=None):
1270 """
1269 """
1271 Perform a merge between the working directory and the given node
1270 Perform a merge between the working directory and the given node
1272
1271
1273 node = the node to update to, or None if unspecified
1272 node = the node to update to, or None if unspecified
1274 branchmerge = whether to merge between branches
1273 branchmerge = whether to merge between branches
1275 force = whether to force branch merging or file overwriting
1274 force = whether to force branch merging or file overwriting
1276 partial = a function to filter file lists (dirstate not updated)
1275 partial = a function to filter file lists (dirstate not updated)
1277 mergeancestor = whether it is merging with an ancestor. If true,
1276 mergeancestor = whether it is merging with an ancestor. If true,
1278 we should accept the incoming changes for any prompts that occur.
1277 we should accept the incoming changes for any prompts that occur.
1279 If false, merging with an ancestor (fast-forward) is only allowed
1278 If false, merging with an ancestor (fast-forward) is only allowed
1280 between different named branches. This flag is used by rebase extension
1279 between different named branches. This flag is used by rebase extension
1281 as a temporary fix and should be avoided in general.
1280 as a temporary fix and should be avoided in general.
1282
1281
1283 The table below shows all the behaviors of the update command
1282 The table below shows all the behaviors of the update command
1284 given the -c and -C or no options, whether the working directory
1283 given the -c and -C or no options, whether the working directory
1285 is dirty, whether a revision is specified, and the relationship of
1284 is dirty, whether a revision is specified, and the relationship of
1286 the parent rev to the target rev (linear, on the same named
1285 the parent rev to the target rev (linear, on the same named
1287 branch, or on another named branch).
1286 branch, or on another named branch).
1288
1287
1289 This logic is tested by test-update-branches.t.
1288 This logic is tested by test-update-branches.t.
1290
1289
1291 -c -C dirty rev | linear same cross
1290 -c -C dirty rev | linear same cross
1292 n n n n | ok (1) x
1291 n n n n | ok (1) x
1293 n n n y | ok ok ok
1292 n n n y | ok ok ok
1294 n n y n | merge (2) (2)
1293 n n y n | merge (2) (2)
1295 n n y y | merge (3) (3)
1294 n n y y | merge (3) (3)
1296 n y * * | discard discard discard
1295 n y * * | discard discard discard
1297 y n y * | (4) (4) (4)
1296 y n y * | (4) (4) (4)
1298 y n n * | ok ok ok
1297 y n n * | ok ok ok
1299 y y * * | (5) (5) (5)
1298 y y * * | (5) (5) (5)
1300
1299
1301 x = can't happen
1300 x = can't happen
1302 * = don't-care
1301 * = don't-care
1303 1 = abort: not a linear update (merge or update --check to force update)
1302 1 = abort: not a linear update (merge or update --check to force update)
1304 2 = abort: uncommitted changes (commit and merge, or update --clean to
1303 2 = abort: uncommitted changes (commit and merge, or update --clean to
1305 discard changes)
1304 discard changes)
1306 3 = abort: uncommitted changes (commit or update --clean to discard changes)
1305 3 = abort: uncommitted changes (commit or update --clean to discard changes)
1307 4 = abort: uncommitted changes (checked in commands.py)
1306 4 = abort: uncommitted changes (checked in commands.py)
1308 5 = incompatible options (checked in commands.py)
1307 5 = incompatible options (checked in commands.py)
1309
1308
1310 Return the same tuple as applyupdates().
1309 Return the same tuple as applyupdates().
1311 """
1310 """
1312
1311
1313 onode = node
1312 onode = node
1314 wlock = repo.wlock()
1313 wlock = repo.wlock()
1315 try:
1314 try:
1316 wc = repo[None]
1315 wc = repo[None]
1317 pl = wc.parents()
1316 pl = wc.parents()
1318 p1 = pl[0]
1317 p1 = pl[0]
1319 pas = [None]
1318 pas = [None]
1320 if ancestor is not None:
1319 if ancestor is not None:
1321 pas = [repo[ancestor]]
1320 pas = [repo[ancestor]]
1322
1321
1323 if node is None:
1322 if node is None:
1324 if (repo.ui.configbool('devel', 'all-warnings')
1323 if (repo.ui.configbool('devel', 'all-warnings')
1325 or repo.ui.configbool('devel', 'oldapi')):
1324 or repo.ui.configbool('devel', 'oldapi')):
1326 repo.ui.develwarn('update with no target')
1325 repo.ui.develwarn('update with no target')
1327 rev, _mark, _act = destutil.destupdate(repo)
1326 rev, _mark, _act = destutil.destupdate(repo)
1328 node = repo[rev].node()
1327 node = repo[rev].node()
1329
1328
1330 overwrite = force and not branchmerge
1329 overwrite = force and not branchmerge
1331
1330
1332 p2 = repo[node]
1331 p2 = repo[node]
1333 if pas[0] is None:
1332 if pas[0] is None:
1334 if repo.ui.configlist('merge', 'preferancestor', ['*']) == ['*']:
1333 if repo.ui.configlist('merge', 'preferancestor', ['*']) == ['*']:
1335 cahs = repo.changelog.commonancestorsheads(p1.node(), p2.node())
1334 cahs = repo.changelog.commonancestorsheads(p1.node(), p2.node())
1336 pas = [repo[anc] for anc in (sorted(cahs) or [nullid])]
1335 pas = [repo[anc] for anc in (sorted(cahs) or [nullid])]
1337 else:
1336 else:
1338 pas = [p1.ancestor(p2, warn=branchmerge)]
1337 pas = [p1.ancestor(p2, warn=branchmerge)]
1339
1338
1340 fp1, fp2, xp1, xp2 = p1.node(), p2.node(), str(p1), str(p2)
1339 fp1, fp2, xp1, xp2 = p1.node(), p2.node(), str(p1), str(p2)
1341
1340
1342 ### check phase
1341 ### check phase
1343 if not overwrite and len(pl) > 1:
1342 if not overwrite and len(pl) > 1:
1344 raise error.Abort(_("outstanding uncommitted merge"))
1343 raise error.Abort(_("outstanding uncommitted merge"))
1345 if branchmerge:
1344 if branchmerge:
1346 if pas == [p2]:
1345 if pas == [p2]:
1347 raise error.Abort(_("merging with a working directory ancestor"
1346 raise error.Abort(_("merging with a working directory ancestor"
1348 " has no effect"))
1347 " has no effect"))
1349 elif pas == [p1]:
1348 elif pas == [p1]:
1350 if not mergeancestor and p1.branch() == p2.branch():
1349 if not mergeancestor and p1.branch() == p2.branch():
1351 raise error.Abort(_("nothing to merge"),
1350 raise error.Abort(_("nothing to merge"),
1352 hint=_("use 'hg update' "
1351 hint=_("use 'hg update' "
1353 "or check 'hg heads'"))
1352 "or check 'hg heads'"))
1354 if not force and (wc.files() or wc.deleted()):
1353 if not force and (wc.files() or wc.deleted()):
1355 raise error.Abort(_("uncommitted changes"),
1354 raise error.Abort(_("uncommitted changes"),
1356 hint=_("use 'hg status' to list changes"))
1355 hint=_("use 'hg status' to list changes"))
1357 for s in sorted(wc.substate):
1356 for s in sorted(wc.substate):
1358 wc.sub(s).bailifchanged()
1357 wc.sub(s).bailifchanged()
1359
1358
1360 elif not overwrite:
1359 elif not overwrite:
1361 if p1 == p2: # no-op update
1360 if p1 == p2: # no-op update
1362 # call the hooks and exit early
1361 # call the hooks and exit early
1363 repo.hook('preupdate', throw=True, parent1=xp2, parent2='')
1362 repo.hook('preupdate', throw=True, parent1=xp2, parent2='')
1364 repo.hook('update', parent1=xp2, parent2='', error=0)
1363 repo.hook('update', parent1=xp2, parent2='', error=0)
1365 return 0, 0, 0, 0
1364 return 0, 0, 0, 0
1366
1365
1367 if pas not in ([p1], [p2]): # nonlinear
1366 if pas not in ([p1], [p2]): # nonlinear
1368 dirty = wc.dirty(missing=True)
1367 dirty = wc.dirty(missing=True)
1369 if dirty or onode is None:
1368 if dirty or onode is None:
1370 # Branching is a bit strange to ensure we do the minimal
1369 # Branching is a bit strange to ensure we do the minimal
1371 # amount of call to obsolete.background.
1370 # amount of call to obsolete.background.
1372 foreground = obsolete.foreground(repo, [p1.node()])
1371 foreground = obsolete.foreground(repo, [p1.node()])
1373 # note: the <node> variable contains a random identifier
1372 # note: the <node> variable contains a random identifier
1374 if repo[node].node() in foreground:
1373 if repo[node].node() in foreground:
1375 pas = [p1] # allow updating to successors
1374 pas = [p1] # allow updating to successors
1376 elif dirty:
1375 elif dirty:
1377 msg = _("uncommitted changes")
1376 msg = _("uncommitted changes")
1378 if onode is None:
1377 if onode is None:
1379 hint = _("commit and merge, or update --clean to"
1378 hint = _("commit and merge, or update --clean to"
1380 " discard changes")
1379 " discard changes")
1381 else:
1380 else:
1382 hint = _("commit or update --clean to discard"
1381 hint = _("commit or update --clean to discard"
1383 " changes")
1382 " changes")
1384 raise error.Abort(msg, hint=hint)
1383 raise error.Abort(msg, hint=hint)
1385 else: # node is none
1384 else: # node is none
1386 msg = _("not a linear update")
1385 msg = _("not a linear update")
1387 hint = _("merge or update --check to force update")
1386 hint = _("merge or update --check to force update")
1388 raise error.Abort(msg, hint=hint)
1387 raise error.Abort(msg, hint=hint)
1389 else:
1388 else:
1390 # Allow jumping branches if clean and specific rev given
1389 # Allow jumping branches if clean and specific rev given
1391 pas = [p1]
1390 pas = [p1]
1392
1391
1393 # deprecated config: merge.followcopies
1392 # deprecated config: merge.followcopies
1394 followcopies = False
1393 followcopies = False
1395 if overwrite:
1394 if overwrite:
1396 pas = [wc]
1395 pas = [wc]
1397 elif pas == [p2]: # backwards
1396 elif pas == [p2]: # backwards
1398 pas = [wc.p1()]
1397 pas = [wc.p1()]
1399 elif not branchmerge and not wc.dirty(missing=True):
1398 elif not branchmerge and not wc.dirty(missing=True):
1400 pass
1399 pass
1401 elif pas[0] and repo.ui.configbool('merge', 'followcopies', True):
1400 elif pas[0] and repo.ui.configbool('merge', 'followcopies', True):
1402 followcopies = True
1401 followcopies = True
1403
1402
1404 ### calculate phase
1403 ### calculate phase
1405 actionbyfile, diverge, renamedelete = calculateupdates(
1404 actionbyfile, diverge, renamedelete = calculateupdates(
1406 repo, wc, p2, pas, branchmerge, force, partial, mergeancestor,
1405 repo, wc, p2, pas, branchmerge, force, partial, mergeancestor,
1407 followcopies)
1406 followcopies)
1408 # Convert to dictionary-of-lists format
1407 # Convert to dictionary-of-lists format
1409 actions = dict((m, []) for m in 'a am f g cd dc r dm dg m e k'.split())
1408 actions = dict((m, []) for m in 'a am f g cd dc r dm dg m e k'.split())
1410 for f, (m, args, msg) in actionbyfile.iteritems():
1409 for f, (m, args, msg) in actionbyfile.iteritems():
1411 if m not in actions:
1410 if m not in actions:
1412 actions[m] = []
1411 actions[m] = []
1413 actions[m].append((f, args, msg))
1412 actions[m].append((f, args, msg))
1414
1413
1415 if not util.checkcase(repo.path):
1414 if not util.checkcase(repo.path):
1416 # check collision between files only in p2 for clean update
1415 # check collision between files only in p2 for clean update
1417 if (not branchmerge and
1416 if (not branchmerge and
1418 (force or not wc.dirty(missing=True, branch=False))):
1417 (force or not wc.dirty(missing=True, branch=False))):
1419 _checkcollision(repo, p2.manifest(), None)
1418 _checkcollision(repo, p2.manifest(), None)
1420 else:
1419 else:
1421 _checkcollision(repo, wc.manifest(), actions)
1420 _checkcollision(repo, wc.manifest(), actions)
1422
1421
1423 # Prompt and create actions. TODO: Move this towards resolve phase.
1422 # Prompt and create actions. TODO: Move this towards resolve phase.
1424 for f, args, msg in sorted(actions['cd']):
1423 for f, args, msg in sorted(actions['cd']):
1425 if repo.ui.promptchoice(
1424 if repo.ui.promptchoice(
1426 _("local changed %s which remote deleted\n"
1425 _("local changed %s which remote deleted\n"
1427 "use (c)hanged version or (d)elete?"
1426 "use (c)hanged version or (d)elete?"
1428 "$$ &Changed $$ &Delete") % f, 0):
1427 "$$ &Changed $$ &Delete") % f, 0):
1429 actions['r'].append((f, None, "prompt delete"))
1428 actions['r'].append((f, None, "prompt delete"))
1430 elif f in p1:
1429 elif f in p1:
1431 actions['am'].append((f, None, "prompt keep"))
1430 actions['am'].append((f, None, "prompt keep"))
1432 else:
1431 else:
1433 actions['a'].append((f, None, "prompt keep"))
1432 actions['a'].append((f, None, "prompt keep"))
1434
1433
1435 for f, args, msg in sorted(actions['dc']):
1434 for f, args, msg in sorted(actions['dc']):
1436 f1, f2, fa, move, anc = args
1435 f1, f2, fa, move, anc = args
1437 flags = p2[f2].flags()
1436 flags = p2[f2].flags()
1438 if repo.ui.promptchoice(
1437 if repo.ui.promptchoice(
1439 _("remote changed %s which local deleted\n"
1438 _("remote changed %s which local deleted\n"
1440 "use (c)hanged version or leave (d)eleted?"
1439 "use (c)hanged version or leave (d)eleted?"
1441 "$$ &Changed $$ &Deleted") % f, 0) == 0:
1440 "$$ &Changed $$ &Deleted") % f, 0) == 0:
1442 actions['g'].append((f, (flags,), "prompt recreating"))
1441 actions['g'].append((f, (flags,), "prompt recreating"))
1443
1442
1444 # divergent renames
1443 # divergent renames
1445 for f, fl in sorted(diverge.iteritems()):
1444 for f, fl in sorted(diverge.iteritems()):
1446 repo.ui.warn(_("note: possible conflict - %s was renamed "
1445 repo.ui.warn(_("note: possible conflict - %s was renamed "
1447 "multiple times to:\n") % f)
1446 "multiple times to:\n") % f)
1448 for nf in fl:
1447 for nf in fl:
1449 repo.ui.warn(" %s\n" % nf)
1448 repo.ui.warn(" %s\n" % nf)
1450
1449
1451 # rename and delete
1450 # rename and delete
1452 for f, fl in sorted(renamedelete.iteritems()):
1451 for f, fl in sorted(renamedelete.iteritems()):
1453 repo.ui.warn(_("note: possible conflict - %s was deleted "
1452 repo.ui.warn(_("note: possible conflict - %s was deleted "
1454 "and renamed to:\n") % f)
1453 "and renamed to:\n") % f)
1455 for nf in fl:
1454 for nf in fl:
1456 repo.ui.warn(" %s\n" % nf)
1455 repo.ui.warn(" %s\n" % nf)
1457
1456
1458 ### apply phase
1457 ### apply phase
1459 if not branchmerge: # just jump to the new rev
1458 if not branchmerge: # just jump to the new rev
1460 fp1, fp2, xp1, xp2 = fp2, nullid, xp2, ''
1459 fp1, fp2, xp1, xp2 = fp2, nullid, xp2, ''
1461 if not partial:
1460 if not partial:
1462 repo.hook('preupdate', throw=True, parent1=xp1, parent2=xp2)
1461 repo.hook('preupdate', throw=True, parent1=xp1, parent2=xp2)
1463 # note that we're in the middle of an update
1462 # note that we're in the middle of an update
1464 repo.vfs.write('updatestate', p2.hex())
1463 repo.vfs.write('updatestate', p2.hex())
1465
1464
1466 stats = applyupdates(repo, actions, wc, p2, overwrite, labels=labels)
1465 stats = applyupdates(repo, actions, wc, p2, overwrite, labels=labels)
1467
1466
1468 if not partial:
1467 if not partial:
1469 repo.dirstate.beginparentchange()
1468 repo.dirstate.beginparentchange()
1470 repo.setparents(fp1, fp2)
1469 repo.setparents(fp1, fp2)
1471 recordupdates(repo, actions, branchmerge)
1470 recordupdates(repo, actions, branchmerge)
1472 # update completed, clear state
1471 # update completed, clear state
1473 util.unlink(repo.join('updatestate'))
1472 util.unlink(repo.join('updatestate'))
1474
1473
1475 if not branchmerge:
1474 if not branchmerge:
1476 repo.dirstate.setbranch(p2.branch())
1475 repo.dirstate.setbranch(p2.branch())
1477 repo.dirstate.endparentchange()
1476 repo.dirstate.endparentchange()
1478 finally:
1477 finally:
1479 wlock.release()
1478 wlock.release()
1480
1479
1481 if not partial:
1480 if not partial:
1482 repo.hook('update', parent1=xp1, parent2=xp2, error=stats[3])
1481 repo.hook('update', parent1=xp1, parent2=xp2, error=stats[3])
1483 return stats
1482 return stats
1484
1483
1485 def graft(repo, ctx, pctx, labels):
1484 def graft(repo, ctx, pctx, labels):
1486 """Do a graft-like merge.
1485 """Do a graft-like merge.
1487
1486
1488 This is a merge where the merge ancestor is chosen such that one
1487 This is a merge where the merge ancestor is chosen such that one
1489 or more changesets are grafted onto the current changeset. In
1488 or more changesets are grafted onto the current changeset. In
1490 addition to the merge, this fixes up the dirstate to include only
1489 addition to the merge, this fixes up the dirstate to include only
1491 a single parent and tries to duplicate any renames/copies
1490 a single parent and tries to duplicate any renames/copies
1492 appropriately.
1491 appropriately.
1493
1492
1494 ctx - changeset to rebase
1493 ctx - changeset to rebase
1495 pctx - merge base, usually ctx.p1()
1494 pctx - merge base, usually ctx.p1()
1496 labels - merge labels eg ['local', 'graft']
1495 labels - merge labels eg ['local', 'graft']
1497
1496
1498 """
1497 """
1499 # If we're grafting a descendant onto an ancestor, be sure to pass
1498 # If we're grafting a descendant onto an ancestor, be sure to pass
1500 # mergeancestor=True to update. This does two things: 1) allows the merge if
1499 # mergeancestor=True to update. This does two things: 1) allows the merge if
1501 # the destination is the same as the parent of the ctx (so we can use graft
1500 # the destination is the same as the parent of the ctx (so we can use graft
1502 # to copy commits), and 2) informs update that the incoming changes are
1501 # to copy commits), and 2) informs update that the incoming changes are
1503 # newer than the destination so it doesn't prompt about "remote changed foo
1502 # newer than the destination so it doesn't prompt about "remote changed foo
1504 # which local deleted".
1503 # which local deleted".
1505 mergeancestor = repo.changelog.isancestor(repo['.'].node(), ctx.node())
1504 mergeancestor = repo.changelog.isancestor(repo['.'].node(), ctx.node())
1506
1505
1507 stats = update(repo, ctx.node(), True, True, False, pctx.node(),
1506 stats = update(repo, ctx.node(), True, True, False, pctx.node(),
1508 mergeancestor=mergeancestor, labels=labels)
1507 mergeancestor=mergeancestor, labels=labels)
1509
1508
1510 # drop the second merge parent
1509 # drop the second merge parent
1511 repo.dirstate.beginparentchange()
1510 repo.dirstate.beginparentchange()
1512 repo.setparents(repo['.'].node(), nullid)
1511 repo.setparents(repo['.'].node(), nullid)
1513 repo.dirstate.write(repo.currenttransaction())
1512 repo.dirstate.write(repo.currenttransaction())
1514 # fix up dirstate for copies and renames
1513 # fix up dirstate for copies and renames
1515 copies.duplicatecopies(repo, ctx.rev(), pctx.rev())
1514 copies.duplicatecopies(repo, ctx.rev(), pctx.rev())
1516 repo.dirstate.endparentchange()
1515 repo.dirstate.endparentchange()
1517 return stats
1516 return stats
General Comments 0
You need to be logged in to leave comments. Login now