##// END OF EJS Templates
merge with stable
Matt Mackall -
r23152:b8f6d840 merge default
parent child Browse files
Show More
@@ -1,331 +1,330 b''
1 1 # extdiff.py - external diff program support for mercurial
2 2 #
3 3 # Copyright 2006 Vadim Gelfer <vadim.gelfer@gmail.com>
4 4 #
5 5 # This software may be used and distributed according to the terms of the
6 6 # GNU General Public License version 2 or any later version.
7 7
8 8 '''command to allow external programs to compare revisions
9 9
10 10 The extdiff Mercurial extension allows you to use external programs
11 11 to compare revisions, or revision with working directory. The external
12 12 diff programs are called with a configurable set of options and two
13 13 non-option arguments: paths to directories containing snapshots of
14 14 files to compare.
15 15
16 16 The extdiff extension also allows you to configure new diff commands, so
17 17 you do not need to type :hg:`extdiff -p kdiff3` always. ::
18 18
19 19 [extdiff]
20 20 # add new command that runs GNU diff(1) in 'context diff' mode
21 21 cdiff = gdiff -Nprc5
22 22 ## or the old way:
23 23 #cmd.cdiff = gdiff
24 24 #opts.cdiff = -Nprc5
25 25
26 26 # add new command called meld, runs meld (no need to name twice). If
27 27 # the meld executable is not available, the meld tool in [merge-tools]
28 28 # will be used, if available
29 29 meld =
30 30
31 31 # add new command called vimdiff, runs gvimdiff with DirDiff plugin
32 32 # (see http://www.vim.org/scripts/script.php?script_id=102) Non
33 33 # English user, be sure to put "let g:DirDiffDynamicDiffText = 1" in
34 34 # your .vimrc
35 35 vimdiff = gvim -f "+next" \\
36 36 "+execute 'DirDiff' fnameescape(argv(0)) fnameescape(argv(1))"
37 37
38 38 Tool arguments can include variables that are expanded at runtime::
39 39
40 40 $parent1, $plabel1 - filename, descriptive label of first parent
41 41 $child, $clabel - filename, descriptive label of child revision
42 42 $parent2, $plabel2 - filename, descriptive label of second parent
43 43 $root - repository root
44 44 $parent is an alias for $parent1.
45 45
46 46 The extdiff extension will look in your [diff-tools] and [merge-tools]
47 47 sections for diff tool arguments, when none are specified in [extdiff].
48 48
49 49 ::
50 50
51 51 [extdiff]
52 52 kdiff3 =
53 53
54 54 [diff-tools]
55 55 kdiff3.diffargs=--L1 '$plabel1' --L2 '$clabel' $parent $child
56 56
57 57 You can use -I/-X and list of file or directory names like normal
58 58 :hg:`diff` command. The extdiff extension makes snapshots of only
59 59 needed files, so running the external diff program will actually be
60 60 pretty fast (at least faster than having to compare the entire tree).
61 61 '''
62 62
63 63 from mercurial.i18n import _
64 64 from mercurial.node import short, nullid
65 65 from mercurial import cmdutil, scmutil, util, commands, encoding, filemerge
66 66 import os, shlex, shutil, tempfile, re
67 67
68 68 cmdtable = {}
69 69 command = cmdutil.command(cmdtable)
70 70 testedwith = 'internal'
71 71
72 72 def snapshot(ui, repo, files, node, tmproot):
73 73 '''snapshot files as of some revision
74 74 if not using snapshot, -I/-X does not work and recursive diff
75 75 in tools like kdiff3 and meld displays too many files.'''
76 76 dirname = os.path.basename(repo.root)
77 77 if dirname == "":
78 78 dirname = "root"
79 79 if node is not None:
80 80 dirname = '%s.%s' % (dirname, short(node))
81 81 base = os.path.join(tmproot, dirname)
82 82 os.mkdir(base)
83 83 if node is not None:
84 84 ui.note(_('making snapshot of %d files from rev %s\n') %
85 85 (len(files), short(node)))
86 86 else:
87 87 ui.note(_('making snapshot of %d files from working directory\n') %
88 88 (len(files)))
89 89 wopener = scmutil.opener(base)
90 90 fns_and_mtime = []
91 91 ctx = repo[node]
92 92 for fn in sorted(files):
93 93 wfn = util.pconvert(fn)
94 94 if wfn not in ctx:
95 95 # File doesn't exist; could be a bogus modify
96 96 continue
97 97 ui.note(' %s\n' % wfn)
98 98 dest = os.path.join(base, wfn)
99 99 fctx = ctx[wfn]
100 100 data = repo.wwritedata(wfn, fctx.data())
101 101 if 'l' in fctx.flags():
102 102 wopener.symlink(data, wfn)
103 103 else:
104 104 wopener.write(wfn, data)
105 105 if 'x' in fctx.flags():
106 106 util.setflags(dest, False, True)
107 107 if node is None:
108 108 fns_and_mtime.append((dest, repo.wjoin(fn),
109 109 os.lstat(dest).st_mtime))
110 110 return dirname, fns_and_mtime
111 111
112 112 def dodiff(ui, repo, diffcmd, diffopts, pats, opts):
113 113 '''Do the actual diff:
114 114
115 115 - copy to a temp structure if diffing 2 internal revisions
116 116 - copy to a temp structure if diffing working revision with
117 117 another one and more than 1 file is changed
118 118 - just invoke the diff for a single file in the working dir
119 119 '''
120 120
121 121 revs = opts.get('rev')
122 122 change = opts.get('change')
123 args = ' '.join(diffopts)
123 args = ' '.join(map(util.shellquote, diffopts))
124 124 do3way = '$parent2' in args
125 125
126 126 if revs and change:
127 127 msg = _('cannot specify --rev and --change at the same time')
128 128 raise util.Abort(msg)
129 129 elif change:
130 130 node2 = scmutil.revsingle(repo, change, None).node()
131 131 node1a, node1b = repo.changelog.parents(node2)
132 132 else:
133 133 node1a, node2 = scmutil.revpair(repo, revs)
134 134 if not revs:
135 135 node1b = repo.dirstate.p2()
136 136 else:
137 137 node1b = nullid
138 138
139 139 # Disable 3-way merge if there is only one parent
140 140 if do3way:
141 141 if node1b == nullid:
142 142 do3way = False
143 143
144 144 matcher = scmutil.match(repo[node2], pats, opts)
145 145 mod_a, add_a, rem_a = map(set, repo.status(node1a, node2, matcher)[:3])
146 146 if do3way:
147 147 mod_b, add_b, rem_b = map(set, repo.status(node1b, node2, matcher)[:3])
148 148 else:
149 149 mod_b, add_b, rem_b = set(), set(), set()
150 150 modadd = mod_a | add_a | mod_b | add_b
151 151 common = modadd | rem_a | rem_b
152 152 if not common:
153 153 return 0
154 154
155 155 tmproot = tempfile.mkdtemp(prefix='extdiff.')
156 156 try:
157 157 # Always make a copy of node1a (and node1b, if applicable)
158 158 dir1a_files = mod_a | rem_a | ((mod_b | add_b) - add_a)
159 159 dir1a = snapshot(ui, repo, dir1a_files, node1a, tmproot)[0]
160 160 rev1a = '@%d' % repo[node1a].rev()
161 161 if do3way:
162 162 dir1b_files = mod_b | rem_b | ((mod_a | add_a) - add_b)
163 163 dir1b = snapshot(ui, repo, dir1b_files, node1b, tmproot)[0]
164 164 rev1b = '@%d' % repo[node1b].rev()
165 165 else:
166 166 dir1b = None
167 167 rev1b = ''
168 168
169 169 fns_and_mtime = []
170 170
171 171 # If node2 in not the wc or there is >1 change, copy it
172 172 dir2root = ''
173 173 rev2 = ''
174 174 if node2:
175 175 dir2 = snapshot(ui, repo, modadd, node2, tmproot)[0]
176 176 rev2 = '@%d' % repo[node2].rev()
177 177 elif len(common) > 1:
178 178 #we only actually need to get the files to copy back to
179 179 #the working dir in this case (because the other cases
180 180 #are: diffing 2 revisions or single file -- in which case
181 181 #the file is already directly passed to the diff tool).
182 182 dir2, fns_and_mtime = snapshot(ui, repo, modadd, None, tmproot)
183 183 else:
184 184 # This lets the diff tool open the changed file directly
185 185 dir2 = ''
186 186 dir2root = repo.root
187 187
188 188 label1a = rev1a
189 189 label1b = rev1b
190 190 label2 = rev2
191 191
192 192 # If only one change, diff the files instead of the directories
193 193 # Handle bogus modifies correctly by checking if the files exist
194 194 if len(common) == 1:
195 195 common_file = util.localpath(common.pop())
196 196 dir1a = os.path.join(tmproot, dir1a, common_file)
197 197 label1a = common_file + rev1a
198 198 if not os.path.isfile(dir1a):
199 199 dir1a = os.devnull
200 200 if do3way:
201 201 dir1b = os.path.join(tmproot, dir1b, common_file)
202 202 label1b = common_file + rev1b
203 203 if not os.path.isfile(dir1b):
204 204 dir1b = os.devnull
205 205 dir2 = os.path.join(dir2root, dir2, common_file)
206 206 label2 = common_file + rev2
207 207
208 208 # Function to quote file/dir names in the argument string.
209 209 # When not operating in 3-way mode, an empty string is
210 210 # returned for parent2
211 211 replace = {'parent': dir1a, 'parent1': dir1a, 'parent2': dir1b,
212 212 'plabel1': label1a, 'plabel2': label1b,
213 213 'clabel': label2, 'child': dir2,
214 214 'root': repo.root}
215 215 def quote(match):
216 216 key = match.group()[1:]
217 217 if not do3way and key == 'parent2':
218 218 return ''
219 219 return util.shellquote(replace[key])
220 220
221 221 # Match parent2 first, so 'parent1?' will match both parent1 and parent
222 222 regex = '\$(parent2|parent1?|child|plabel1|plabel2|clabel|root)'
223 223 if not do3way and not re.search(regex, args):
224 224 args += ' $parent1 $child'
225 225 args = re.sub(regex, quote, args)
226 226 cmdline = util.shellquote(diffcmd) + ' ' + args
227 227
228 228 ui.debug('running %r in %s\n' % (cmdline, tmproot))
229 229 util.system(cmdline, cwd=tmproot, out=ui.fout)
230 230
231 231 for copy_fn, working_fn, mtime in fns_and_mtime:
232 232 if os.lstat(copy_fn).st_mtime != mtime:
233 233 ui.debug('file changed while diffing. '
234 234 'Overwriting: %s (src: %s)\n' % (working_fn, copy_fn))
235 235 util.copyfile(copy_fn, working_fn)
236 236
237 237 return 1
238 238 finally:
239 239 ui.note(_('cleaning up temp directory\n'))
240 240 shutil.rmtree(tmproot)
241 241
242 242 @command('extdiff',
243 243 [('p', 'program', '',
244 244 _('comparison program to run'), _('CMD')),
245 245 ('o', 'option', [],
246 246 _('pass option to comparison program'), _('OPT')),
247 247 ('r', 'rev', [], _('revision'), _('REV')),
248 248 ('c', 'change', '', _('change made by revision'), _('REV')),
249 249 ] + commands.walkopts,
250 250 _('hg extdiff [OPT]... [FILE]...'),
251 251 inferrepo=True)
252 252 def extdiff(ui, repo, *pats, **opts):
253 253 '''use external program to diff repository (or selected files)
254 254
255 255 Show differences between revisions for the specified files, using
256 256 an external program. The default program used is diff, with
257 257 default options "-Npru".
258 258
259 259 To select a different program, use the -p/--program option. The
260 260 program will be passed the names of two directories to compare. To
261 261 pass additional options to the program, use -o/--option. These
262 262 will be passed before the names of the directories to compare.
263 263
264 264 When two revision arguments are given, then changes are shown
265 265 between those revisions. If only one revision is specified then
266 266 that revision is compared to the working directory, and, when no
267 267 revisions are specified, the working directory files are compared
268 268 to its parent.'''
269 269 program = opts.get('program')
270 270 option = opts.get('option')
271 271 if not program:
272 272 program = 'diff'
273 273 option = option or ['-Npru']
274 274 return dodiff(ui, repo, program, option, pats, opts)
275 275
276 276 def uisetup(ui):
277 277 for cmd, path in ui.configitems('extdiff'):
278 278 if cmd.startswith('cmd.'):
279 279 cmd = cmd[4:]
280 280 if not path:
281 281 path = util.findexe(cmd)
282 282 if path is None:
283 283 path = filemerge.findexternaltool(ui, cmd) or cmd
284 diffopts = ui.config('extdiff', 'opts.' + cmd, '')
285 diffopts = diffopts and [diffopts] or []
284 diffopts = shlex.split(ui.config('extdiff', 'opts.' + cmd, ''))
286 285 elif cmd.startswith('opts.'):
287 286 continue
288 287 else:
289 288 # command = path opts
290 289 if path:
291 290 diffopts = shlex.split(path)
292 291 path = diffopts.pop(0)
293 292 else:
294 293 path, diffopts = util.findexe(cmd), []
295 294 if path is None:
296 295 path = filemerge.findexternaltool(ui, cmd) or cmd
297 296 # look for diff arguments in [diff-tools] then [merge-tools]
298 297 if diffopts == []:
299 298 args = ui.config('diff-tools', cmd+'.diffargs') or \
300 299 ui.config('merge-tools', cmd+'.diffargs')
301 300 if args:
302 301 diffopts = shlex.split(args)
303 302 def save(cmd, path, diffopts):
304 303 '''use closure to save diff command to use'''
305 304 def mydiff(ui, repo, *pats, **opts):
306 305 return dodiff(ui, repo, path, diffopts + opts['option'],
307 306 pats, opts)
308 307 doc = _('''\
309 308 use %(path)s to diff repository (or selected files)
310 309
311 310 Show differences between revisions for the specified files, using
312 311 the %(path)s program.
313 312
314 313 When two revision arguments are given, then changes are shown
315 314 between those revisions. If only one revision is specified then
316 315 that revision is compared to the working directory, and, when no
317 316 revisions are specified, the working directory files are compared
318 317 to its parent.\
319 318 ''') % {'path': util.uirepr(path)}
320 319
321 320 # We must translate the docstring right away since it is
322 321 # used as a format string. The string will unfortunately
323 322 # be translated again in commands.helpcmd and this will
324 323 # fail when the docstring contains non-ASCII characters.
325 324 # Decoding the string to a Unicode string here (using the
326 325 # right encoding) prevents that.
327 326 mydiff.__doc__ = doc.decode(encoding.encoding)
328 327 return mydiff
329 328 cmdtable[cmd] = (save(cmd, path, diffopts),
330 329 cmdtable['extdiff'][1][1:],
331 330 _('hg %s [OPTION]... [FILE]...') % cmd)
@@ -1,6314 +1,6314 b''
1 1 # commands.py - command processing for mercurial
2 2 #
3 3 # Copyright 2005-2007 Matt Mackall <mpm@selenic.com>
4 4 #
5 5 # This software may be used and distributed according to the terms of the
6 6 # GNU General Public License version 2 or any later version.
7 7
8 8 from node import hex, bin, nullid, nullrev, short
9 9 from lock import release
10 10 from i18n import _
11 11 import os, re, difflib, time, tempfile, errno, shlex
12 12 import sys, socket
13 13 import hg, scmutil, util, revlog, copies, error, bookmarks
14 14 import patch, help, encoding, templatekw, discovery
15 15 import archival, changegroup, cmdutil, hbisect
16 16 import sshserver, hgweb, commandserver
17 17 import extensions
18 18 from hgweb import server as hgweb_server
19 19 import merge as mergemod
20 20 import minirst, revset, fileset
21 21 import dagparser, context, simplemerge, graphmod, copies
22 22 import random
23 23 import setdiscovery, treediscovery, dagutil, pvec, localrepo
24 24 import phases, obsolete, exchange
25 25 import ui as uimod
26 26
27 27 table = {}
28 28
29 29 command = cmdutil.command(table)
30 30
31 31 # Space delimited list of commands that don't require local repositories.
32 32 # This should be populated by passing norepo=True into the @command decorator.
33 33 norepo = ''
34 34 # Space delimited list of commands that optionally require local repositories.
35 35 # This should be populated by passing optionalrepo=True into the @command
36 36 # decorator.
37 37 optionalrepo = ''
38 38 # Space delimited list of commands that will examine arguments looking for
39 39 # a repository. This should be populated by passing inferrepo=True into the
40 40 # @command decorator.
41 41 inferrepo = ''
42 42
43 43 # common command options
44 44
45 45 globalopts = [
46 46 ('R', 'repository', '',
47 47 _('repository root directory or name of overlay bundle file'),
48 48 _('REPO')),
49 49 ('', 'cwd', '',
50 50 _('change working directory'), _('DIR')),
51 51 ('y', 'noninteractive', None,
52 52 _('do not prompt, automatically pick the first choice for all prompts')),
53 53 ('q', 'quiet', None, _('suppress output')),
54 54 ('v', 'verbose', None, _('enable additional output')),
55 55 ('', 'config', [],
56 56 _('set/override config option (use \'section.name=value\')'),
57 57 _('CONFIG')),
58 58 ('', 'debug', None, _('enable debugging output')),
59 59 ('', 'debugger', None, _('start debugger')),
60 60 ('', 'encoding', encoding.encoding, _('set the charset encoding'),
61 61 _('ENCODE')),
62 62 ('', 'encodingmode', encoding.encodingmode,
63 63 _('set the charset encoding mode'), _('MODE')),
64 64 ('', 'traceback', None, _('always print a traceback on exception')),
65 65 ('', 'time', None, _('time how long the command takes')),
66 66 ('', 'profile', None, _('print command execution profile')),
67 67 ('', 'version', None, _('output version information and exit')),
68 68 ('h', 'help', None, _('display help and exit')),
69 69 ('', 'hidden', False, _('consider hidden changesets')),
70 70 ]
71 71
72 72 dryrunopts = [('n', 'dry-run', None,
73 73 _('do not perform actions, just print output'))]
74 74
75 75 remoteopts = [
76 76 ('e', 'ssh', '',
77 77 _('specify ssh command to use'), _('CMD')),
78 78 ('', 'remotecmd', '',
79 79 _('specify hg command to run on the remote side'), _('CMD')),
80 80 ('', 'insecure', None,
81 81 _('do not verify server certificate (ignoring web.cacerts config)')),
82 82 ]
83 83
84 84 walkopts = [
85 85 ('I', 'include', [],
86 86 _('include names matching the given patterns'), _('PATTERN')),
87 87 ('X', 'exclude', [],
88 88 _('exclude names matching the given patterns'), _('PATTERN')),
89 89 ]
90 90
91 91 commitopts = [
92 92 ('m', 'message', '',
93 93 _('use text as commit message'), _('TEXT')),
94 94 ('l', 'logfile', '',
95 95 _('read commit message from file'), _('FILE')),
96 96 ]
97 97
98 98 commitopts2 = [
99 99 ('d', 'date', '',
100 100 _('record the specified date as commit date'), _('DATE')),
101 101 ('u', 'user', '',
102 102 _('record the specified user as committer'), _('USER')),
103 103 ]
104 104
105 105 # hidden for now
106 106 formatteropts = [
107 107 ('T', 'template', '',
108 108 _('display with template (DEPRECATED)'), _('TEMPLATE')),
109 109 ]
110 110
111 111 templateopts = [
112 112 ('', 'style', '',
113 113 _('display using template map file (DEPRECATED)'), _('STYLE')),
114 114 ('T', 'template', '',
115 115 _('display with template'), _('TEMPLATE')),
116 116 ]
117 117
118 118 logopts = [
119 119 ('p', 'patch', None, _('show patch')),
120 120 ('g', 'git', None, _('use git extended diff format')),
121 121 ('l', 'limit', '',
122 122 _('limit number of changes displayed'), _('NUM')),
123 123 ('M', 'no-merges', None, _('do not show merges')),
124 124 ('', 'stat', None, _('output diffstat-style summary of changes')),
125 125 ('G', 'graph', None, _("show the revision DAG")),
126 126 ] + templateopts
127 127
128 128 diffopts = [
129 129 ('a', 'text', None, _('treat all files as text')),
130 130 ('g', 'git', None, _('use git extended diff format')),
131 131 ('', 'nodates', None, _('omit dates from diff headers'))
132 132 ]
133 133
134 134 diffwsopts = [
135 135 ('w', 'ignore-all-space', None,
136 136 _('ignore white space when comparing lines')),
137 137 ('b', 'ignore-space-change', None,
138 138 _('ignore changes in the amount of white space')),
139 139 ('B', 'ignore-blank-lines', None,
140 140 _('ignore changes whose lines are all blank')),
141 141 ]
142 142
143 143 diffopts2 = [
144 144 ('p', 'show-function', None, _('show which function each change is in')),
145 145 ('', 'reverse', None, _('produce a diff that undoes the changes')),
146 146 ] + diffwsopts + [
147 147 ('U', 'unified', '',
148 148 _('number of lines of context to show'), _('NUM')),
149 149 ('', 'stat', None, _('output diffstat-style summary of changes')),
150 150 ]
151 151
152 152 mergetoolopts = [
153 153 ('t', 'tool', '', _('specify merge tool')),
154 154 ]
155 155
156 156 similarityopts = [
157 157 ('s', 'similarity', '',
158 158 _('guess renamed files by similarity (0<=s<=100)'), _('SIMILARITY'))
159 159 ]
160 160
161 161 subrepoopts = [
162 162 ('S', 'subrepos', None,
163 163 _('recurse into subrepositories'))
164 164 ]
165 165
166 166 # Commands start here, listed alphabetically
167 167
168 168 @command('^add',
169 169 walkopts + subrepoopts + dryrunopts,
170 170 _('[OPTION]... [FILE]...'),
171 171 inferrepo=True)
172 172 def add(ui, repo, *pats, **opts):
173 173 """add the specified files on the next commit
174 174
175 175 Schedule files to be version controlled and added to the
176 176 repository.
177 177
178 178 The files will be added to the repository at the next commit. To
179 179 undo an add before that, see :hg:`forget`.
180 180
181 181 If no names are given, add all files to the repository.
182 182
183 183 .. container:: verbose
184 184
185 185 An example showing how new (unknown) files are added
186 186 automatically by :hg:`add`::
187 187
188 188 $ ls
189 189 foo.c
190 190 $ hg status
191 191 ? foo.c
192 192 $ hg add
193 193 adding foo.c
194 194 $ hg status
195 195 A foo.c
196 196
197 197 Returns 0 if all files are successfully added.
198 198 """
199 199
200 200 m = scmutil.match(repo[None], pats, opts)
201 201 rejected = cmdutil.add(ui, repo, m, opts.get('dry_run'),
202 202 opts.get('subrepos'), prefix="", explicitonly=False)
203 203 return rejected and 1 or 0
204 204
205 205 @command('addremove',
206 206 similarityopts + walkopts + dryrunopts,
207 207 _('[OPTION]... [FILE]...'),
208 208 inferrepo=True)
209 209 def addremove(ui, repo, *pats, **opts):
210 210 """add all new files, delete all missing files
211 211
212 212 Add all new files and remove all missing files from the
213 213 repository.
214 214
215 215 New files are ignored if they match any of the patterns in
216 216 ``.hgignore``. As with add, these changes take effect at the next
217 217 commit.
218 218
219 219 Use the -s/--similarity option to detect renamed files. This
220 220 option takes a percentage between 0 (disabled) and 100 (files must
221 221 be identical) as its parameter. With a parameter greater than 0,
222 222 this compares every removed file with every added file and records
223 223 those similar enough as renames. Detecting renamed files this way
224 224 can be expensive. After using this option, :hg:`status -C` can be
225 225 used to check which files were identified as moved or renamed. If
226 226 not specified, -s/--similarity defaults to 100 and only renames of
227 227 identical files are detected.
228 228
229 229 Returns 0 if all files are successfully added.
230 230 """
231 231 try:
232 232 sim = float(opts.get('similarity') or 100)
233 233 except ValueError:
234 234 raise util.Abort(_('similarity must be a number'))
235 235 if sim < 0 or sim > 100:
236 236 raise util.Abort(_('similarity must be between 0 and 100'))
237 237 return scmutil.addremove(repo, pats, opts, similarity=sim / 100.0)
238 238
239 239 @command('^annotate|blame',
240 240 [('r', 'rev', '', _('annotate the specified revision'), _('REV')),
241 241 ('', 'follow', None,
242 242 _('follow copies/renames and list the filename (DEPRECATED)')),
243 243 ('', 'no-follow', None, _("don't follow copies and renames")),
244 244 ('a', 'text', None, _('treat all files as text')),
245 245 ('u', 'user', None, _('list the author (long with -v)')),
246 246 ('f', 'file', None, _('list the filename')),
247 247 ('d', 'date', None, _('list the date (short with -q)')),
248 248 ('n', 'number', None, _('list the revision number (default)')),
249 249 ('c', 'changeset', None, _('list the changeset')),
250 250 ('l', 'line-number', None, _('show line number at the first appearance'))
251 251 ] + diffwsopts + walkopts + formatteropts,
252 252 _('[-r REV] [-f] [-a] [-u] [-d] [-n] [-c] [-l] FILE...'),
253 253 inferrepo=True)
254 254 def annotate(ui, repo, *pats, **opts):
255 255 """show changeset information by line for each file
256 256
257 257 List changes in files, showing the revision id responsible for
258 258 each line
259 259
260 260 This command is useful for discovering when a change was made and
261 261 by whom.
262 262
263 263 Without the -a/--text option, annotate will avoid processing files
264 264 it detects as binary. With -a, annotate will annotate the file
265 265 anyway, although the results will probably be neither useful
266 266 nor desirable.
267 267
268 268 Returns 0 on success.
269 269 """
270 270 if not pats:
271 271 raise util.Abort(_('at least one filename or pattern is required'))
272 272
273 273 if opts.get('follow'):
274 274 # --follow is deprecated and now just an alias for -f/--file
275 275 # to mimic the behavior of Mercurial before version 1.5
276 276 opts['file'] = True
277 277
278 278 fm = ui.formatter('annotate', opts)
279 279 datefunc = ui.quiet and util.shortdate or util.datestr
280 280 hexfn = fm.hexfunc
281 281
282 282 opmap = [('user', ' ', lambda x: x[0].user(), ui.shortuser),
283 283 ('number', ' ', lambda x: x[0].rev(), str),
284 284 ('changeset', ' ', lambda x: hexfn(x[0].node()), str),
285 285 ('date', ' ', lambda x: x[0].date(), util.cachefunc(datefunc)),
286 286 ('file', ' ', lambda x: x[0].path(), str),
287 287 ('line_number', ':', lambda x: x[1], str),
288 288 ]
289 289 fieldnamemap = {'number': 'rev', 'changeset': 'node'}
290 290
291 291 if (not opts.get('user') and not opts.get('changeset')
292 292 and not opts.get('date') and not opts.get('file')):
293 293 opts['number'] = True
294 294
295 295 linenumber = opts.get('line_number') is not None
296 296 if linenumber and (not opts.get('changeset')) and (not opts.get('number')):
297 297 raise util.Abort(_('at least one of -n/-c is required for -l'))
298 298
299 299 if fm:
300 300 def makefunc(get, fmt):
301 301 return get
302 302 else:
303 303 def makefunc(get, fmt):
304 304 return lambda x: fmt(get(x))
305 305 funcmap = [(makefunc(get, fmt), sep) for op, sep, get, fmt in opmap
306 306 if opts.get(op)]
307 307 funcmap[0] = (funcmap[0][0], '') # no separator in front of first column
308 308 fields = ' '.join(fieldnamemap.get(op, op) for op, sep, get, fmt in opmap
309 309 if opts.get(op))
310 310
311 311 def bad(x, y):
312 312 raise util.Abort("%s: %s" % (x, y))
313 313
314 314 ctx = scmutil.revsingle(repo, opts.get('rev'))
315 315 m = scmutil.match(ctx, pats, opts)
316 316 m.bad = bad
317 317 follow = not opts.get('no_follow')
318 318 diffopts = patch.diffopts(ui, opts, section='annotate')
319 319 for abs in ctx.walk(m):
320 320 fctx = ctx[abs]
321 321 if not opts.get('text') and util.binary(fctx.data()):
322 322 fm.plain(_("%s: binary file\n") % ((pats and m.rel(abs)) or abs))
323 323 continue
324 324
325 325 lines = fctx.annotate(follow=follow, linenumber=linenumber,
326 326 diffopts=diffopts)
327 327 formats = []
328 328 pieces = []
329 329
330 330 for f, sep in funcmap:
331 331 l = [f(n) for n, dummy in lines]
332 332 if l:
333 333 if fm:
334 334 formats.append(['%s' for x in l])
335 335 else:
336 336 sizes = [encoding.colwidth(x) for x in l]
337 337 ml = max(sizes)
338 338 formats.append([sep + ' ' * (ml - w) + '%s' for w in sizes])
339 339 pieces.append(l)
340 340
341 341 for f, p, l in zip(zip(*formats), zip(*pieces), lines):
342 342 fm.startitem()
343 343 fm.write(fields, "".join(f), *p)
344 344 fm.write('line', ": %s", l[1])
345 345
346 346 if lines and not lines[-1][1].endswith('\n'):
347 347 fm.plain('\n')
348 348
349 349 fm.end()
350 350
351 351 @command('archive',
352 352 [('', 'no-decode', None, _('do not pass files through decoders')),
353 353 ('p', 'prefix', '', _('directory prefix for files in archive'),
354 354 _('PREFIX')),
355 355 ('r', 'rev', '', _('revision to distribute'), _('REV')),
356 356 ('t', 'type', '', _('type of distribution to create'), _('TYPE')),
357 357 ] + subrepoopts + walkopts,
358 358 _('[OPTION]... DEST'))
359 359 def archive(ui, repo, dest, **opts):
360 360 '''create an unversioned archive of a repository revision
361 361
362 362 By default, the revision used is the parent of the working
363 363 directory; use -r/--rev to specify a different revision.
364 364
365 365 The archive type is automatically detected based on file
366 366 extension (or override using -t/--type).
367 367
368 368 .. container:: verbose
369 369
370 370 Examples:
371 371
372 372 - create a zip file containing the 1.0 release::
373 373
374 374 hg archive -r 1.0 project-1.0.zip
375 375
376 376 - create a tarball excluding .hg files::
377 377
378 378 hg archive project.tar.gz -X ".hg*"
379 379
380 380 Valid types are:
381 381
382 382 :``files``: a directory full of files (default)
383 383 :``tar``: tar archive, uncompressed
384 384 :``tbz2``: tar archive, compressed using bzip2
385 385 :``tgz``: tar archive, compressed using gzip
386 386 :``uzip``: zip archive, uncompressed
387 387 :``zip``: zip archive, compressed using deflate
388 388
389 389 The exact name of the destination archive or directory is given
390 390 using a format string; see :hg:`help export` for details.
391 391
392 392 Each member added to an archive file has a directory prefix
393 393 prepended. Use -p/--prefix to specify a format string for the
394 394 prefix. The default is the basename of the archive, with suffixes
395 395 removed.
396 396
397 397 Returns 0 on success.
398 398 '''
399 399
400 400 ctx = scmutil.revsingle(repo, opts.get('rev'))
401 401 if not ctx:
402 402 raise util.Abort(_('no working directory: please specify a revision'))
403 403 node = ctx.node()
404 404 dest = cmdutil.makefilename(repo, dest, node)
405 405 if os.path.realpath(dest) == repo.root:
406 406 raise util.Abort(_('repository root cannot be destination'))
407 407
408 408 kind = opts.get('type') or archival.guesskind(dest) or 'files'
409 409 prefix = opts.get('prefix')
410 410
411 411 if dest == '-':
412 412 if kind == 'files':
413 413 raise util.Abort(_('cannot archive plain files to stdout'))
414 414 dest = cmdutil.makefileobj(repo, dest)
415 415 if not prefix:
416 416 prefix = os.path.basename(repo.root) + '-%h'
417 417
418 418 prefix = cmdutil.makefilename(repo, prefix, node)
419 419 matchfn = scmutil.match(ctx, [], opts)
420 420 archival.archive(repo, dest, node, kind, not opts.get('no_decode'),
421 421 matchfn, prefix, subrepos=opts.get('subrepos'))
422 422
423 423 @command('backout',
424 424 [('', 'merge', None, _('merge with old dirstate parent after backout')),
425 425 ('', 'parent', '',
426 426 _('parent to choose when backing out merge (DEPRECATED)'), _('REV')),
427 427 ('r', 'rev', '', _('revision to backout'), _('REV')),
428 428 ('e', 'edit', False, _('invoke editor on commit messages')),
429 429 ] + mergetoolopts + walkopts + commitopts + commitopts2,
430 430 _('[OPTION]... [-r] REV'))
431 431 def backout(ui, repo, node=None, rev=None, **opts):
432 432 '''reverse effect of earlier changeset
433 433
434 434 Prepare a new changeset with the effect of REV undone in the
435 435 current working directory.
436 436
437 437 If REV is the parent of the working directory, then this new changeset
438 438 is committed automatically. Otherwise, hg needs to merge the
439 439 changes and the merged result is left uncommitted.
440 440
441 441 .. note::
442 442
443 443 backout cannot be used to fix either an unwanted or
444 444 incorrect merge.
445 445
446 446 .. container:: verbose
447 447
448 448 By default, the pending changeset will have one parent,
449 449 maintaining a linear history. With --merge, the pending
450 450 changeset will instead have two parents: the old parent of the
451 451 working directory and a new child of REV that simply undoes REV.
452 452
453 453 Before version 1.7, the behavior without --merge was equivalent
454 454 to specifying --merge followed by :hg:`update --clean .` to
455 455 cancel the merge and leave the child of REV as a head to be
456 456 merged separately.
457 457
458 458 See :hg:`help dates` for a list of formats valid for -d/--date.
459 459
460 460 Returns 0 on success, 1 if nothing to backout or there are unresolved
461 461 files.
462 462 '''
463 463 if rev and node:
464 464 raise util.Abort(_("please specify just one revision"))
465 465
466 466 if not rev:
467 467 rev = node
468 468
469 469 if not rev:
470 470 raise util.Abort(_("please specify a revision to backout"))
471 471
472 472 date = opts.get('date')
473 473 if date:
474 474 opts['date'] = util.parsedate(date)
475 475
476 476 cmdutil.checkunfinished(repo)
477 477 cmdutil.bailifchanged(repo)
478 478 node = scmutil.revsingle(repo, rev).node()
479 479
480 480 op1, op2 = repo.dirstate.parents()
481 481 if not repo.changelog.isancestor(node, op1):
482 482 raise util.Abort(_('cannot backout change that is not an ancestor'))
483 483
484 484 p1, p2 = repo.changelog.parents(node)
485 485 if p1 == nullid:
486 486 raise util.Abort(_('cannot backout a change with no parents'))
487 487 if p2 != nullid:
488 488 if not opts.get('parent'):
489 489 raise util.Abort(_('cannot backout a merge changeset'))
490 490 p = repo.lookup(opts['parent'])
491 491 if p not in (p1, p2):
492 492 raise util.Abort(_('%s is not a parent of %s') %
493 493 (short(p), short(node)))
494 494 parent = p
495 495 else:
496 496 if opts.get('parent'):
497 497 raise util.Abort(_('cannot use --parent on non-merge changeset'))
498 498 parent = p1
499 499
500 500 # the backout should appear on the same branch
501 501 wlock = repo.wlock()
502 502 try:
503 503 branch = repo.dirstate.branch()
504 504 bheads = repo.branchheads(branch)
505 505 rctx = scmutil.revsingle(repo, hex(parent))
506 506 if not opts.get('merge') and op1 != node:
507 507 try:
508 508 ui.setconfig('ui', 'forcemerge', opts.get('tool', ''),
509 509 'backout')
510 510 repo.dirstate.beginparentchange()
511 511 stats = mergemod.update(repo, parent, True, True, False,
512 512 node, False)
513 513 repo.setparents(op1, op2)
514 514 repo.dirstate.endparentchange()
515 515 hg._showstats(repo, stats)
516 516 if stats[3]:
517 517 repo.ui.status(_("use 'hg resolve' to retry unresolved "
518 518 "file merges\n"))
519 519 else:
520 520 msg = _("changeset %s backed out, "
521 521 "don't forget to commit.\n")
522 522 ui.status(msg % short(node))
523 523 return stats[3] > 0
524 524 finally:
525 525 ui.setconfig('ui', 'forcemerge', '', '')
526 526 else:
527 527 hg.clean(repo, node, show_stats=False)
528 528 repo.dirstate.setbranch(branch)
529 529 cmdutil.revert(ui, repo, rctx, repo.dirstate.parents())
530 530
531 531
532 532 def commitfunc(ui, repo, message, match, opts):
533 533 editform = 'backout'
534 534 e = cmdutil.getcommiteditor(editform=editform, **opts)
535 535 if not message:
536 536 # we don't translate commit messages
537 537 message = "Backed out changeset %s" % short(node)
538 538 e = cmdutil.getcommiteditor(edit=True, editform=editform)
539 539 return repo.commit(message, opts.get('user'), opts.get('date'),
540 540 match, editor=e)
541 541 newnode = cmdutil.commit(ui, repo, commitfunc, [], opts)
542 542 if not newnode:
543 543 ui.status(_("nothing changed\n"))
544 544 return 1
545 545 cmdutil.commitstatus(repo, newnode, branch, bheads)
546 546
547 547 def nice(node):
548 548 return '%d:%s' % (repo.changelog.rev(node), short(node))
549 549 ui.status(_('changeset %s backs out changeset %s\n') %
550 550 (nice(repo.changelog.tip()), nice(node)))
551 551 if opts.get('merge') and op1 != node:
552 552 hg.clean(repo, op1, show_stats=False)
553 553 ui.status(_('merging with changeset %s\n')
554 554 % nice(repo.changelog.tip()))
555 555 try:
556 556 ui.setconfig('ui', 'forcemerge', opts.get('tool', ''),
557 557 'backout')
558 558 return hg.merge(repo, hex(repo.changelog.tip()))
559 559 finally:
560 560 ui.setconfig('ui', 'forcemerge', '', '')
561 561 finally:
562 562 wlock.release()
563 563 return 0
564 564
565 565 @command('bisect',
566 566 [('r', 'reset', False, _('reset bisect state')),
567 567 ('g', 'good', False, _('mark changeset good')),
568 568 ('b', 'bad', False, _('mark changeset bad')),
569 569 ('s', 'skip', False, _('skip testing changeset')),
570 570 ('e', 'extend', False, _('extend the bisect range')),
571 571 ('c', 'command', '', _('use command to check changeset state'), _('CMD')),
572 572 ('U', 'noupdate', False, _('do not update to target'))],
573 573 _("[-gbsr] [-U] [-c CMD] [REV]"))
574 574 def bisect(ui, repo, rev=None, extra=None, command=None,
575 575 reset=None, good=None, bad=None, skip=None, extend=None,
576 576 noupdate=None):
577 577 """subdivision search of changesets
578 578
579 579 This command helps to find changesets which introduce problems. To
580 580 use, mark the earliest changeset you know exhibits the problem as
581 581 bad, then mark the latest changeset which is free from the problem
582 582 as good. Bisect will update your working directory to a revision
583 583 for testing (unless the -U/--noupdate option is specified). Once
584 584 you have performed tests, mark the working directory as good or
585 585 bad, and bisect will either update to another candidate changeset
586 586 or announce that it has found the bad revision.
587 587
588 588 As a shortcut, you can also use the revision argument to mark a
589 589 revision as good or bad without checking it out first.
590 590
591 591 If you supply a command, it will be used for automatic bisection.
592 592 The environment variable HG_NODE will contain the ID of the
593 593 changeset being tested. The exit status of the command will be
594 594 used to mark revisions as good or bad: status 0 means good, 125
595 595 means to skip the revision, 127 (command not found) will abort the
596 596 bisection, and any other non-zero exit status means the revision
597 597 is bad.
598 598
599 599 .. container:: verbose
600 600
601 601 Some examples:
602 602
603 603 - start a bisection with known bad revision 34, and good revision 12::
604 604
605 605 hg bisect --bad 34
606 606 hg bisect --good 12
607 607
608 608 - advance the current bisection by marking current revision as good or
609 609 bad::
610 610
611 611 hg bisect --good
612 612 hg bisect --bad
613 613
614 614 - mark the current revision, or a known revision, to be skipped (e.g. if
615 615 that revision is not usable because of another issue)::
616 616
617 617 hg bisect --skip
618 618 hg bisect --skip 23
619 619
620 620 - skip all revisions that do not touch directories ``foo`` or ``bar``::
621 621
622 622 hg bisect --skip "!( file('path:foo') & file('path:bar') )"
623 623
624 624 - forget the current bisection::
625 625
626 626 hg bisect --reset
627 627
628 628 - use 'make && make tests' to automatically find the first broken
629 629 revision::
630 630
631 631 hg bisect --reset
632 632 hg bisect --bad 34
633 633 hg bisect --good 12
634 634 hg bisect --command "make && make tests"
635 635
636 636 - see all changesets whose states are already known in the current
637 637 bisection::
638 638
639 639 hg log -r "bisect(pruned)"
640 640
641 641 - see the changeset currently being bisected (especially useful
642 642 if running with -U/--noupdate)::
643 643
644 644 hg log -r "bisect(current)"
645 645
646 646 - see all changesets that took part in the current bisection::
647 647
648 648 hg log -r "bisect(range)"
649 649
650 650 - you can even get a nice graph::
651 651
652 652 hg log --graph -r "bisect(range)"
653 653
654 654 See :hg:`help revsets` for more about the `bisect()` keyword.
655 655
656 656 Returns 0 on success.
657 657 """
658 658 def extendbisectrange(nodes, good):
659 659 # bisect is incomplete when it ends on a merge node and
660 660 # one of the parent was not checked.
661 661 parents = repo[nodes[0]].parents()
662 662 if len(parents) > 1:
663 663 side = good and state['bad'] or state['good']
664 664 num = len(set(i.node() for i in parents) & set(side))
665 665 if num == 1:
666 666 return parents[0].ancestor(parents[1])
667 667 return None
668 668
669 669 def print_result(nodes, good):
670 670 displayer = cmdutil.show_changeset(ui, repo, {})
671 671 if len(nodes) == 1:
672 672 # narrowed it down to a single revision
673 673 if good:
674 674 ui.write(_("The first good revision is:\n"))
675 675 else:
676 676 ui.write(_("The first bad revision is:\n"))
677 677 displayer.show(repo[nodes[0]])
678 678 extendnode = extendbisectrange(nodes, good)
679 679 if extendnode is not None:
680 680 ui.write(_('Not all ancestors of this changeset have been'
681 681 ' checked.\nUse bisect --extend to continue the '
682 682 'bisection from\nthe common ancestor, %s.\n')
683 683 % extendnode)
684 684 else:
685 685 # multiple possible revisions
686 686 if good:
687 687 ui.write(_("Due to skipped revisions, the first "
688 688 "good revision could be any of:\n"))
689 689 else:
690 690 ui.write(_("Due to skipped revisions, the first "
691 691 "bad revision could be any of:\n"))
692 692 for n in nodes:
693 693 displayer.show(repo[n])
694 694 displayer.close()
695 695
696 696 def check_state(state, interactive=True):
697 697 if not state['good'] or not state['bad']:
698 698 if (good or bad or skip or reset) and interactive:
699 699 return
700 700 if not state['good']:
701 701 raise util.Abort(_('cannot bisect (no known good revisions)'))
702 702 else:
703 703 raise util.Abort(_('cannot bisect (no known bad revisions)'))
704 704 return True
705 705
706 706 # backward compatibility
707 707 if rev in "good bad reset init".split():
708 708 ui.warn(_("(use of 'hg bisect <cmd>' is deprecated)\n"))
709 709 cmd, rev, extra = rev, extra, None
710 710 if cmd == "good":
711 711 good = True
712 712 elif cmd == "bad":
713 713 bad = True
714 714 else:
715 715 reset = True
716 716 elif extra or good + bad + skip + reset + extend + bool(command) > 1:
717 717 raise util.Abort(_('incompatible arguments'))
718 718
719 719 cmdutil.checkunfinished(repo)
720 720
721 721 if reset:
722 722 p = repo.join("bisect.state")
723 723 if os.path.exists(p):
724 724 os.unlink(p)
725 725 return
726 726
727 727 state = hbisect.load_state(repo)
728 728
729 729 if command:
730 730 changesets = 1
731 731 if noupdate:
732 732 try:
733 733 node = state['current'][0]
734 734 except LookupError:
735 735 raise util.Abort(_('current bisect revision is unknown - '
736 736 'start a new bisect to fix'))
737 737 else:
738 738 node, p2 = repo.dirstate.parents()
739 739 if p2 != nullid:
740 740 raise util.Abort(_('current bisect revision is a merge'))
741 741 try:
742 742 while changesets:
743 743 # update state
744 744 state['current'] = [node]
745 745 hbisect.save_state(repo, state)
746 746 status = util.system(command,
747 747 environ={'HG_NODE': hex(node)},
748 748 out=ui.fout)
749 749 if status == 125:
750 750 transition = "skip"
751 751 elif status == 0:
752 752 transition = "good"
753 753 # status < 0 means process was killed
754 754 elif status == 127:
755 755 raise util.Abort(_("failed to execute %s") % command)
756 756 elif status < 0:
757 757 raise util.Abort(_("%s killed") % command)
758 758 else:
759 759 transition = "bad"
760 760 ctx = scmutil.revsingle(repo, rev, node)
761 761 rev = None # clear for future iterations
762 762 state[transition].append(ctx.node())
763 763 ui.status(_('changeset %d:%s: %s\n') % (ctx, ctx, transition))
764 764 check_state(state, interactive=False)
765 765 # bisect
766 766 nodes, changesets, bgood = hbisect.bisect(repo.changelog, state)
767 767 # update to next check
768 768 node = nodes[0]
769 769 if not noupdate:
770 770 cmdutil.bailifchanged(repo)
771 771 hg.clean(repo, node, show_stats=False)
772 772 finally:
773 773 state['current'] = [node]
774 774 hbisect.save_state(repo, state)
775 775 print_result(nodes, bgood)
776 776 return
777 777
778 778 # update state
779 779
780 780 if rev:
781 781 nodes = [repo.lookup(i) for i in scmutil.revrange(repo, [rev])]
782 782 else:
783 783 nodes = [repo.lookup('.')]
784 784
785 785 if good or bad or skip:
786 786 if good:
787 787 state['good'] += nodes
788 788 elif bad:
789 789 state['bad'] += nodes
790 790 elif skip:
791 791 state['skip'] += nodes
792 792 hbisect.save_state(repo, state)
793 793
794 794 if not check_state(state):
795 795 return
796 796
797 797 # actually bisect
798 798 nodes, changesets, good = hbisect.bisect(repo.changelog, state)
799 799 if extend:
800 800 if not changesets:
801 801 extendnode = extendbisectrange(nodes, good)
802 802 if extendnode is not None:
803 803 ui.write(_("Extending search to changeset %d:%s\n")
804 804 % (extendnode.rev(), extendnode))
805 805 state['current'] = [extendnode.node()]
806 806 hbisect.save_state(repo, state)
807 807 if noupdate:
808 808 return
809 809 cmdutil.bailifchanged(repo)
810 810 return hg.clean(repo, extendnode.node())
811 811 raise util.Abort(_("nothing to extend"))
812 812
813 813 if changesets == 0:
814 814 print_result(nodes, good)
815 815 else:
816 816 assert len(nodes) == 1 # only a single node can be tested next
817 817 node = nodes[0]
818 818 # compute the approximate number of remaining tests
819 819 tests, size = 0, 2
820 820 while size <= changesets:
821 821 tests, size = tests + 1, size * 2
822 822 rev = repo.changelog.rev(node)
823 823 ui.write(_("Testing changeset %d:%s "
824 824 "(%d changesets remaining, ~%d tests)\n")
825 825 % (rev, short(node), changesets, tests))
826 826 state['current'] = [node]
827 827 hbisect.save_state(repo, state)
828 828 if not noupdate:
829 829 cmdutil.bailifchanged(repo)
830 830 return hg.clean(repo, node)
831 831
832 832 @command('bookmarks|bookmark',
833 833 [('f', 'force', False, _('force')),
834 834 ('r', 'rev', '', _('revision'), _('REV')),
835 835 ('d', 'delete', False, _('delete a given bookmark')),
836 836 ('m', 'rename', '', _('rename a given bookmark'), _('NAME')),
837 837 ('i', 'inactive', False, _('mark a bookmark inactive')),
838 838 ] + formatteropts,
839 839 _('hg bookmarks [OPTIONS]... [NAME]...'))
840 840 def bookmark(ui, repo, *names, **opts):
841 841 '''create a new bookmark or list existing bookmarks
842 842
843 843 Bookmarks are labels on changesets to help track lines of development.
844 844 Bookmarks are unversioned and can be moved, renamed and deleted.
845 845 Deleting or moving a bookmark has no effect on the associated changesets.
846 846
847 847 Creating or updating to a bookmark causes it to be marked as 'active'.
848 848 The active bookmark is indicated with a '*'.
849 849 When a commit is made, the active bookmark will advance to the new commit.
850 850 A plain :hg:`update` will also advance an active bookmark, if possible.
851 851 Updating away from a bookmark will cause it to be deactivated.
852 852
853 853 Bookmarks can be pushed and pulled between repositories (see
854 854 :hg:`help push` and :hg:`help pull`). If a shared bookmark has
855 855 diverged, a new 'divergent bookmark' of the form 'name@path' will
856 856 be created. Using :hg:`merge` will resolve the divergence.
857 857
858 858 A bookmark named '@' has the special property that :hg:`clone` will
859 859 check it out by default if it exists.
860 860
861 861 .. container:: verbose
862 862
863 863 Examples:
864 864
865 865 - create an active bookmark for a new line of development::
866 866
867 867 hg book new-feature
868 868
869 869 - create an inactive bookmark as a place marker::
870 870
871 871 hg book -i reviewed
872 872
873 873 - create an inactive bookmark on another changeset::
874 874
875 875 hg book -r .^ tested
876 876
877 877 - move the '@' bookmark from another branch::
878 878
879 879 hg book -f @
880 880 '''
881 881 force = opts.get('force')
882 882 rev = opts.get('rev')
883 883 delete = opts.get('delete')
884 884 rename = opts.get('rename')
885 885 inactive = opts.get('inactive')
886 886
887 887 def checkformat(mark):
888 888 mark = mark.strip()
889 889 if not mark:
890 890 raise util.Abort(_("bookmark names cannot consist entirely of "
891 891 "whitespace"))
892 892 scmutil.checknewlabel(repo, mark, 'bookmark')
893 893 return mark
894 894
895 895 def checkconflict(repo, mark, cur, force=False, target=None):
896 896 if mark in marks and not force:
897 897 if target:
898 898 if marks[mark] == target and target == cur:
899 899 # re-activating a bookmark
900 900 return
901 901 anc = repo.changelog.ancestors([repo[target].rev()])
902 902 bmctx = repo[marks[mark]]
903 903 divs = [repo[b].node() for b in marks
904 904 if b.split('@', 1)[0] == mark.split('@', 1)[0]]
905 905
906 906 # allow resolving a single divergent bookmark even if moving
907 907 # the bookmark across branches when a revision is specified
908 908 # that contains a divergent bookmark
909 909 if bmctx.rev() not in anc and target in divs:
910 910 bookmarks.deletedivergent(repo, [target], mark)
911 911 return
912 912
913 913 deletefrom = [b for b in divs
914 914 if repo[b].rev() in anc or b == target]
915 915 bookmarks.deletedivergent(repo, deletefrom, mark)
916 916 if bookmarks.validdest(repo, bmctx, repo[target]):
917 917 ui.status(_("moving bookmark '%s' forward from %s\n") %
918 918 (mark, short(bmctx.node())))
919 919 return
920 920 raise util.Abort(_("bookmark '%s' already exists "
921 921 "(use -f to force)") % mark)
922 922 if ((mark in repo.branchmap() or mark == repo.dirstate.branch())
923 923 and not force):
924 924 raise util.Abort(
925 925 _("a bookmark cannot have the name of an existing branch"))
926 926
927 927 if delete and rename:
928 928 raise util.Abort(_("--delete and --rename are incompatible"))
929 929 if delete and rev:
930 930 raise util.Abort(_("--rev is incompatible with --delete"))
931 931 if rename and rev:
932 932 raise util.Abort(_("--rev is incompatible with --rename"))
933 933 if not names and (delete or rev):
934 934 raise util.Abort(_("bookmark name required"))
935 935
936 936 if delete or rename or names or inactive:
937 937 wlock = repo.wlock()
938 938 try:
939 939 cur = repo.changectx('.').node()
940 940 marks = repo._bookmarks
941 941 if delete:
942 942 for mark in names:
943 943 if mark not in marks:
944 944 raise util.Abort(_("bookmark '%s' does not exist") %
945 945 mark)
946 946 if mark == repo._bookmarkcurrent:
947 947 bookmarks.unsetcurrent(repo)
948 948 del marks[mark]
949 949 marks.write()
950 950
951 951 elif rename:
952 952 if not names:
953 953 raise util.Abort(_("new bookmark name required"))
954 954 elif len(names) > 1:
955 955 raise util.Abort(_("only one new bookmark name allowed"))
956 956 mark = checkformat(names[0])
957 957 if rename not in marks:
958 958 raise util.Abort(_("bookmark '%s' does not exist") % rename)
959 959 checkconflict(repo, mark, cur, force)
960 960 marks[mark] = marks[rename]
961 961 if repo._bookmarkcurrent == rename and not inactive:
962 962 bookmarks.setcurrent(repo, mark)
963 963 del marks[rename]
964 964 marks.write()
965 965
966 966 elif names:
967 967 newact = None
968 968 for mark in names:
969 969 mark = checkformat(mark)
970 970 if newact is None:
971 971 newact = mark
972 972 if inactive and mark == repo._bookmarkcurrent:
973 973 bookmarks.unsetcurrent(repo)
974 974 return
975 975 tgt = cur
976 976 if rev:
977 977 tgt = scmutil.revsingle(repo, rev).node()
978 978 checkconflict(repo, mark, cur, force, tgt)
979 979 marks[mark] = tgt
980 980 if not inactive and cur == marks[newact] and not rev:
981 981 bookmarks.setcurrent(repo, newact)
982 982 elif cur != tgt and newact == repo._bookmarkcurrent:
983 983 bookmarks.unsetcurrent(repo)
984 984 marks.write()
985 985
986 986 elif inactive:
987 987 if len(marks) == 0:
988 988 ui.status(_("no bookmarks set\n"))
989 989 elif not repo._bookmarkcurrent:
990 990 ui.status(_("no active bookmark\n"))
991 991 else:
992 992 bookmarks.unsetcurrent(repo)
993 993 finally:
994 994 wlock.release()
995 995 else: # show bookmarks
996 996 fm = ui.formatter('bookmarks', opts)
997 997 hexfn = fm.hexfunc
998 998 marks = repo._bookmarks
999 999 if len(marks) == 0 and not fm:
1000 1000 ui.status(_("no bookmarks set\n"))
1001 1001 for bmark, n in sorted(marks.iteritems()):
1002 1002 current = repo._bookmarkcurrent
1003 1003 if bmark == current:
1004 1004 prefix, label = '*', 'bookmarks.current'
1005 1005 else:
1006 1006 prefix, label = ' ', ''
1007 1007
1008 1008 fm.startitem()
1009 1009 if not ui.quiet:
1010 1010 fm.plain(' %s ' % prefix, label=label)
1011 1011 fm.write('bookmark', '%s', bmark, label=label)
1012 1012 pad = " " * (25 - encoding.colwidth(bmark))
1013 1013 fm.condwrite(not ui.quiet, 'rev node', pad + ' %d:%s',
1014 1014 repo.changelog.rev(n), hexfn(n), label=label)
1015 1015 fm.data(active=(bmark == current))
1016 1016 fm.plain('\n')
1017 1017 fm.end()
1018 1018
1019 1019 @command('branch',
1020 1020 [('f', 'force', None,
1021 1021 _('set branch name even if it shadows an existing branch')),
1022 1022 ('C', 'clean', None, _('reset branch name to parent branch name'))],
1023 1023 _('[-fC] [NAME]'))
1024 1024 def branch(ui, repo, label=None, **opts):
1025 1025 """set or show the current branch name
1026 1026
1027 1027 .. note::
1028 1028
1029 1029 Branch names are permanent and global. Use :hg:`bookmark` to create a
1030 1030 light-weight bookmark instead. See :hg:`help glossary` for more
1031 1031 information about named branches and bookmarks.
1032 1032
1033 1033 With no argument, show the current branch name. With one argument,
1034 1034 set the working directory branch name (the branch will not exist
1035 1035 in the repository until the next commit). Standard practice
1036 1036 recommends that primary development take place on the 'default'
1037 1037 branch.
1038 1038
1039 1039 Unless -f/--force is specified, branch will not let you set a
1040 1040 branch name that already exists, even if it's inactive.
1041 1041
1042 1042 Use -C/--clean to reset the working directory branch to that of
1043 1043 the parent of the working directory, negating a previous branch
1044 1044 change.
1045 1045
1046 1046 Use the command :hg:`update` to switch to an existing branch. Use
1047 1047 :hg:`commit --close-branch` to mark this branch as closed.
1048 1048
1049 1049 Returns 0 on success.
1050 1050 """
1051 1051 if label:
1052 1052 label = label.strip()
1053 1053
1054 1054 if not opts.get('clean') and not label:
1055 1055 ui.write("%s\n" % repo.dirstate.branch())
1056 1056 return
1057 1057
1058 1058 wlock = repo.wlock()
1059 1059 try:
1060 1060 if opts.get('clean'):
1061 1061 label = repo[None].p1().branch()
1062 1062 repo.dirstate.setbranch(label)
1063 1063 ui.status(_('reset working directory to branch %s\n') % label)
1064 1064 elif label:
1065 1065 if not opts.get('force') and label in repo.branchmap():
1066 1066 if label not in [p.branch() for p in repo.parents()]:
1067 1067 raise util.Abort(_('a branch of the same name already'
1068 1068 ' exists'),
1069 1069 # i18n: "it" refers to an existing branch
1070 1070 hint=_("use 'hg update' to switch to it"))
1071 1071 scmutil.checknewlabel(repo, label, 'branch')
1072 1072 repo.dirstate.setbranch(label)
1073 1073 ui.status(_('marked working directory as branch %s\n') % label)
1074 1074 ui.status(_('(branches are permanent and global, '
1075 1075 'did you want a bookmark?)\n'))
1076 1076 finally:
1077 1077 wlock.release()
1078 1078
1079 1079 @command('branches',
1080 1080 [('a', 'active', False, _('show only branches that have unmerged heads')),
1081 1081 ('c', 'closed', False, _('show normal and closed branches')),
1082 1082 ] + formatteropts,
1083 1083 _('[-ac]'))
1084 1084 def branches(ui, repo, active=False, closed=False, **opts):
1085 1085 """list repository named branches
1086 1086
1087 1087 List the repository's named branches, indicating which ones are
1088 1088 inactive. If -c/--closed is specified, also list branches which have
1089 1089 been marked closed (see :hg:`commit --close-branch`).
1090 1090
1091 1091 If -a/--active is specified, only show active branches. A branch
1092 1092 is considered active if it contains repository heads.
1093 1093
1094 1094 Use the command :hg:`update` to switch to an existing branch.
1095 1095
1096 1096 Returns 0.
1097 1097 """
1098 1098
1099 1099 fm = ui.formatter('branches', opts)
1100 1100 hexfunc = fm.hexfunc
1101 1101
1102 1102 allheads = set(repo.heads())
1103 1103 branches = []
1104 1104 for tag, heads, tip, isclosed in repo.branchmap().iterbranches():
1105 1105 isactive = not isclosed and bool(set(heads) & allheads)
1106 1106 branches.append((tag, repo[tip], isactive, not isclosed))
1107 1107 branches.sort(key=lambda i: (i[2], i[1].rev(), i[0], i[3]),
1108 1108 reverse=True)
1109 1109
1110 1110 for tag, ctx, isactive, isopen in branches:
1111 1111 if active and not isactive:
1112 1112 continue
1113 1113 if isactive:
1114 1114 label = 'branches.active'
1115 1115 notice = ''
1116 1116 elif not isopen:
1117 1117 if not closed:
1118 1118 continue
1119 1119 label = 'branches.closed'
1120 1120 notice = _(' (closed)')
1121 1121 else:
1122 1122 label = 'branches.inactive'
1123 1123 notice = _(' (inactive)')
1124 1124 current = (tag == repo.dirstate.branch())
1125 1125 if current:
1126 1126 label = 'branches.current'
1127 1127
1128 1128 fm.startitem()
1129 1129 fm.write('branch', '%s', tag, label=label)
1130 1130 rev = ctx.rev()
1131 1131 padsize = max(31 - len(str(rev)) - encoding.colwidth(tag), 0)
1132 1132 fmt = ' ' * padsize + ' %d:%s'
1133 1133 fm.condwrite(not ui.quiet, 'rev node', fmt, rev, hexfunc(ctx.node()),
1134 1134 label='log.changeset changeset.%s' % ctx.phasestr())
1135 1135 fm.data(active=isactive, closed=not isopen, current=current)
1136 1136 if not ui.quiet:
1137 1137 fm.plain(notice)
1138 1138 fm.plain('\n')
1139 1139 fm.end()
1140 1140
1141 1141 @command('bundle',
1142 1142 [('f', 'force', None, _('run even when the destination is unrelated')),
1143 1143 ('r', 'rev', [], _('a changeset intended to be added to the destination'),
1144 1144 _('REV')),
1145 1145 ('b', 'branch', [], _('a specific branch you would like to bundle'),
1146 1146 _('BRANCH')),
1147 1147 ('', 'base', [],
1148 1148 _('a base changeset assumed to be available at the destination'),
1149 1149 _('REV')),
1150 1150 ('a', 'all', None, _('bundle all changesets in the repository')),
1151 1151 ('t', 'type', 'bzip2', _('bundle compression type to use'), _('TYPE')),
1152 1152 ] + remoteopts,
1153 1153 _('[-f] [-t TYPE] [-a] [-r REV]... [--base REV]... FILE [DEST]'))
1154 1154 def bundle(ui, repo, fname, dest=None, **opts):
1155 1155 """create a changegroup file
1156 1156
1157 1157 Generate a compressed changegroup file collecting changesets not
1158 1158 known to be in another repository.
1159 1159
1160 1160 If you omit the destination repository, then hg assumes the
1161 1161 destination will have all the nodes you specify with --base
1162 1162 parameters. To create a bundle containing all changesets, use
1163 1163 -a/--all (or --base null).
1164 1164
1165 1165 You can change compression method with the -t/--type option.
1166 1166 The available compression methods are: none, bzip2, and
1167 1167 gzip (by default, bundles are compressed using bzip2).
1168 1168
1169 1169 The bundle file can then be transferred using conventional means
1170 1170 and applied to another repository with the unbundle or pull
1171 1171 command. This is useful when direct push and pull are not
1172 1172 available or when exporting an entire repository is undesirable.
1173 1173
1174 1174 Applying bundles preserves all changeset contents including
1175 1175 permissions, copy/rename information, and revision history.
1176 1176
1177 1177 Returns 0 on success, 1 if no changes found.
1178 1178 """
1179 1179 revs = None
1180 1180 if 'rev' in opts:
1181 1181 revs = scmutil.revrange(repo, opts['rev'])
1182 1182
1183 1183 bundletype = opts.get('type', 'bzip2').lower()
1184 1184 btypes = {'none': 'HG10UN', 'bzip2': 'HG10BZ', 'gzip': 'HG10GZ'}
1185 1185 bundletype = btypes.get(bundletype)
1186 1186 if bundletype not in changegroup.bundletypes:
1187 1187 raise util.Abort(_('unknown bundle type specified with --type'))
1188 1188
1189 1189 if opts.get('all'):
1190 1190 base = ['null']
1191 1191 else:
1192 1192 base = scmutil.revrange(repo, opts.get('base'))
1193 1193 # TODO: get desired bundlecaps from command line.
1194 1194 bundlecaps = None
1195 1195 if base:
1196 1196 if dest:
1197 1197 raise util.Abort(_("--base is incompatible with specifying "
1198 1198 "a destination"))
1199 1199 common = [repo.lookup(rev) for rev in base]
1200 1200 heads = revs and map(repo.lookup, revs) or revs
1201 1201 cg = changegroup.getchangegroup(repo, 'bundle', heads=heads,
1202 1202 common=common, bundlecaps=bundlecaps)
1203 1203 outgoing = None
1204 1204 else:
1205 1205 dest = ui.expandpath(dest or 'default-push', dest or 'default')
1206 1206 dest, branches = hg.parseurl(dest, opts.get('branch'))
1207 1207 other = hg.peer(repo, opts, dest)
1208 1208 revs, checkout = hg.addbranchrevs(repo, repo, branches, revs)
1209 1209 heads = revs and map(repo.lookup, revs) or revs
1210 1210 outgoing = discovery.findcommonoutgoing(repo, other,
1211 1211 onlyheads=heads,
1212 1212 force=opts.get('force'),
1213 1213 portable=True)
1214 1214 cg = changegroup.getlocalchangegroup(repo, 'bundle', outgoing,
1215 1215 bundlecaps)
1216 1216 if not cg:
1217 1217 scmutil.nochangesfound(ui, repo, outgoing and outgoing.excluded)
1218 1218 return 1
1219 1219
1220 1220 changegroup.writebundle(cg, fname, bundletype)
1221 1221
1222 1222 @command('cat',
1223 1223 [('o', 'output', '',
1224 1224 _('print output to file with formatted name'), _('FORMAT')),
1225 1225 ('r', 'rev', '', _('print the given revision'), _('REV')),
1226 1226 ('', 'decode', None, _('apply any matching decode filter')),
1227 1227 ] + walkopts,
1228 1228 _('[OPTION]... FILE...'),
1229 1229 inferrepo=True)
1230 1230 def cat(ui, repo, file1, *pats, **opts):
1231 1231 """output the current or given revision of files
1232 1232
1233 1233 Print the specified files as they were at the given revision. If
1234 1234 no revision is given, the parent of the working directory is used.
1235 1235
1236 1236 Output may be to a file, in which case the name of the file is
1237 1237 given using a format string. The formatting rules as follows:
1238 1238
1239 1239 :``%%``: literal "%" character
1240 1240 :``%s``: basename of file being printed
1241 1241 :``%d``: dirname of file being printed, or '.' if in repository root
1242 1242 :``%p``: root-relative path name of file being printed
1243 1243 :``%H``: changeset hash (40 hexadecimal digits)
1244 1244 :``%R``: changeset revision number
1245 1245 :``%h``: short-form changeset hash (12 hexadecimal digits)
1246 1246 :``%r``: zero-padded changeset revision number
1247 1247 :``%b``: basename of the exporting repository
1248 1248
1249 1249 Returns 0 on success.
1250 1250 """
1251 1251 ctx = scmutil.revsingle(repo, opts.get('rev'))
1252 1252 m = scmutil.match(ctx, (file1,) + pats, opts)
1253 1253
1254 1254 return cmdutil.cat(ui, repo, ctx, m, '', **opts)
1255 1255
1256 1256 @command('^clone',
1257 1257 [('U', 'noupdate', None,
1258 1258 _('the clone will include an empty working copy (only a repository)')),
1259 1259 ('u', 'updaterev', '', _('revision, tag or branch to check out'), _('REV')),
1260 1260 ('r', 'rev', [], _('include the specified changeset'), _('REV')),
1261 1261 ('b', 'branch', [], _('clone only the specified branch'), _('BRANCH')),
1262 1262 ('', 'pull', None, _('use pull protocol to copy metadata')),
1263 1263 ('', 'uncompressed', None, _('use uncompressed transfer (fast over LAN)')),
1264 1264 ] + remoteopts,
1265 1265 _('[OPTION]... SOURCE [DEST]'),
1266 1266 norepo=True)
1267 1267 def clone(ui, source, dest=None, **opts):
1268 1268 """make a copy of an existing repository
1269 1269
1270 1270 Create a copy of an existing repository in a new directory.
1271 1271
1272 1272 If no destination directory name is specified, it defaults to the
1273 1273 basename of the source.
1274 1274
1275 1275 The location of the source is added to the new repository's
1276 1276 ``.hg/hgrc`` file, as the default to be used for future pulls.
1277 1277
1278 1278 Only local paths and ``ssh://`` URLs are supported as
1279 1279 destinations. For ``ssh://`` destinations, no working directory or
1280 1280 ``.hg/hgrc`` will be created on the remote side.
1281 1281
1282 1282 To pull only a subset of changesets, specify one or more revisions
1283 1283 identifiers with -r/--rev or branches with -b/--branch. The
1284 1284 resulting clone will contain only the specified changesets and
1285 1285 their ancestors. These options (or 'clone src#rev dest') imply
1286 1286 --pull, even for local source repositories. Note that specifying a
1287 1287 tag will include the tagged changeset but not the changeset
1288 1288 containing the tag.
1289 1289
1290 1290 If the source repository has a bookmark called '@' set, that
1291 1291 revision will be checked out in the new repository by default.
1292 1292
1293 1293 To check out a particular version, use -u/--update, or
1294 1294 -U/--noupdate to create a clone with no working directory.
1295 1295
1296 1296 .. container:: verbose
1297 1297
1298 1298 For efficiency, hardlinks are used for cloning whenever the
1299 1299 source and destination are on the same filesystem (note this
1300 1300 applies only to the repository data, not to the working
1301 1301 directory). Some filesystems, such as AFS, implement hardlinking
1302 1302 incorrectly, but do not report errors. In these cases, use the
1303 1303 --pull option to avoid hardlinking.
1304 1304
1305 1305 In some cases, you can clone repositories and the working
1306 1306 directory using full hardlinks with ::
1307 1307
1308 1308 $ cp -al REPO REPOCLONE
1309 1309
1310 1310 This is the fastest way to clone, but it is not always safe. The
1311 1311 operation is not atomic (making sure REPO is not modified during
1312 1312 the operation is up to you) and you have to make sure your
1313 1313 editor breaks hardlinks (Emacs and most Linux Kernel tools do
1314 1314 so). Also, this is not compatible with certain extensions that
1315 1315 place their metadata under the .hg directory, such as mq.
1316 1316
1317 1317 Mercurial will update the working directory to the first applicable
1318 1318 revision from this list:
1319 1319
1320 1320 a) null if -U or the source repository has no changesets
1321 1321 b) if -u . and the source repository is local, the first parent of
1322 1322 the source repository's working directory
1323 1323 c) the changeset specified with -u (if a branch name, this means the
1324 1324 latest head of that branch)
1325 1325 d) the changeset specified with -r
1326 1326 e) the tipmost head specified with -b
1327 1327 f) the tipmost head specified with the url#branch source syntax
1328 1328 g) the revision marked with the '@' bookmark, if present
1329 1329 h) the tipmost head of the default branch
1330 1330 i) tip
1331 1331
1332 1332 Examples:
1333 1333
1334 1334 - clone a remote repository to a new directory named hg/::
1335 1335
1336 1336 hg clone http://selenic.com/hg
1337 1337
1338 1338 - create a lightweight local clone::
1339 1339
1340 1340 hg clone project/ project-feature/
1341 1341
1342 1342 - clone from an absolute path on an ssh server (note double-slash)::
1343 1343
1344 1344 hg clone ssh://user@server//home/projects/alpha/
1345 1345
1346 1346 - do a high-speed clone over a LAN while checking out a
1347 1347 specified version::
1348 1348
1349 1349 hg clone --uncompressed http://server/repo -u 1.5
1350 1350
1351 1351 - create a repository without changesets after a particular revision::
1352 1352
1353 1353 hg clone -r 04e544 experimental/ good/
1354 1354
1355 1355 - clone (and track) a particular named branch::
1356 1356
1357 1357 hg clone http://selenic.com/hg#stable
1358 1358
1359 1359 See :hg:`help urls` for details on specifying URLs.
1360 1360
1361 1361 Returns 0 on success.
1362 1362 """
1363 1363 if opts.get('noupdate') and opts.get('updaterev'):
1364 1364 raise util.Abort(_("cannot specify both --noupdate and --updaterev"))
1365 1365
1366 1366 r = hg.clone(ui, opts, source, dest,
1367 1367 pull=opts.get('pull'),
1368 1368 stream=opts.get('uncompressed'),
1369 1369 rev=opts.get('rev'),
1370 1370 update=opts.get('updaterev') or not opts.get('noupdate'),
1371 1371 branch=opts.get('branch'))
1372 1372
1373 1373 return r is None
1374 1374
1375 1375 @command('^commit|ci',
1376 1376 [('A', 'addremove', None,
1377 1377 _('mark new/missing files as added/removed before committing')),
1378 1378 ('', 'close-branch', None,
1379 1379 _('mark a branch as closed, hiding it from the branch list')),
1380 1380 ('', 'amend', None, _('amend the parent of the working dir')),
1381 1381 ('s', 'secret', None, _('use the secret phase for committing')),
1382 1382 ('e', 'edit', None, _('invoke editor on commit messages')),
1383 1383 ] + walkopts + commitopts + commitopts2 + subrepoopts,
1384 1384 _('[OPTION]... [FILE]...'),
1385 1385 inferrepo=True)
1386 1386 def commit(ui, repo, *pats, **opts):
1387 1387 """commit the specified files or all outstanding changes
1388 1388
1389 1389 Commit changes to the given files into the repository. Unlike a
1390 1390 centralized SCM, this operation is a local operation. See
1391 1391 :hg:`push` for a way to actively distribute your changes.
1392 1392
1393 1393 If a list of files is omitted, all changes reported by :hg:`status`
1394 1394 will be committed.
1395 1395
1396 1396 If you are committing the result of a merge, do not provide any
1397 1397 filenames or -I/-X filters.
1398 1398
1399 1399 If no commit message is specified, Mercurial starts your
1400 1400 configured editor where you can enter a message. In case your
1401 1401 commit fails, you will find a backup of your message in
1402 1402 ``.hg/last-message.txt``.
1403 1403
1404 1404 The --amend flag can be used to amend the parent of the
1405 1405 working directory with a new commit that contains the changes
1406 1406 in the parent in addition to those currently reported by :hg:`status`,
1407 1407 if there are any. The old commit is stored in a backup bundle in
1408 1408 ``.hg/strip-backup`` (see :hg:`help bundle` and :hg:`help unbundle`
1409 1409 on how to restore it).
1410 1410
1411 1411 Message, user and date are taken from the amended commit unless
1412 1412 specified. When a message isn't specified on the command line,
1413 1413 the editor will open with the message of the amended commit.
1414 1414
1415 1415 It is not possible to amend public changesets (see :hg:`help phases`)
1416 1416 or changesets that have children.
1417 1417
1418 1418 See :hg:`help dates` for a list of formats valid for -d/--date.
1419 1419
1420 1420 Returns 0 on success, 1 if nothing changed.
1421 1421 """
1422 1422 if opts.get('subrepos'):
1423 1423 if opts.get('amend'):
1424 1424 raise util.Abort(_('cannot amend with --subrepos'))
1425 1425 # Let --subrepos on the command line override config setting.
1426 1426 ui.setconfig('ui', 'commitsubrepos', True, 'commit')
1427 1427
1428 1428 cmdutil.checkunfinished(repo, commit=True)
1429 1429
1430 1430 branch = repo[None].branch()
1431 1431 bheads = repo.branchheads(branch)
1432 1432
1433 1433 extra = {}
1434 1434 if opts.get('close_branch'):
1435 1435 extra['close'] = 1
1436 1436
1437 1437 if not bheads:
1438 1438 raise util.Abort(_('can only close branch heads'))
1439 1439 elif opts.get('amend'):
1440 1440 if repo.parents()[0].p1().branch() != branch and \
1441 1441 repo.parents()[0].p2().branch() != branch:
1442 1442 raise util.Abort(_('can only close branch heads'))
1443 1443
1444 1444 if opts.get('amend'):
1445 1445 if ui.configbool('ui', 'commitsubrepos'):
1446 1446 raise util.Abort(_('cannot amend with ui.commitsubrepos enabled'))
1447 1447
1448 1448 old = repo['.']
1449 1449 if not old.mutable():
1450 1450 raise util.Abort(_('cannot amend public changesets'))
1451 1451 if len(repo[None].parents()) > 1:
1452 1452 raise util.Abort(_('cannot amend while merging'))
1453 1453 allowunstable = obsolete.isenabled(repo, obsolete.allowunstableopt)
1454 1454 if not allowunstable and old.children():
1455 1455 raise util.Abort(_('cannot amend changeset with children'))
1456 1456
1457 1457 # commitfunc is used only for temporary amend commit by cmdutil.amend
1458 1458 def commitfunc(ui, repo, message, match, opts):
1459 1459 return repo.commit(message,
1460 1460 opts.get('user') or old.user(),
1461 1461 opts.get('date') or old.date(),
1462 1462 match,
1463 1463 extra=extra)
1464 1464
1465 1465 current = repo._bookmarkcurrent
1466 1466 marks = old.bookmarks()
1467 1467 node = cmdutil.amend(ui, repo, commitfunc, old, extra, pats, opts)
1468 1468 if node == old.node():
1469 1469 ui.status(_("nothing changed\n"))
1470 1470 return 1
1471 1471 elif marks:
1472 1472 ui.debug('moving bookmarks %r from %s to %s\n' %
1473 1473 (marks, old.hex(), hex(node)))
1474 1474 newmarks = repo._bookmarks
1475 1475 for bm in marks:
1476 1476 newmarks[bm] = node
1477 1477 if bm == current:
1478 1478 bookmarks.setcurrent(repo, bm)
1479 1479 newmarks.write()
1480 1480 else:
1481 1481 def commitfunc(ui, repo, message, match, opts):
1482 1482 backup = ui.backupconfig('phases', 'new-commit')
1483 1483 baseui = repo.baseui
1484 1484 basebackup = baseui.backupconfig('phases', 'new-commit')
1485 1485 try:
1486 1486 if opts.get('secret'):
1487 1487 ui.setconfig('phases', 'new-commit', 'secret', 'commit')
1488 1488 # Propagate to subrepos
1489 1489 baseui.setconfig('phases', 'new-commit', 'secret', 'commit')
1490 1490
1491 1491 editform = cmdutil.mergeeditform(repo[None], 'commit.normal')
1492 1492 editor = cmdutil.getcommiteditor(editform=editform, **opts)
1493 1493 return repo.commit(message, opts.get('user'), opts.get('date'),
1494 1494 match,
1495 1495 editor=editor,
1496 1496 extra=extra)
1497 1497 finally:
1498 1498 ui.restoreconfig(backup)
1499 1499 repo.baseui.restoreconfig(basebackup)
1500 1500
1501 1501
1502 1502 node = cmdutil.commit(ui, repo, commitfunc, pats, opts)
1503 1503
1504 1504 if not node:
1505 1505 stat = repo.status(match=scmutil.match(repo[None], pats, opts))
1506 1506 if stat[3]:
1507 1507 ui.status(_("nothing changed (%d missing files, see "
1508 1508 "'hg status')\n") % len(stat[3]))
1509 1509 else:
1510 1510 ui.status(_("nothing changed\n"))
1511 1511 return 1
1512 1512
1513 1513 cmdutil.commitstatus(repo, node, branch, bheads, opts)
1514 1514
1515 1515 @command('config|showconfig|debugconfig',
1516 1516 [('u', 'untrusted', None, _('show untrusted configuration options')),
1517 1517 ('e', 'edit', None, _('edit user config')),
1518 1518 ('l', 'local', None, _('edit repository config')),
1519 1519 ('g', 'global', None, _('edit global config'))],
1520 1520 _('[-u] [NAME]...'),
1521 1521 optionalrepo=True)
1522 1522 def config(ui, repo, *values, **opts):
1523 1523 """show combined config settings from all hgrc files
1524 1524
1525 1525 With no arguments, print names and values of all config items.
1526 1526
1527 1527 With one argument of the form section.name, print just the value
1528 1528 of that config item.
1529 1529
1530 1530 With multiple arguments, print names and values of all config
1531 1531 items with matching section names.
1532 1532
1533 1533 With --edit, start an editor on the user-level config file. With
1534 1534 --global, edit the system-wide config file. With --local, edit the
1535 1535 repository-level config file.
1536 1536
1537 1537 With --debug, the source (filename and line number) is printed
1538 1538 for each config item.
1539 1539
1540 1540 See :hg:`help config` for more information about config files.
1541 1541
1542 1542 Returns 0 on success, 1 if NAME does not exist.
1543 1543
1544 1544 """
1545 1545
1546 1546 if opts.get('edit') or opts.get('local') or opts.get('global'):
1547 1547 if opts.get('local') and opts.get('global'):
1548 1548 raise util.Abort(_("can't use --local and --global together"))
1549 1549
1550 1550 if opts.get('local'):
1551 1551 if not repo:
1552 1552 raise util.Abort(_("can't use --local outside a repository"))
1553 1553 paths = [repo.join('hgrc')]
1554 1554 elif opts.get('global'):
1555 1555 paths = scmutil.systemrcpath()
1556 1556 else:
1557 1557 paths = scmutil.userrcpath()
1558 1558
1559 1559 for f in paths:
1560 1560 if os.path.exists(f):
1561 1561 break
1562 1562 else:
1563 1563 if opts.get('global'):
1564 1564 samplehgrc = uimod.samplehgrcs['global']
1565 1565 elif opts.get('local'):
1566 1566 samplehgrc = uimod.samplehgrcs['local']
1567 1567 else:
1568 1568 samplehgrc = uimod.samplehgrcs['user']
1569 1569
1570 1570 f = paths[0]
1571 1571 fp = open(f, "w")
1572 1572 fp.write(samplehgrc)
1573 1573 fp.close()
1574 1574
1575 1575 editor = ui.geteditor()
1576 1576 util.system("%s \"%s\"" % (editor, f),
1577 1577 onerr=util.Abort, errprefix=_("edit failed"),
1578 1578 out=ui.fout)
1579 1579 return
1580 1580
1581 1581 for f in scmutil.rcpath():
1582 1582 ui.debug('read config from: %s\n' % f)
1583 1583 untrusted = bool(opts.get('untrusted'))
1584 1584 if values:
1585 1585 sections = [v for v in values if '.' not in v]
1586 1586 items = [v for v in values if '.' in v]
1587 1587 if len(items) > 1 or items and sections:
1588 1588 raise util.Abort(_('only one config item permitted'))
1589 1589 matched = False
1590 1590 for section, name, value in ui.walkconfig(untrusted=untrusted):
1591 1591 value = str(value).replace('\n', '\\n')
1592 1592 sectname = section + '.' + name
1593 1593 if values:
1594 1594 for v in values:
1595 1595 if v == section:
1596 1596 ui.debug('%s: ' %
1597 1597 ui.configsource(section, name, untrusted))
1598 1598 ui.write('%s=%s\n' % (sectname, value))
1599 1599 matched = True
1600 1600 elif v == sectname:
1601 1601 ui.debug('%s: ' %
1602 1602 ui.configsource(section, name, untrusted))
1603 1603 ui.write(value, '\n')
1604 1604 matched = True
1605 1605 else:
1606 1606 ui.debug('%s: ' %
1607 1607 ui.configsource(section, name, untrusted))
1608 1608 ui.write('%s=%s\n' % (sectname, value))
1609 1609 matched = True
1610 1610 if matched:
1611 1611 return 0
1612 1612 return 1
1613 1613
1614 1614 @command('copy|cp',
1615 1615 [('A', 'after', None, _('record a copy that has already occurred')),
1616 1616 ('f', 'force', None, _('forcibly copy over an existing managed file')),
1617 1617 ] + walkopts + dryrunopts,
1618 1618 _('[OPTION]... [SOURCE]... DEST'))
1619 1619 def copy(ui, repo, *pats, **opts):
1620 1620 """mark files as copied for the next commit
1621 1621
1622 1622 Mark dest as having copies of source files. If dest is a
1623 1623 directory, copies are put in that directory. If dest is a file,
1624 1624 the source must be a single file.
1625 1625
1626 1626 By default, this command copies the contents of files as they
1627 1627 exist in the working directory. If invoked with -A/--after, the
1628 1628 operation is recorded, but no copying is performed.
1629 1629
1630 1630 This command takes effect with the next commit. To undo a copy
1631 1631 before that, see :hg:`revert`.
1632 1632
1633 1633 Returns 0 on success, 1 if errors are encountered.
1634 1634 """
1635 1635 wlock = repo.wlock(False)
1636 1636 try:
1637 1637 return cmdutil.copy(ui, repo, pats, opts)
1638 1638 finally:
1639 1639 wlock.release()
1640 1640
1641 1641 @command('debugancestor', [], _('[INDEX] REV1 REV2'), optionalrepo=True)
1642 1642 def debugancestor(ui, repo, *args):
1643 1643 """find the ancestor revision of two revisions in a given index"""
1644 1644 if len(args) == 3:
1645 1645 index, rev1, rev2 = args
1646 1646 r = revlog.revlog(scmutil.opener(os.getcwd(), audit=False), index)
1647 1647 lookup = r.lookup
1648 1648 elif len(args) == 2:
1649 1649 if not repo:
1650 1650 raise util.Abort(_("there is no Mercurial repository here "
1651 1651 "(.hg not found)"))
1652 1652 rev1, rev2 = args
1653 1653 r = repo.changelog
1654 1654 lookup = repo.lookup
1655 1655 else:
1656 1656 raise util.Abort(_('either two or three arguments required'))
1657 1657 a = r.ancestor(lookup(rev1), lookup(rev2))
1658 1658 ui.write("%d:%s\n" % (r.rev(a), hex(a)))
1659 1659
1660 1660 @command('debugbuilddag',
1661 1661 [('m', 'mergeable-file', None, _('add single file mergeable changes')),
1662 1662 ('o', 'overwritten-file', None, _('add single file all revs overwrite')),
1663 1663 ('n', 'new-file', None, _('add new file at each rev'))],
1664 1664 _('[OPTION]... [TEXT]'))
1665 1665 def debugbuilddag(ui, repo, text=None,
1666 1666 mergeable_file=False,
1667 1667 overwritten_file=False,
1668 1668 new_file=False):
1669 1669 """builds a repo with a given DAG from scratch in the current empty repo
1670 1670
1671 1671 The description of the DAG is read from stdin if not given on the
1672 1672 command line.
1673 1673
1674 1674 Elements:
1675 1675
1676 1676 - "+n" is a linear run of n nodes based on the current default parent
1677 1677 - "." is a single node based on the current default parent
1678 1678 - "$" resets the default parent to null (implied at the start);
1679 1679 otherwise the default parent is always the last node created
1680 1680 - "<p" sets the default parent to the backref p
1681 1681 - "*p" is a fork at parent p, which is a backref
1682 1682 - "*p1/p2" is a merge of parents p1 and p2, which are backrefs
1683 1683 - "/p2" is a merge of the preceding node and p2
1684 1684 - ":tag" defines a local tag for the preceding node
1685 1685 - "@branch" sets the named branch for subsequent nodes
1686 1686 - "#...\\n" is a comment up to the end of the line
1687 1687
1688 1688 Whitespace between the above elements is ignored.
1689 1689
1690 1690 A backref is either
1691 1691
1692 1692 - a number n, which references the node curr-n, where curr is the current
1693 1693 node, or
1694 1694 - the name of a local tag you placed earlier using ":tag", or
1695 1695 - empty to denote the default parent.
1696 1696
1697 1697 All string valued-elements are either strictly alphanumeric, or must
1698 1698 be enclosed in double quotes ("..."), with "\\" as escape character.
1699 1699 """
1700 1700
1701 1701 if text is None:
1702 1702 ui.status(_("reading DAG from stdin\n"))
1703 1703 text = ui.fin.read()
1704 1704
1705 1705 cl = repo.changelog
1706 1706 if len(cl) > 0:
1707 1707 raise util.Abort(_('repository is not empty'))
1708 1708
1709 1709 # determine number of revs in DAG
1710 1710 total = 0
1711 1711 for type, data in dagparser.parsedag(text):
1712 1712 if type == 'n':
1713 1713 total += 1
1714 1714
1715 1715 if mergeable_file:
1716 1716 linesperrev = 2
1717 1717 # make a file with k lines per rev
1718 1718 initialmergedlines = [str(i) for i in xrange(0, total * linesperrev)]
1719 1719 initialmergedlines.append("")
1720 1720
1721 1721 tags = []
1722 1722
1723 1723 lock = tr = None
1724 1724 try:
1725 1725 lock = repo.lock()
1726 1726 tr = repo.transaction("builddag")
1727 1727
1728 1728 at = -1
1729 1729 atbranch = 'default'
1730 1730 nodeids = []
1731 1731 id = 0
1732 1732 ui.progress(_('building'), id, unit=_('revisions'), total=total)
1733 1733 for type, data in dagparser.parsedag(text):
1734 1734 if type == 'n':
1735 1735 ui.note(('node %s\n' % str(data)))
1736 1736 id, ps = data
1737 1737
1738 1738 files = []
1739 1739 fctxs = {}
1740 1740
1741 1741 p2 = None
1742 1742 if mergeable_file:
1743 1743 fn = "mf"
1744 1744 p1 = repo[ps[0]]
1745 1745 if len(ps) > 1:
1746 1746 p2 = repo[ps[1]]
1747 1747 pa = p1.ancestor(p2)
1748 1748 base, local, other = [x[fn].data() for x in (pa, p1,
1749 1749 p2)]
1750 1750 m3 = simplemerge.Merge3Text(base, local, other)
1751 1751 ml = [l.strip() for l in m3.merge_lines()]
1752 1752 ml.append("")
1753 1753 elif at > 0:
1754 1754 ml = p1[fn].data().split("\n")
1755 1755 else:
1756 1756 ml = initialmergedlines
1757 1757 ml[id * linesperrev] += " r%i" % id
1758 1758 mergedtext = "\n".join(ml)
1759 1759 files.append(fn)
1760 1760 fctxs[fn] = context.memfilectx(repo, fn, mergedtext)
1761 1761
1762 1762 if overwritten_file:
1763 1763 fn = "of"
1764 1764 files.append(fn)
1765 1765 fctxs[fn] = context.memfilectx(repo, fn, "r%i\n" % id)
1766 1766
1767 1767 if new_file:
1768 1768 fn = "nf%i" % id
1769 1769 files.append(fn)
1770 1770 fctxs[fn] = context.memfilectx(repo, fn, "r%i\n" % id)
1771 1771 if len(ps) > 1:
1772 1772 if not p2:
1773 1773 p2 = repo[ps[1]]
1774 1774 for fn in p2:
1775 1775 if fn.startswith("nf"):
1776 1776 files.append(fn)
1777 1777 fctxs[fn] = p2[fn]
1778 1778
1779 1779 def fctxfn(repo, cx, path):
1780 1780 return fctxs.get(path)
1781 1781
1782 1782 if len(ps) == 0 or ps[0] < 0:
1783 1783 pars = [None, None]
1784 1784 elif len(ps) == 1:
1785 1785 pars = [nodeids[ps[0]], None]
1786 1786 else:
1787 1787 pars = [nodeids[p] for p in ps]
1788 1788 cx = context.memctx(repo, pars, "r%i" % id, files, fctxfn,
1789 1789 date=(id, 0),
1790 1790 user="debugbuilddag",
1791 1791 extra={'branch': atbranch})
1792 1792 nodeid = repo.commitctx(cx)
1793 1793 nodeids.append(nodeid)
1794 1794 at = id
1795 1795 elif type == 'l':
1796 1796 id, name = data
1797 1797 ui.note(('tag %s\n' % name))
1798 1798 tags.append("%s %s\n" % (hex(repo.changelog.node(id)), name))
1799 1799 elif type == 'a':
1800 1800 ui.note(('branch %s\n' % data))
1801 1801 atbranch = data
1802 1802 ui.progress(_('building'), id, unit=_('revisions'), total=total)
1803 1803 tr.close()
1804 1804
1805 1805 if tags:
1806 1806 repo.opener.write("localtags", "".join(tags))
1807 1807 finally:
1808 1808 ui.progress(_('building'), None)
1809 1809 release(tr, lock)
1810 1810
1811 1811 @command('debugbundle',
1812 1812 [('a', 'all', None, _('show all details'))],
1813 1813 _('FILE'),
1814 1814 norepo=True)
1815 1815 def debugbundle(ui, bundlepath, all=None, **opts):
1816 1816 """lists the contents of a bundle"""
1817 1817 f = hg.openpath(ui, bundlepath)
1818 1818 try:
1819 1819 gen = exchange.readbundle(ui, f, bundlepath)
1820 1820 if all:
1821 1821 ui.write(("format: id, p1, p2, cset, delta base, len(delta)\n"))
1822 1822
1823 1823 def showchunks(named):
1824 1824 ui.write("\n%s\n" % named)
1825 1825 chain = None
1826 1826 while True:
1827 1827 chunkdata = gen.deltachunk(chain)
1828 1828 if not chunkdata:
1829 1829 break
1830 1830 node = chunkdata['node']
1831 1831 p1 = chunkdata['p1']
1832 1832 p2 = chunkdata['p2']
1833 1833 cs = chunkdata['cs']
1834 1834 deltabase = chunkdata['deltabase']
1835 1835 delta = chunkdata['delta']
1836 1836 ui.write("%s %s %s %s %s %s\n" %
1837 1837 (hex(node), hex(p1), hex(p2),
1838 1838 hex(cs), hex(deltabase), len(delta)))
1839 1839 chain = node
1840 1840
1841 1841 chunkdata = gen.changelogheader()
1842 1842 showchunks("changelog")
1843 1843 chunkdata = gen.manifestheader()
1844 1844 showchunks("manifest")
1845 1845 while True:
1846 1846 chunkdata = gen.filelogheader()
1847 1847 if not chunkdata:
1848 1848 break
1849 1849 fname = chunkdata['filename']
1850 1850 showchunks(fname)
1851 1851 else:
1852 1852 chunkdata = gen.changelogheader()
1853 1853 chain = None
1854 1854 while True:
1855 1855 chunkdata = gen.deltachunk(chain)
1856 1856 if not chunkdata:
1857 1857 break
1858 1858 node = chunkdata['node']
1859 1859 ui.write("%s\n" % hex(node))
1860 1860 chain = node
1861 1861 finally:
1862 1862 f.close()
1863 1863
1864 1864 @command('debugcheckstate', [], '')
1865 1865 def debugcheckstate(ui, repo):
1866 1866 """validate the correctness of the current dirstate"""
1867 1867 parent1, parent2 = repo.dirstate.parents()
1868 1868 m1 = repo[parent1].manifest()
1869 1869 m2 = repo[parent2].manifest()
1870 1870 errors = 0
1871 1871 for f in repo.dirstate:
1872 1872 state = repo.dirstate[f]
1873 1873 if state in "nr" and f not in m1:
1874 1874 ui.warn(_("%s in state %s, but not in manifest1\n") % (f, state))
1875 1875 errors += 1
1876 1876 if state in "a" and f in m1:
1877 1877 ui.warn(_("%s in state %s, but also in manifest1\n") % (f, state))
1878 1878 errors += 1
1879 1879 if state in "m" and f not in m1 and f not in m2:
1880 1880 ui.warn(_("%s in state %s, but not in either manifest\n") %
1881 1881 (f, state))
1882 1882 errors += 1
1883 1883 for f in m1:
1884 1884 state = repo.dirstate[f]
1885 1885 if state not in "nrm":
1886 1886 ui.warn(_("%s in manifest1, but listed as state %s") % (f, state))
1887 1887 errors += 1
1888 1888 if errors:
1889 1889 error = _(".hg/dirstate inconsistent with current parent's manifest")
1890 1890 raise util.Abort(error)
1891 1891
1892 1892 @command('debugcommands', [], _('[COMMAND]'), norepo=True)
1893 1893 def debugcommands(ui, cmd='', *args):
1894 1894 """list all available commands and options"""
1895 1895 for cmd, vals in sorted(table.iteritems()):
1896 1896 cmd = cmd.split('|')[0].strip('^')
1897 1897 opts = ', '.join([i[1] for i in vals[1]])
1898 1898 ui.write('%s: %s\n' % (cmd, opts))
1899 1899
1900 1900 @command('debugcomplete',
1901 1901 [('o', 'options', None, _('show the command options'))],
1902 1902 _('[-o] CMD'),
1903 1903 norepo=True)
1904 1904 def debugcomplete(ui, cmd='', **opts):
1905 1905 """returns the completion list associated with the given command"""
1906 1906
1907 1907 if opts.get('options'):
1908 1908 options = []
1909 1909 otables = [globalopts]
1910 1910 if cmd:
1911 1911 aliases, entry = cmdutil.findcmd(cmd, table, False)
1912 1912 otables.append(entry[1])
1913 1913 for t in otables:
1914 1914 for o in t:
1915 1915 if "(DEPRECATED)" in o[3]:
1916 1916 continue
1917 1917 if o[0]:
1918 1918 options.append('-%s' % o[0])
1919 1919 options.append('--%s' % o[1])
1920 1920 ui.write("%s\n" % "\n".join(options))
1921 1921 return
1922 1922
1923 1923 cmdlist = cmdutil.findpossible(cmd, table)
1924 1924 if ui.verbose:
1925 1925 cmdlist = [' '.join(c[0]) for c in cmdlist.values()]
1926 1926 ui.write("%s\n" % "\n".join(sorted(cmdlist)))
1927 1927
1928 1928 @command('debugdag',
1929 1929 [('t', 'tags', None, _('use tags as labels')),
1930 1930 ('b', 'branches', None, _('annotate with branch names')),
1931 1931 ('', 'dots', None, _('use dots for runs')),
1932 1932 ('s', 'spaces', None, _('separate elements by spaces'))],
1933 1933 _('[OPTION]... [FILE [REV]...]'),
1934 1934 optionalrepo=True)
1935 1935 def debugdag(ui, repo, file_=None, *revs, **opts):
1936 1936 """format the changelog or an index DAG as a concise textual description
1937 1937
1938 1938 If you pass a revlog index, the revlog's DAG is emitted. If you list
1939 1939 revision numbers, they get labeled in the output as rN.
1940 1940
1941 1941 Otherwise, the changelog DAG of the current repo is emitted.
1942 1942 """
1943 1943 spaces = opts.get('spaces')
1944 1944 dots = opts.get('dots')
1945 1945 if file_:
1946 1946 rlog = revlog.revlog(scmutil.opener(os.getcwd(), audit=False), file_)
1947 1947 revs = set((int(r) for r in revs))
1948 1948 def events():
1949 1949 for r in rlog:
1950 1950 yield 'n', (r, list(p for p in rlog.parentrevs(r)
1951 1951 if p != -1))
1952 1952 if r in revs:
1953 1953 yield 'l', (r, "r%i" % r)
1954 1954 elif repo:
1955 1955 cl = repo.changelog
1956 1956 tags = opts.get('tags')
1957 1957 branches = opts.get('branches')
1958 1958 if tags:
1959 1959 labels = {}
1960 1960 for l, n in repo.tags().items():
1961 1961 labels.setdefault(cl.rev(n), []).append(l)
1962 1962 def events():
1963 1963 b = "default"
1964 1964 for r in cl:
1965 1965 if branches:
1966 1966 newb = cl.read(cl.node(r))[5]['branch']
1967 1967 if newb != b:
1968 1968 yield 'a', newb
1969 1969 b = newb
1970 1970 yield 'n', (r, list(p for p in cl.parentrevs(r)
1971 1971 if p != -1))
1972 1972 if tags:
1973 1973 ls = labels.get(r)
1974 1974 if ls:
1975 1975 for l in ls:
1976 1976 yield 'l', (r, l)
1977 1977 else:
1978 1978 raise util.Abort(_('need repo for changelog dag'))
1979 1979
1980 1980 for line in dagparser.dagtextlines(events(),
1981 1981 addspaces=spaces,
1982 1982 wraplabels=True,
1983 1983 wrapannotations=True,
1984 1984 wrapnonlinear=dots,
1985 1985 usedots=dots,
1986 1986 maxlinewidth=70):
1987 1987 ui.write(line)
1988 1988 ui.write("\n")
1989 1989
1990 1990 @command('debugdata',
1991 1991 [('c', 'changelog', False, _('open changelog')),
1992 1992 ('m', 'manifest', False, _('open manifest'))],
1993 1993 _('-c|-m|FILE REV'))
1994 1994 def debugdata(ui, repo, file_, rev=None, **opts):
1995 1995 """dump the contents of a data file revision"""
1996 1996 if opts.get('changelog') or opts.get('manifest'):
1997 1997 file_, rev = None, file_
1998 1998 elif rev is None:
1999 1999 raise error.CommandError('debugdata', _('invalid arguments'))
2000 2000 r = cmdutil.openrevlog(repo, 'debugdata', file_, opts)
2001 2001 try:
2002 2002 ui.write(r.revision(r.lookup(rev)))
2003 2003 except KeyError:
2004 2004 raise util.Abort(_('invalid revision identifier %s') % rev)
2005 2005
2006 2006 @command('debugdate',
2007 2007 [('e', 'extended', None, _('try extended date formats'))],
2008 2008 _('[-e] DATE [RANGE]'),
2009 2009 norepo=True, optionalrepo=True)
2010 2010 def debugdate(ui, date, range=None, **opts):
2011 2011 """parse and display a date"""
2012 2012 if opts["extended"]:
2013 2013 d = util.parsedate(date, util.extendeddateformats)
2014 2014 else:
2015 2015 d = util.parsedate(date)
2016 2016 ui.write(("internal: %s %s\n") % d)
2017 2017 ui.write(("standard: %s\n") % util.datestr(d))
2018 2018 if range:
2019 2019 m = util.matchdate(range)
2020 2020 ui.write(("match: %s\n") % m(d[0]))
2021 2021
2022 2022 @command('debugdiscovery',
2023 2023 [('', 'old', None, _('use old-style discovery')),
2024 2024 ('', 'nonheads', None,
2025 2025 _('use old-style discovery with non-heads included')),
2026 2026 ] + remoteopts,
2027 2027 _('[-l REV] [-r REV] [-b BRANCH]... [OTHER]'))
2028 2028 def debugdiscovery(ui, repo, remoteurl="default", **opts):
2029 2029 """runs the changeset discovery protocol in isolation"""
2030 2030 remoteurl, branches = hg.parseurl(ui.expandpath(remoteurl),
2031 2031 opts.get('branch'))
2032 2032 remote = hg.peer(repo, opts, remoteurl)
2033 2033 ui.status(_('comparing with %s\n') % util.hidepassword(remoteurl))
2034 2034
2035 2035 # make sure tests are repeatable
2036 2036 random.seed(12323)
2037 2037
2038 2038 def doit(localheads, remoteheads, remote=remote):
2039 2039 if opts.get('old'):
2040 2040 if localheads:
2041 2041 raise util.Abort('cannot use localheads with old style '
2042 2042 'discovery')
2043 2043 if not util.safehasattr(remote, 'branches'):
2044 2044 # enable in-client legacy support
2045 2045 remote = localrepo.locallegacypeer(remote.local())
2046 2046 common, _in, hds = treediscovery.findcommonincoming(repo, remote,
2047 2047 force=True)
2048 2048 common = set(common)
2049 2049 if not opts.get('nonheads'):
2050 2050 ui.write(("unpruned common: %s\n") %
2051 2051 " ".join(sorted(short(n) for n in common)))
2052 2052 dag = dagutil.revlogdag(repo.changelog)
2053 2053 all = dag.ancestorset(dag.internalizeall(common))
2054 2054 common = dag.externalizeall(dag.headsetofconnecteds(all))
2055 2055 else:
2056 2056 common, any, hds = setdiscovery.findcommonheads(ui, repo, remote)
2057 2057 common = set(common)
2058 2058 rheads = set(hds)
2059 2059 lheads = set(repo.heads())
2060 2060 ui.write(("common heads: %s\n") %
2061 2061 " ".join(sorted(short(n) for n in common)))
2062 2062 if lheads <= common:
2063 2063 ui.write(("local is subset\n"))
2064 2064 elif rheads <= common:
2065 2065 ui.write(("remote is subset\n"))
2066 2066
2067 2067 serverlogs = opts.get('serverlog')
2068 2068 if serverlogs:
2069 2069 for filename in serverlogs:
2070 2070 logfile = open(filename, 'r')
2071 2071 try:
2072 2072 line = logfile.readline()
2073 2073 while line:
2074 2074 parts = line.strip().split(';')
2075 2075 op = parts[1]
2076 2076 if op == 'cg':
2077 2077 pass
2078 2078 elif op == 'cgss':
2079 2079 doit(parts[2].split(' '), parts[3].split(' '))
2080 2080 elif op == 'unb':
2081 2081 doit(parts[3].split(' '), parts[2].split(' '))
2082 2082 line = logfile.readline()
2083 2083 finally:
2084 2084 logfile.close()
2085 2085
2086 2086 else:
2087 2087 remoterevs, _checkout = hg.addbranchrevs(repo, remote, branches,
2088 2088 opts.get('remote_head'))
2089 2089 localrevs = opts.get('local_head')
2090 2090 doit(localrevs, remoterevs)
2091 2091
2092 2092 @command('debugfileset',
2093 2093 [('r', 'rev', '', _('apply the filespec on this revision'), _('REV'))],
2094 2094 _('[-r REV] FILESPEC'))
2095 2095 def debugfileset(ui, repo, expr, **opts):
2096 2096 '''parse and apply a fileset specification'''
2097 2097 ctx = scmutil.revsingle(repo, opts.get('rev'), None)
2098 2098 if ui.verbose:
2099 2099 tree = fileset.parse(expr)[0]
2100 2100 ui.note(tree, "\n")
2101 2101
2102 2102 for f in ctx.getfileset(expr):
2103 2103 ui.write("%s\n" % f)
2104 2104
2105 2105 @command('debugfsinfo', [], _('[PATH]'), norepo=True)
2106 2106 def debugfsinfo(ui, path="."):
2107 2107 """show information detected about current filesystem"""
2108 2108 util.writefile('.debugfsinfo', '')
2109 2109 ui.write(('exec: %s\n') % (util.checkexec(path) and 'yes' or 'no'))
2110 2110 ui.write(('symlink: %s\n') % (util.checklink(path) and 'yes' or 'no'))
2111 2111 ui.write(('hardlink: %s\n') % (util.checknlink(path) and 'yes' or 'no'))
2112 2112 ui.write(('case-sensitive: %s\n') % (util.checkcase('.debugfsinfo')
2113 2113 and 'yes' or 'no'))
2114 2114 os.unlink('.debugfsinfo')
2115 2115
2116 2116 @command('debuggetbundle',
2117 2117 [('H', 'head', [], _('id of head node'), _('ID')),
2118 2118 ('C', 'common', [], _('id of common node'), _('ID')),
2119 2119 ('t', 'type', 'bzip2', _('bundle compression type to use'), _('TYPE'))],
2120 2120 _('REPO FILE [-H|-C ID]...'),
2121 2121 norepo=True)
2122 2122 def debuggetbundle(ui, repopath, bundlepath, head=None, common=None, **opts):
2123 2123 """retrieves a bundle from a repo
2124 2124
2125 2125 Every ID must be a full-length hex node id string. Saves the bundle to the
2126 2126 given file.
2127 2127 """
2128 2128 repo = hg.peer(ui, opts, repopath)
2129 2129 if not repo.capable('getbundle'):
2130 2130 raise util.Abort("getbundle() not supported by target repository")
2131 2131 args = {}
2132 2132 if common:
2133 2133 args['common'] = [bin(s) for s in common]
2134 2134 if head:
2135 2135 args['heads'] = [bin(s) for s in head]
2136 2136 # TODO: get desired bundlecaps from command line.
2137 2137 args['bundlecaps'] = None
2138 2138 bundle = repo.getbundle('debug', **args)
2139 2139
2140 2140 bundletype = opts.get('type', 'bzip2').lower()
2141 2141 btypes = {'none': 'HG10UN', 'bzip2': 'HG10BZ', 'gzip': 'HG10GZ'}
2142 2142 bundletype = btypes.get(bundletype)
2143 2143 if bundletype not in changegroup.bundletypes:
2144 2144 raise util.Abort(_('unknown bundle type specified with --type'))
2145 2145 changegroup.writebundle(bundle, bundlepath, bundletype)
2146 2146
2147 2147 @command('debugignore', [], '')
2148 2148 def debugignore(ui, repo, *values, **opts):
2149 2149 """display the combined ignore pattern"""
2150 2150 ignore = repo.dirstate._ignore
2151 2151 includepat = getattr(ignore, 'includepat', None)
2152 2152 if includepat is not None:
2153 2153 ui.write("%s\n" % includepat)
2154 2154 else:
2155 2155 raise util.Abort(_("no ignore patterns found"))
2156 2156
2157 2157 @command('debugindex',
2158 2158 [('c', 'changelog', False, _('open changelog')),
2159 2159 ('m', 'manifest', False, _('open manifest')),
2160 2160 ('f', 'format', 0, _('revlog format'), _('FORMAT'))],
2161 2161 _('[-f FORMAT] -c|-m|FILE'),
2162 2162 optionalrepo=True)
2163 2163 def debugindex(ui, repo, file_=None, **opts):
2164 2164 """dump the contents of an index file"""
2165 2165 r = cmdutil.openrevlog(repo, 'debugindex', file_, opts)
2166 2166 format = opts.get('format', 0)
2167 2167 if format not in (0, 1):
2168 2168 raise util.Abort(_("unknown format %d") % format)
2169 2169
2170 2170 generaldelta = r.version & revlog.REVLOGGENERALDELTA
2171 2171 if generaldelta:
2172 2172 basehdr = ' delta'
2173 2173 else:
2174 2174 basehdr = ' base'
2175 2175
2176 2176 if format == 0:
2177 2177 ui.write(" rev offset length " + basehdr + " linkrev"
2178 2178 " nodeid p1 p2\n")
2179 2179 elif format == 1:
2180 2180 ui.write(" rev flag offset length"
2181 2181 " size " + basehdr + " link p1 p2"
2182 2182 " nodeid\n")
2183 2183
2184 2184 for i in r:
2185 2185 node = r.node(i)
2186 2186 if generaldelta:
2187 2187 base = r.deltaparent(i)
2188 2188 else:
2189 2189 base = r.chainbase(i)
2190 2190 if format == 0:
2191 2191 try:
2192 2192 pp = r.parents(node)
2193 2193 except Exception:
2194 2194 pp = [nullid, nullid]
2195 2195 ui.write("% 6d % 9d % 7d % 6d % 7d %s %s %s\n" % (
2196 2196 i, r.start(i), r.length(i), base, r.linkrev(i),
2197 2197 short(node), short(pp[0]), short(pp[1])))
2198 2198 elif format == 1:
2199 2199 pr = r.parentrevs(i)
2200 2200 ui.write("% 6d %04x % 8d % 8d % 8d % 6d % 6d % 6d % 6d %s\n" % (
2201 2201 i, r.flags(i), r.start(i), r.length(i), r.rawsize(i),
2202 2202 base, r.linkrev(i), pr[0], pr[1], short(node)))
2203 2203
2204 2204 @command('debugindexdot', [], _('FILE'), optionalrepo=True)
2205 2205 def debugindexdot(ui, repo, file_):
2206 2206 """dump an index DAG as a graphviz dot file"""
2207 2207 r = None
2208 2208 if repo:
2209 2209 filelog = repo.file(file_)
2210 2210 if len(filelog):
2211 2211 r = filelog
2212 2212 if not r:
2213 2213 r = revlog.revlog(scmutil.opener(os.getcwd(), audit=False), file_)
2214 2214 ui.write(("digraph G {\n"))
2215 2215 for i in r:
2216 2216 node = r.node(i)
2217 2217 pp = r.parents(node)
2218 2218 ui.write("\t%d -> %d\n" % (r.rev(pp[0]), i))
2219 2219 if pp[1] != nullid:
2220 2220 ui.write("\t%d -> %d\n" % (r.rev(pp[1]), i))
2221 2221 ui.write("}\n")
2222 2222
2223 2223 @command('debuginstall', [], '', norepo=True)
2224 2224 def debuginstall(ui):
2225 2225 '''test Mercurial installation
2226 2226
2227 2227 Returns 0 on success.
2228 2228 '''
2229 2229
2230 2230 def writetemp(contents):
2231 2231 (fd, name) = tempfile.mkstemp(prefix="hg-debuginstall-")
2232 2232 f = os.fdopen(fd, "wb")
2233 2233 f.write(contents)
2234 2234 f.close()
2235 2235 return name
2236 2236
2237 2237 problems = 0
2238 2238
2239 2239 # encoding
2240 2240 ui.status(_("checking encoding (%s)...\n") % encoding.encoding)
2241 2241 try:
2242 2242 encoding.fromlocal("test")
2243 2243 except util.Abort, inst:
2244 2244 ui.write(" %s\n" % inst)
2245 2245 ui.write(_(" (check that your locale is properly set)\n"))
2246 2246 problems += 1
2247 2247
2248 2248 # Python
2249 2249 ui.status(_("checking Python executable (%s)\n") % sys.executable)
2250 2250 ui.status(_("checking Python version (%s)\n")
2251 2251 % ("%s.%s.%s" % sys.version_info[:3]))
2252 2252 ui.status(_("checking Python lib (%s)...\n")
2253 2253 % os.path.dirname(os.__file__))
2254 2254
2255 2255 # compiled modules
2256 2256 ui.status(_("checking installed modules (%s)...\n")
2257 2257 % os.path.dirname(__file__))
2258 2258 try:
2259 2259 import bdiff, mpatch, base85, osutil
2260 2260 dir(bdiff), dir(mpatch), dir(base85), dir(osutil) # quiet pyflakes
2261 2261 except Exception, inst:
2262 2262 ui.write(" %s\n" % inst)
2263 2263 ui.write(_(" One or more extensions could not be found"))
2264 2264 ui.write(_(" (check that you compiled the extensions)\n"))
2265 2265 problems += 1
2266 2266
2267 2267 # templates
2268 2268 import templater
2269 2269 p = templater.templatepaths()
2270 2270 ui.status(_("checking templates (%s)...\n") % ' '.join(p))
2271 2271 if p:
2272 2272 m = templater.templatepath("map-cmdline.default")
2273 2273 if m:
2274 2274 # template found, check if it is working
2275 2275 try:
2276 2276 templater.templater(m)
2277 2277 except Exception, inst:
2278 2278 ui.write(" %s\n" % inst)
2279 2279 p = None
2280 2280 else:
2281 2281 ui.write(_(" template 'default' not found\n"))
2282 2282 p = None
2283 2283 else:
2284 2284 ui.write(_(" no template directories found\n"))
2285 2285 if not p:
2286 2286 ui.write(_(" (templates seem to have been installed incorrectly)\n"))
2287 2287 problems += 1
2288 2288
2289 2289 # editor
2290 2290 ui.status(_("checking commit editor...\n"))
2291 2291 editor = ui.geteditor()
2292 2292 cmdpath = util.findexe(shlex.split(editor)[0])
2293 2293 if not cmdpath:
2294 2294 if editor == 'vi':
2295 2295 ui.write(_(" No commit editor set and can't find vi in PATH\n"))
2296 2296 ui.write(_(" (specify a commit editor in your configuration"
2297 2297 " file)\n"))
2298 2298 else:
2299 2299 ui.write(_(" Can't find editor '%s' in PATH\n") % editor)
2300 2300 ui.write(_(" (specify a commit editor in your configuration"
2301 2301 " file)\n"))
2302 2302 problems += 1
2303 2303
2304 2304 # check username
2305 2305 ui.status(_("checking username...\n"))
2306 2306 try:
2307 2307 ui.username()
2308 2308 except util.Abort, e:
2309 2309 ui.write(" %s\n" % e)
2310 2310 ui.write(_(" (specify a username in your configuration file)\n"))
2311 2311 problems += 1
2312 2312
2313 2313 if not problems:
2314 2314 ui.status(_("no problems detected\n"))
2315 2315 else:
2316 2316 ui.write(_("%s problems detected,"
2317 2317 " please check your install!\n") % problems)
2318 2318
2319 2319 return problems
2320 2320
2321 2321 @command('debugknown', [], _('REPO ID...'), norepo=True)
2322 2322 def debugknown(ui, repopath, *ids, **opts):
2323 2323 """test whether node ids are known to a repo
2324 2324
2325 2325 Every ID must be a full-length hex node id string. Returns a list of 0s
2326 2326 and 1s indicating unknown/known.
2327 2327 """
2328 2328 repo = hg.peer(ui, opts, repopath)
2329 2329 if not repo.capable('known'):
2330 2330 raise util.Abort("known() not supported by target repository")
2331 2331 flags = repo.known([bin(s) for s in ids])
2332 2332 ui.write("%s\n" % ("".join([f and "1" or "0" for f in flags])))
2333 2333
2334 2334 @command('debuglabelcomplete', [], _('LABEL...'))
2335 2335 def debuglabelcomplete(ui, repo, *args):
2336 2336 '''complete "labels" - tags, open branch names, bookmark names'''
2337 2337
2338 2338 labels = set()
2339 2339 labels.update(t[0] for t in repo.tagslist())
2340 2340 labels.update(repo._bookmarks.keys())
2341 2341 labels.update(tag for (tag, heads, tip, closed)
2342 2342 in repo.branchmap().iterbranches() if not closed)
2343 2343 completions = set()
2344 2344 if not args:
2345 2345 args = ['']
2346 2346 for a in args:
2347 2347 completions.update(l for l in labels if l.startswith(a))
2348 2348 ui.write('\n'.join(sorted(completions)))
2349 2349 ui.write('\n')
2350 2350
2351 2351 @command('debuglocks',
2352 2352 [('L', 'force-lock', None, _('free the store lock (DANGEROUS)')),
2353 2353 ('W', 'force-wlock', None,
2354 2354 _('free the working state lock (DANGEROUS)'))],
2355 2355 _('[OPTION]...'))
2356 2356 def debuglocks(ui, repo, **opts):
2357 2357 """show or modify state of locks
2358 2358
2359 2359 By default, this command will show which locks are held. This
2360 2360 includes the user and process holding the lock, the amount of time
2361 2361 the lock has been held, and the machine name where the process is
2362 2362 running if it's not local.
2363 2363
2364 2364 Locks protect the integrity of Mercurial's data, so should be
2365 2365 treated with care. System crashes or other interruptions may cause
2366 2366 locks to not be properly released, though Mercurial will usually
2367 2367 detect and remove such stale locks automatically.
2368 2368
2369 2369 However, detecting stale locks may not always be possible (for
2370 2370 instance, on a shared filesystem). Removing locks may also be
2371 2371 blocked by filesystem permissions.
2372 2372
2373 2373 Returns 0 if no locks are held.
2374 2374
2375 2375 """
2376 2376
2377 2377 if opts.get('force_lock'):
2378 2378 repo.svfs.unlink('lock')
2379 2379 if opts.get('force_wlock'):
2380 2380 repo.vfs.unlink('wlock')
2381 2381 if opts.get('force_lock') or opts.get('force_lock'):
2382 2382 return 0
2383 2383
2384 2384 now = time.time()
2385 2385 held = 0
2386 2386
2387 2387 def report(vfs, name, method):
2388 2388 # this causes stale locks to get reaped for more accurate reporting
2389 2389 try:
2390 2390 l = method(False)
2391 2391 except error.LockHeld:
2392 2392 l = None
2393 2393
2394 2394 if l:
2395 2395 l.release()
2396 2396 else:
2397 2397 try:
2398 2398 stat = repo.svfs.lstat(name)
2399 2399 age = now - stat.st_mtime
2400 2400 user = util.username(stat.st_uid)
2401 2401 locker = vfs.readlock(name)
2402 2402 if ":" in locker:
2403 2403 host, pid = locker.split(':')
2404 2404 if host == socket.gethostname():
2405 2405 locker = 'user %s, process %s' % (user, pid)
2406 2406 else:
2407 2407 locker = 'user %s, process %s, host %s' \
2408 2408 % (user, pid, host)
2409 2409 ui.write("%-6s %s (%ds)\n" % (name + ":", locker, age))
2410 2410 return 1
2411 2411 except OSError, e:
2412 2412 if e.errno != errno.ENOENT:
2413 2413 raise
2414 2414
2415 2415 ui.write("%-6s free\n" % (name + ":"))
2416 2416 return 0
2417 2417
2418 2418 held += report(repo.svfs, "lock", repo.lock)
2419 2419 held += report(repo.vfs, "wlock", repo.wlock)
2420 2420
2421 2421 return held
2422 2422
2423 2423 @command('debugobsolete',
2424 2424 [('', 'flags', 0, _('markers flag')),
2425 2425 ('', 'record-parents', False,
2426 2426 _('record parent information for the precursor')),
2427 2427 ('r', 'rev', [], _('display markers relevant to REV')),
2428 2428 ] + commitopts2,
2429 2429 _('[OBSOLETED [REPLACEMENT] [REPL... ]'))
2430 2430 def debugobsolete(ui, repo, precursor=None, *successors, **opts):
2431 2431 """create arbitrary obsolete marker
2432 2432
2433 2433 With no arguments, displays the list of obsolescence markers."""
2434 2434
2435 2435 def parsenodeid(s):
2436 2436 try:
2437 2437 # We do not use revsingle/revrange functions here to accept
2438 2438 # arbitrary node identifiers, possibly not present in the
2439 2439 # local repository.
2440 2440 n = bin(s)
2441 2441 if len(n) != len(nullid):
2442 2442 raise TypeError()
2443 2443 return n
2444 2444 except TypeError:
2445 2445 raise util.Abort('changeset references must be full hexadecimal '
2446 2446 'node identifiers')
2447 2447
2448 2448 if precursor is not None:
2449 2449 if opts['rev']:
2450 2450 raise util.Abort('cannot select revision when creating marker')
2451 2451 metadata = {}
2452 2452 metadata['user'] = opts['user'] or ui.username()
2453 2453 succs = tuple(parsenodeid(succ) for succ in successors)
2454 2454 l = repo.lock()
2455 2455 try:
2456 2456 tr = repo.transaction('debugobsolete')
2457 2457 try:
2458 2458 try:
2459 2459 date = opts.get('date')
2460 2460 if date:
2461 2461 date = util.parsedate(date)
2462 2462 else:
2463 2463 date = None
2464 2464 prec = parsenodeid(precursor)
2465 2465 parents = None
2466 2466 if opts['record_parents']:
2467 2467 if prec not in repo.unfiltered():
2468 2468 raise util.Abort('cannot used --record-parents on '
2469 2469 'unknown changesets')
2470 2470 parents = repo.unfiltered()[prec].parents()
2471 2471 parents = tuple(p.node() for p in parents)
2472 2472 repo.obsstore.create(tr, prec, succs, opts['flags'],
2473 2473 parents=parents, date=date,
2474 2474 metadata=metadata)
2475 2475 tr.close()
2476 2476 except ValueError, exc:
2477 2477 raise util.Abort(_('bad obsmarker input: %s') % exc)
2478 2478 finally:
2479 2479 tr.release()
2480 2480 finally:
2481 2481 l.release()
2482 2482 else:
2483 2483 if opts['rev']:
2484 2484 revs = scmutil.revrange(repo, opts['rev'])
2485 2485 nodes = [repo[r].node() for r in revs]
2486 2486 markers = list(obsolete.getmarkers(repo, nodes=nodes))
2487 2487 markers.sort(key=lambda x: x._data)
2488 2488 else:
2489 2489 markers = obsolete.getmarkers(repo)
2490 2490
2491 2491 for m in markers:
2492 2492 cmdutil.showmarker(ui, m)
2493 2493
2494 2494 @command('debugpathcomplete',
2495 2495 [('f', 'full', None, _('complete an entire path')),
2496 2496 ('n', 'normal', None, _('show only normal files')),
2497 2497 ('a', 'added', None, _('show only added files')),
2498 2498 ('r', 'removed', None, _('show only removed files'))],
2499 2499 _('FILESPEC...'))
2500 2500 def debugpathcomplete(ui, repo, *specs, **opts):
2501 2501 '''complete part or all of a tracked path
2502 2502
2503 2503 This command supports shells that offer path name completion. It
2504 2504 currently completes only files already known to the dirstate.
2505 2505
2506 2506 Completion extends only to the next path segment unless
2507 2507 --full is specified, in which case entire paths are used.'''
2508 2508
2509 2509 def complete(path, acceptable):
2510 2510 dirstate = repo.dirstate
2511 2511 spec = os.path.normpath(os.path.join(os.getcwd(), path))
2512 2512 rootdir = repo.root + os.sep
2513 2513 if spec != repo.root and not spec.startswith(rootdir):
2514 2514 return [], []
2515 2515 if os.path.isdir(spec):
2516 2516 spec += '/'
2517 2517 spec = spec[len(rootdir):]
2518 2518 fixpaths = os.sep != '/'
2519 2519 if fixpaths:
2520 2520 spec = spec.replace(os.sep, '/')
2521 2521 speclen = len(spec)
2522 2522 fullpaths = opts['full']
2523 2523 files, dirs = set(), set()
2524 2524 adddir, addfile = dirs.add, files.add
2525 2525 for f, st in dirstate.iteritems():
2526 2526 if f.startswith(spec) and st[0] in acceptable:
2527 2527 if fixpaths:
2528 2528 f = f.replace('/', os.sep)
2529 2529 if fullpaths:
2530 2530 addfile(f)
2531 2531 continue
2532 2532 s = f.find(os.sep, speclen)
2533 2533 if s >= 0:
2534 2534 adddir(f[:s])
2535 2535 else:
2536 2536 addfile(f)
2537 2537 return files, dirs
2538 2538
2539 2539 acceptable = ''
2540 2540 if opts['normal']:
2541 2541 acceptable += 'nm'
2542 2542 if opts['added']:
2543 2543 acceptable += 'a'
2544 2544 if opts['removed']:
2545 2545 acceptable += 'r'
2546 2546 cwd = repo.getcwd()
2547 2547 if not specs:
2548 2548 specs = ['.']
2549 2549
2550 2550 files, dirs = set(), set()
2551 2551 for spec in specs:
2552 2552 f, d = complete(spec, acceptable or 'nmar')
2553 2553 files.update(f)
2554 2554 dirs.update(d)
2555 2555 files.update(dirs)
2556 2556 ui.write('\n'.join(repo.pathto(p, cwd) for p in sorted(files)))
2557 2557 ui.write('\n')
2558 2558
2559 2559 @command('debugpushkey', [], _('REPO NAMESPACE [KEY OLD NEW]'), norepo=True)
2560 2560 def debugpushkey(ui, repopath, namespace, *keyinfo, **opts):
2561 2561 '''access the pushkey key/value protocol
2562 2562
2563 2563 With two args, list the keys in the given namespace.
2564 2564
2565 2565 With five args, set a key to new if it currently is set to old.
2566 2566 Reports success or failure.
2567 2567 '''
2568 2568
2569 2569 target = hg.peer(ui, {}, repopath)
2570 2570 if keyinfo:
2571 2571 key, old, new = keyinfo
2572 2572 r = target.pushkey(namespace, key, old, new)
2573 2573 ui.status(str(r) + '\n')
2574 2574 return not r
2575 2575 else:
2576 2576 for k, v in sorted(target.listkeys(namespace).iteritems()):
2577 2577 ui.write("%s\t%s\n" % (k.encode('string-escape'),
2578 2578 v.encode('string-escape')))
2579 2579
2580 2580 @command('debugpvec', [], _('A B'))
2581 2581 def debugpvec(ui, repo, a, b=None):
2582 2582 ca = scmutil.revsingle(repo, a)
2583 2583 cb = scmutil.revsingle(repo, b)
2584 2584 pa = pvec.ctxpvec(ca)
2585 2585 pb = pvec.ctxpvec(cb)
2586 2586 if pa == pb:
2587 2587 rel = "="
2588 2588 elif pa > pb:
2589 2589 rel = ">"
2590 2590 elif pa < pb:
2591 2591 rel = "<"
2592 2592 elif pa | pb:
2593 2593 rel = "|"
2594 2594 ui.write(_("a: %s\n") % pa)
2595 2595 ui.write(_("b: %s\n") % pb)
2596 2596 ui.write(_("depth(a): %d depth(b): %d\n") % (pa._depth, pb._depth))
2597 2597 ui.write(_("delta: %d hdist: %d distance: %d relation: %s\n") %
2598 2598 (abs(pa._depth - pb._depth), pvec._hamming(pa._vec, pb._vec),
2599 2599 pa.distance(pb), rel))
2600 2600
2601 2601 @command('debugrebuilddirstate|debugrebuildstate',
2602 2602 [('r', 'rev', '', _('revision to rebuild to'), _('REV'))],
2603 2603 _('[-r REV]'))
2604 2604 def debugrebuilddirstate(ui, repo, rev):
2605 2605 """rebuild the dirstate as it would look like for the given revision
2606 2606
2607 2607 If no revision is specified the first current parent will be used.
2608 2608
2609 2609 The dirstate will be set to the files of the given revision.
2610 2610 The actual working directory content or existing dirstate
2611 2611 information such as adds or removes is not considered.
2612 2612
2613 2613 One use of this command is to make the next :hg:`status` invocation
2614 2614 check the actual file content.
2615 2615 """
2616 2616 ctx = scmutil.revsingle(repo, rev)
2617 2617 wlock = repo.wlock()
2618 2618 try:
2619 2619 repo.dirstate.rebuild(ctx.node(), ctx.manifest())
2620 2620 finally:
2621 2621 wlock.release()
2622 2622
2623 2623 @command('debugrename',
2624 2624 [('r', 'rev', '', _('revision to debug'), _('REV'))],
2625 2625 _('[-r REV] FILE'))
2626 2626 def debugrename(ui, repo, file1, *pats, **opts):
2627 2627 """dump rename information"""
2628 2628
2629 2629 ctx = scmutil.revsingle(repo, opts.get('rev'))
2630 2630 m = scmutil.match(ctx, (file1,) + pats, opts)
2631 2631 for abs in ctx.walk(m):
2632 2632 fctx = ctx[abs]
2633 2633 o = fctx.filelog().renamed(fctx.filenode())
2634 2634 rel = m.rel(abs)
2635 2635 if o:
2636 2636 ui.write(_("%s renamed from %s:%s\n") % (rel, o[0], hex(o[1])))
2637 2637 else:
2638 2638 ui.write(_("%s not renamed\n") % rel)
2639 2639
2640 2640 @command('debugrevlog',
2641 2641 [('c', 'changelog', False, _('open changelog')),
2642 2642 ('m', 'manifest', False, _('open manifest')),
2643 2643 ('d', 'dump', False, _('dump index data'))],
2644 2644 _('-c|-m|FILE'),
2645 2645 optionalrepo=True)
2646 2646 def debugrevlog(ui, repo, file_=None, **opts):
2647 2647 """show data and statistics about a revlog"""
2648 2648 r = cmdutil.openrevlog(repo, 'debugrevlog', file_, opts)
2649 2649
2650 2650 if opts.get("dump"):
2651 2651 numrevs = len(r)
2652 2652 ui.write("# rev p1rev p2rev start end deltastart base p1 p2"
2653 2653 " rawsize totalsize compression heads chainlen\n")
2654 2654 ts = 0
2655 2655 heads = set()
2656 2656 rindex = r.index
2657 2657
2658 2658 def chainbaseandlen(rev):
2659 2659 clen = 0
2660 2660 base = rindex[rev][3]
2661 2661 while base != rev:
2662 2662 clen += 1
2663 2663 rev = base
2664 2664 base = rindex[rev][3]
2665 2665 return base, clen
2666 2666
2667 2667 for rev in xrange(numrevs):
2668 2668 dbase = r.deltaparent(rev)
2669 2669 if dbase == -1:
2670 2670 dbase = rev
2671 2671 cbase, clen = chainbaseandlen(rev)
2672 2672 p1, p2 = r.parentrevs(rev)
2673 2673 rs = r.rawsize(rev)
2674 2674 ts = ts + rs
2675 2675 heads -= set(r.parentrevs(rev))
2676 2676 heads.add(rev)
2677 2677 ui.write("%5d %5d %5d %5d %5d %10d %4d %4d %4d %7d %9d "
2678 2678 "%11d %5d %8d\n" %
2679 2679 (rev, p1, p2, r.start(rev), r.end(rev),
2680 2680 r.start(dbase), r.start(cbase),
2681 2681 r.start(p1), r.start(p2),
2682 2682 rs, ts, ts / r.end(rev), len(heads), clen))
2683 2683 return 0
2684 2684
2685 2685 v = r.version
2686 2686 format = v & 0xFFFF
2687 2687 flags = []
2688 2688 gdelta = False
2689 2689 if v & revlog.REVLOGNGINLINEDATA:
2690 2690 flags.append('inline')
2691 2691 if v & revlog.REVLOGGENERALDELTA:
2692 2692 gdelta = True
2693 2693 flags.append('generaldelta')
2694 2694 if not flags:
2695 2695 flags = ['(none)']
2696 2696
2697 2697 nummerges = 0
2698 2698 numfull = 0
2699 2699 numprev = 0
2700 2700 nump1 = 0
2701 2701 nump2 = 0
2702 2702 numother = 0
2703 2703 nump1prev = 0
2704 2704 nump2prev = 0
2705 2705 chainlengths = []
2706 2706
2707 2707 datasize = [None, 0, 0L]
2708 2708 fullsize = [None, 0, 0L]
2709 2709 deltasize = [None, 0, 0L]
2710 2710
2711 2711 def addsize(size, l):
2712 2712 if l[0] is None or size < l[0]:
2713 2713 l[0] = size
2714 2714 if size > l[1]:
2715 2715 l[1] = size
2716 2716 l[2] += size
2717 2717
2718 2718 numrevs = len(r)
2719 2719 for rev in xrange(numrevs):
2720 2720 p1, p2 = r.parentrevs(rev)
2721 2721 delta = r.deltaparent(rev)
2722 2722 if format > 0:
2723 2723 addsize(r.rawsize(rev), datasize)
2724 2724 if p2 != nullrev:
2725 2725 nummerges += 1
2726 2726 size = r.length(rev)
2727 2727 if delta == nullrev:
2728 2728 chainlengths.append(0)
2729 2729 numfull += 1
2730 2730 addsize(size, fullsize)
2731 2731 else:
2732 2732 chainlengths.append(chainlengths[delta] + 1)
2733 2733 addsize(size, deltasize)
2734 2734 if delta == rev - 1:
2735 2735 numprev += 1
2736 2736 if delta == p1:
2737 2737 nump1prev += 1
2738 2738 elif delta == p2:
2739 2739 nump2prev += 1
2740 2740 elif delta == p1:
2741 2741 nump1 += 1
2742 2742 elif delta == p2:
2743 2743 nump2 += 1
2744 2744 elif delta != nullrev:
2745 2745 numother += 1
2746 2746
2747 2747 # Adjust size min value for empty cases
2748 2748 for size in (datasize, fullsize, deltasize):
2749 2749 if size[0] is None:
2750 2750 size[0] = 0
2751 2751
2752 2752 numdeltas = numrevs - numfull
2753 2753 numoprev = numprev - nump1prev - nump2prev
2754 2754 totalrawsize = datasize[2]
2755 2755 datasize[2] /= numrevs
2756 2756 fulltotal = fullsize[2]
2757 2757 fullsize[2] /= numfull
2758 2758 deltatotal = deltasize[2]
2759 2759 if numrevs - numfull > 0:
2760 2760 deltasize[2] /= numrevs - numfull
2761 2761 totalsize = fulltotal + deltatotal
2762 2762 avgchainlen = sum(chainlengths) / numrevs
2763 2763 compratio = totalrawsize / totalsize
2764 2764
2765 2765 basedfmtstr = '%%%dd\n'
2766 2766 basepcfmtstr = '%%%dd %s(%%5.2f%%%%)\n'
2767 2767
2768 2768 def dfmtstr(max):
2769 2769 return basedfmtstr % len(str(max))
2770 2770 def pcfmtstr(max, padding=0):
2771 2771 return basepcfmtstr % (len(str(max)), ' ' * padding)
2772 2772
2773 2773 def pcfmt(value, total):
2774 2774 return (value, 100 * float(value) / total)
2775 2775
2776 2776 ui.write(('format : %d\n') % format)
2777 2777 ui.write(('flags : %s\n') % ', '.join(flags))
2778 2778
2779 2779 ui.write('\n')
2780 2780 fmt = pcfmtstr(totalsize)
2781 2781 fmt2 = dfmtstr(totalsize)
2782 2782 ui.write(('revisions : ') + fmt2 % numrevs)
2783 2783 ui.write((' merges : ') + fmt % pcfmt(nummerges, numrevs))
2784 2784 ui.write((' normal : ') + fmt % pcfmt(numrevs - nummerges, numrevs))
2785 2785 ui.write(('revisions : ') + fmt2 % numrevs)
2786 2786 ui.write((' full : ') + fmt % pcfmt(numfull, numrevs))
2787 2787 ui.write((' deltas : ') + fmt % pcfmt(numdeltas, numrevs))
2788 2788 ui.write(('revision size : ') + fmt2 % totalsize)
2789 2789 ui.write((' full : ') + fmt % pcfmt(fulltotal, totalsize))
2790 2790 ui.write((' deltas : ') + fmt % pcfmt(deltatotal, totalsize))
2791 2791
2792 2792 ui.write('\n')
2793 2793 fmt = dfmtstr(max(avgchainlen, compratio))
2794 2794 ui.write(('avg chain length : ') + fmt % avgchainlen)
2795 2795 ui.write(('compression ratio : ') + fmt % compratio)
2796 2796
2797 2797 if format > 0:
2798 2798 ui.write('\n')
2799 2799 ui.write(('uncompressed data size (min/max/avg) : %d / %d / %d\n')
2800 2800 % tuple(datasize))
2801 2801 ui.write(('full revision size (min/max/avg) : %d / %d / %d\n')
2802 2802 % tuple(fullsize))
2803 2803 ui.write(('delta size (min/max/avg) : %d / %d / %d\n')
2804 2804 % tuple(deltasize))
2805 2805
2806 2806 if numdeltas > 0:
2807 2807 ui.write('\n')
2808 2808 fmt = pcfmtstr(numdeltas)
2809 2809 fmt2 = pcfmtstr(numdeltas, 4)
2810 2810 ui.write(('deltas against prev : ') + fmt % pcfmt(numprev, numdeltas))
2811 2811 if numprev > 0:
2812 2812 ui.write((' where prev = p1 : ') + fmt2 % pcfmt(nump1prev,
2813 2813 numprev))
2814 2814 ui.write((' where prev = p2 : ') + fmt2 % pcfmt(nump2prev,
2815 2815 numprev))
2816 2816 ui.write((' other : ') + fmt2 % pcfmt(numoprev,
2817 2817 numprev))
2818 2818 if gdelta:
2819 2819 ui.write(('deltas against p1 : ')
2820 2820 + fmt % pcfmt(nump1, numdeltas))
2821 2821 ui.write(('deltas against p2 : ')
2822 2822 + fmt % pcfmt(nump2, numdeltas))
2823 2823 ui.write(('deltas against other : ') + fmt % pcfmt(numother,
2824 2824 numdeltas))
2825 2825
2826 2826 @command('debugrevspec',
2827 2827 [('', 'optimize', None, _('print parsed tree after optimizing'))],
2828 2828 ('REVSPEC'))
2829 2829 def debugrevspec(ui, repo, expr, **opts):
2830 2830 """parse and apply a revision specification
2831 2831
2832 2832 Use --verbose to print the parsed tree before and after aliases
2833 2833 expansion.
2834 2834 """
2835 2835 if ui.verbose:
2836 2836 tree = revset.parse(expr)[0]
2837 2837 ui.note(revset.prettyformat(tree), "\n")
2838 2838 newtree = revset.findaliases(ui, tree)
2839 2839 if newtree != tree:
2840 2840 ui.note(revset.prettyformat(newtree), "\n")
2841 2841 if opts["optimize"]:
2842 2842 weight, optimizedtree = revset.optimize(newtree, True)
2843 2843 ui.note("* optimized:\n", revset.prettyformat(optimizedtree), "\n")
2844 2844 func = revset.match(ui, expr)
2845 2845 for c in func(repo, revset.spanset(repo)):
2846 2846 ui.write("%s\n" % c)
2847 2847
2848 2848 @command('debugsetparents', [], _('REV1 [REV2]'))
2849 2849 def debugsetparents(ui, repo, rev1, rev2=None):
2850 2850 """manually set the parents of the current working directory
2851 2851
2852 2852 This is useful for writing repository conversion tools, but should
2853 2853 be used with care.
2854 2854
2855 2855 Returns 0 on success.
2856 2856 """
2857 2857
2858 2858 r1 = scmutil.revsingle(repo, rev1).node()
2859 2859 r2 = scmutil.revsingle(repo, rev2, 'null').node()
2860 2860
2861 2861 wlock = repo.wlock()
2862 2862 try:
2863 2863 repo.dirstate.beginparentchange()
2864 2864 repo.setparents(r1, r2)
2865 2865 repo.dirstate.endparentchange()
2866 2866 finally:
2867 2867 wlock.release()
2868 2868
2869 2869 @command('debugdirstate|debugstate',
2870 2870 [('', 'nodates', None, _('do not display the saved mtime')),
2871 2871 ('', 'datesort', None, _('sort by saved mtime'))],
2872 2872 _('[OPTION]...'))
2873 2873 def debugstate(ui, repo, nodates=None, datesort=None):
2874 2874 """show the contents of the current dirstate"""
2875 2875 timestr = ""
2876 2876 showdate = not nodates
2877 2877 if datesort:
2878 2878 keyfunc = lambda x: (x[1][3], x[0]) # sort by mtime, then by filename
2879 2879 else:
2880 2880 keyfunc = None # sort by filename
2881 2881 for file_, ent in sorted(repo.dirstate._map.iteritems(), key=keyfunc):
2882 2882 if showdate:
2883 2883 if ent[3] == -1:
2884 2884 # Pad or slice to locale representation
2885 2885 locale_len = len(time.strftime("%Y-%m-%d %H:%M:%S ",
2886 2886 time.localtime(0)))
2887 2887 timestr = 'unset'
2888 2888 timestr = (timestr[:locale_len] +
2889 2889 ' ' * (locale_len - len(timestr)))
2890 2890 else:
2891 2891 timestr = time.strftime("%Y-%m-%d %H:%M:%S ",
2892 2892 time.localtime(ent[3]))
2893 2893 if ent[1] & 020000:
2894 2894 mode = 'lnk'
2895 2895 else:
2896 2896 mode = '%3o' % (ent[1] & 0777 & ~util.umask)
2897 2897 ui.write("%c %s %10d %s%s\n" % (ent[0], mode, ent[2], timestr, file_))
2898 2898 for f in repo.dirstate.copies():
2899 2899 ui.write(_("copy: %s -> %s\n") % (repo.dirstate.copied(f), f))
2900 2900
2901 2901 @command('debugsub',
2902 2902 [('r', 'rev', '',
2903 2903 _('revision to check'), _('REV'))],
2904 2904 _('[-r REV] [REV]'))
2905 2905 def debugsub(ui, repo, rev=None):
2906 2906 ctx = scmutil.revsingle(repo, rev, None)
2907 2907 for k, v in sorted(ctx.substate.items()):
2908 2908 ui.write(('path %s\n') % k)
2909 2909 ui.write((' source %s\n') % v[0])
2910 2910 ui.write((' revision %s\n') % v[1])
2911 2911
2912 2912 @command('debugsuccessorssets',
2913 2913 [],
2914 2914 _('[REV]'))
2915 2915 def debugsuccessorssets(ui, repo, *revs):
2916 2916 """show set of successors for revision
2917 2917
2918 2918 A successors set of changeset A is a consistent group of revisions that
2919 2919 succeed A. It contains non-obsolete changesets only.
2920 2920
2921 2921 In most cases a changeset A has a single successors set containing a single
2922 2922 successor (changeset A replaced by A').
2923 2923
2924 2924 A changeset that is made obsolete with no successors are called "pruned".
2925 2925 Such changesets have no successors sets at all.
2926 2926
2927 2927 A changeset that has been "split" will have a successors set containing
2928 2928 more than one successor.
2929 2929
2930 2930 A changeset that has been rewritten in multiple different ways is called
2931 2931 "divergent". Such changesets have multiple successor sets (each of which
2932 2932 may also be split, i.e. have multiple successors).
2933 2933
2934 2934 Results are displayed as follows::
2935 2935
2936 2936 <rev1>
2937 2937 <successors-1A>
2938 2938 <rev2>
2939 2939 <successors-2A>
2940 2940 <successors-2B1> <successors-2B2> <successors-2B3>
2941 2941
2942 2942 Here rev2 has two possible (i.e. divergent) successors sets. The first
2943 2943 holds one element, whereas the second holds three (i.e. the changeset has
2944 2944 been split).
2945 2945 """
2946 2946 # passed to successorssets caching computation from one call to another
2947 2947 cache = {}
2948 2948 ctx2str = str
2949 2949 node2str = short
2950 2950 if ui.debug():
2951 2951 def ctx2str(ctx):
2952 2952 return ctx.hex()
2953 2953 node2str = hex
2954 2954 for rev in scmutil.revrange(repo, revs):
2955 2955 ctx = repo[rev]
2956 2956 ui.write('%s\n'% ctx2str(ctx))
2957 2957 for succsset in obsolete.successorssets(repo, ctx.node(), cache):
2958 2958 if succsset:
2959 2959 ui.write(' ')
2960 2960 ui.write(node2str(succsset[0]))
2961 2961 for node in succsset[1:]:
2962 2962 ui.write(' ')
2963 2963 ui.write(node2str(node))
2964 2964 ui.write('\n')
2965 2965
2966 2966 @command('debugwalk', walkopts, _('[OPTION]... [FILE]...'), inferrepo=True)
2967 2967 def debugwalk(ui, repo, *pats, **opts):
2968 2968 """show how files match on given patterns"""
2969 2969 m = scmutil.match(repo[None], pats, opts)
2970 2970 items = list(repo.walk(m))
2971 2971 if not items:
2972 2972 return
2973 2973 f = lambda fn: fn
2974 2974 if ui.configbool('ui', 'slash') and os.sep != '/':
2975 2975 f = lambda fn: util.normpath(fn)
2976 2976 fmt = 'f %%-%ds %%-%ds %%s' % (
2977 2977 max([len(abs) for abs in items]),
2978 2978 max([len(m.rel(abs)) for abs in items]))
2979 2979 for abs in items:
2980 2980 line = fmt % (abs, f(m.rel(abs)), m.exact(abs) and 'exact' or '')
2981 2981 ui.write("%s\n" % line.rstrip())
2982 2982
2983 2983 @command('debugwireargs',
2984 2984 [('', 'three', '', 'three'),
2985 2985 ('', 'four', '', 'four'),
2986 2986 ('', 'five', '', 'five'),
2987 2987 ] + remoteopts,
2988 2988 _('REPO [OPTIONS]... [ONE [TWO]]'),
2989 2989 norepo=True)
2990 2990 def debugwireargs(ui, repopath, *vals, **opts):
2991 2991 repo = hg.peer(ui, opts, repopath)
2992 2992 for opt in remoteopts:
2993 2993 del opts[opt[1]]
2994 2994 args = {}
2995 2995 for k, v in opts.iteritems():
2996 2996 if v:
2997 2997 args[k] = v
2998 2998 # run twice to check that we don't mess up the stream for the next command
2999 2999 res1 = repo.debugwireargs(*vals, **args)
3000 3000 res2 = repo.debugwireargs(*vals, **args)
3001 3001 ui.write("%s\n" % res1)
3002 3002 if res1 != res2:
3003 3003 ui.warn("%s\n" % res2)
3004 3004
3005 3005 @command('^diff',
3006 3006 [('r', 'rev', [], _('revision'), _('REV')),
3007 3007 ('c', 'change', '', _('change made by revision'), _('REV'))
3008 3008 ] + diffopts + diffopts2 + walkopts + subrepoopts,
3009 3009 _('[OPTION]... ([-c REV] | [-r REV1 [-r REV2]]) [FILE]...'),
3010 3010 inferrepo=True)
3011 3011 def diff(ui, repo, *pats, **opts):
3012 3012 """diff repository (or selected files)
3013 3013
3014 3014 Show differences between revisions for the specified files.
3015 3015
3016 3016 Differences between files are shown using the unified diff format.
3017 3017
3018 3018 .. note::
3019 3019
3020 3020 diff may generate unexpected results for merges, as it will
3021 3021 default to comparing against the working directory's first
3022 3022 parent changeset if no revisions are specified.
3023 3023
3024 3024 When two revision arguments are given, then changes are shown
3025 3025 between those revisions. If only one revision is specified then
3026 3026 that revision is compared to the working directory, and, when no
3027 3027 revisions are specified, the working directory files are compared
3028 3028 to its parent.
3029 3029
3030 3030 Alternatively you can specify -c/--change with a revision to see
3031 3031 the changes in that changeset relative to its first parent.
3032 3032
3033 3033 Without the -a/--text option, diff will avoid generating diffs of
3034 3034 files it detects as binary. With -a, diff will generate a diff
3035 3035 anyway, probably with undesirable results.
3036 3036
3037 3037 Use the -g/--git option to generate diffs in the git extended diff
3038 3038 format. For more information, read :hg:`help diffs`.
3039 3039
3040 3040 .. container:: verbose
3041 3041
3042 3042 Examples:
3043 3043
3044 3044 - compare a file in the current working directory to its parent::
3045 3045
3046 3046 hg diff foo.c
3047 3047
3048 3048 - compare two historical versions of a directory, with rename info::
3049 3049
3050 3050 hg diff --git -r 1.0:1.2 lib/
3051 3051
3052 3052 - get change stats relative to the last change on some date::
3053 3053
3054 3054 hg diff --stat -r "date('may 2')"
3055 3055
3056 3056 - diff all newly-added files that contain a keyword::
3057 3057
3058 3058 hg diff "set:added() and grep(GNU)"
3059 3059
3060 3060 - compare a revision and its parents::
3061 3061
3062 3062 hg diff -c 9353 # compare against first parent
3063 3063 hg diff -r 9353^:9353 # same using revset syntax
3064 3064 hg diff -r 9353^2:9353 # compare against the second parent
3065 3065
3066 3066 Returns 0 on success.
3067 3067 """
3068 3068
3069 3069 revs = opts.get('rev')
3070 3070 change = opts.get('change')
3071 3071 stat = opts.get('stat')
3072 3072 reverse = opts.get('reverse')
3073 3073
3074 3074 if revs and change:
3075 3075 msg = _('cannot specify --rev and --change at the same time')
3076 3076 raise util.Abort(msg)
3077 3077 elif change:
3078 3078 node2 = scmutil.revsingle(repo, change, None).node()
3079 3079 node1 = repo[node2].p1().node()
3080 3080 else:
3081 3081 node1, node2 = scmutil.revpair(repo, revs)
3082 3082
3083 3083 if reverse:
3084 3084 node1, node2 = node2, node1
3085 3085
3086 3086 diffopts = patch.diffopts(ui, opts)
3087 3087 m = scmutil.match(repo[node2], pats, opts)
3088 3088 cmdutil.diffordiffstat(ui, repo, diffopts, node1, node2, m, stat=stat,
3089 3089 listsubrepos=opts.get('subrepos'))
3090 3090
3091 3091 @command('^export',
3092 3092 [('o', 'output', '',
3093 3093 _('print output to file with formatted name'), _('FORMAT')),
3094 3094 ('', 'switch-parent', None, _('diff against the second parent')),
3095 3095 ('r', 'rev', [], _('revisions to export'), _('REV')),
3096 3096 ] + diffopts,
3097 3097 _('[OPTION]... [-o OUTFILESPEC] [-r] [REV]...'))
3098 3098 def export(ui, repo, *changesets, **opts):
3099 3099 """dump the header and diffs for one or more changesets
3100 3100
3101 3101 Print the changeset header and diffs for one or more revisions.
3102 3102 If no revision is given, the parent of the working directory is used.
3103 3103
3104 3104 The information shown in the changeset header is: author, date,
3105 3105 branch name (if non-default), changeset hash, parent(s) and commit
3106 3106 comment.
3107 3107
3108 3108 .. note::
3109 3109
3110 3110 export may generate unexpected diff output for merge
3111 3111 changesets, as it will compare the merge changeset against its
3112 3112 first parent only.
3113 3113
3114 3114 Output may be to a file, in which case the name of the file is
3115 3115 given using a format string. The formatting rules are as follows:
3116 3116
3117 3117 :``%%``: literal "%" character
3118 3118 :``%H``: changeset hash (40 hexadecimal digits)
3119 3119 :``%N``: number of patches being generated
3120 3120 :``%R``: changeset revision number
3121 3121 :``%b``: basename of the exporting repository
3122 3122 :``%h``: short-form changeset hash (12 hexadecimal digits)
3123 3123 :``%m``: first line of the commit message (only alphanumeric characters)
3124 3124 :``%n``: zero-padded sequence number, starting at 1
3125 3125 :``%r``: zero-padded changeset revision number
3126 3126
3127 3127 Without the -a/--text option, export will avoid generating diffs
3128 3128 of files it detects as binary. With -a, export will generate a
3129 3129 diff anyway, probably with undesirable results.
3130 3130
3131 3131 Use the -g/--git option to generate diffs in the git extended diff
3132 3132 format. See :hg:`help diffs` for more information.
3133 3133
3134 3134 With the --switch-parent option, the diff will be against the
3135 3135 second parent. It can be useful to review a merge.
3136 3136
3137 3137 .. container:: verbose
3138 3138
3139 3139 Examples:
3140 3140
3141 3141 - use export and import to transplant a bugfix to the current
3142 3142 branch::
3143 3143
3144 3144 hg export -r 9353 | hg import -
3145 3145
3146 3146 - export all the changesets between two revisions to a file with
3147 3147 rename information::
3148 3148
3149 3149 hg export --git -r 123:150 > changes.txt
3150 3150
3151 3151 - split outgoing changes into a series of patches with
3152 3152 descriptive names::
3153 3153
3154 3154 hg export -r "outgoing()" -o "%n-%m.patch"
3155 3155
3156 3156 Returns 0 on success.
3157 3157 """
3158 3158 changesets += tuple(opts.get('rev', []))
3159 3159 if not changesets:
3160 3160 changesets = ['.']
3161 3161 revs = scmutil.revrange(repo, changesets)
3162 3162 if not revs:
3163 3163 raise util.Abort(_("export requires at least one changeset"))
3164 3164 if len(revs) > 1:
3165 3165 ui.note(_('exporting patches:\n'))
3166 3166 else:
3167 3167 ui.note(_('exporting patch:\n'))
3168 3168 cmdutil.export(repo, revs, template=opts.get('output'),
3169 3169 switch_parent=opts.get('switch_parent'),
3170 3170 opts=patch.diffopts(ui, opts))
3171 3171
3172 3172 @command('files',
3173 3173 [('r', 'rev', '', _('search the repository as it is in REV'), _('REV')),
3174 3174 ('0', 'print0', None, _('end filenames with NUL, for use with xargs')),
3175 3175 ] + walkopts + formatteropts,
3176 3176 _('[OPTION]... [PATTERN]...'))
3177 3177 def files(ui, repo, *pats, **opts):
3178 3178 """list tracked files
3179 3179
3180 3180 Print files under Mercurial control in the working directory or
3181 3181 specified revision whose names match the given patterns (excluding
3182 3182 removed files).
3183 3183
3184 3184 If no patterns are given to match, this command prints the names
3185 3185 of all files under Mercurial control in the working copy.
3186 3186
3187 3187 .. container:: verbose
3188 3188
3189 3189 Examples:
3190 3190
3191 3191 - list all files under the current directory::
3192 3192
3193 3193 hg files .
3194 3194
3195 3195 - shows sizes and flags for current revision::
3196 3196
3197 3197 hg files -vr .
3198 3198
3199 3199 - list all files named README::
3200 3200
3201 3201 hg files -I "**/README"
3202 3202
3203 3203 - list all binary files::
3204 3204
3205 3205 hg files "set:binary()"
3206 3206
3207 3207 - find files containing a regular expression::
3208 3208
3209 3209 hg files "set:grep('bob')"
3210 3210
3211 3211 - search tracked file contents with xargs and grep::
3212 3212
3213 3213 hg files -0 | xargs -0 grep foo
3214 3214
3215 3215 See :hg:`help pattern` and :hg:`help filesets` for more information
3216 3216 on specifying file patterns.
3217 3217
3218 3218 Returns 0 if a match is found, 1 otherwise.
3219 3219
3220 3220 """
3221 3221 ctx = scmutil.revsingle(repo, opts.get('rev'), None)
3222 3222 rev = ctx.rev()
3223 3223 ret = 1
3224 3224
3225 3225 end = '\n'
3226 3226 if opts.get('print0'):
3227 3227 end = '\0'
3228 3228 fm = ui.formatter('files', opts)
3229 3229 fmt = '%s' + end
3230 3230
3231 3231 m = scmutil.match(ctx, pats, opts)
3232 3232 ds = repo.dirstate
3233 3233 for f in ctx.matches(m):
3234 3234 if rev is None and ds[f] == 'r':
3235 3235 continue
3236 3236 fm.startitem()
3237 3237 if ui.verbose:
3238 3238 fc = ctx[f]
3239 3239 fm.write('size flags', '% 10d % 1s ', fc.size(), fc.flags())
3240 3240 fm.data(abspath=f)
3241 3241 fm.write('path', fmt, m.rel(f))
3242 3242 ret = 0
3243 3243
3244 3244 fm.end()
3245 3245
3246 3246 return ret
3247 3247
3248 3248 @command('^forget', walkopts, _('[OPTION]... FILE...'), inferrepo=True)
3249 3249 def forget(ui, repo, *pats, **opts):
3250 3250 """forget the specified files on the next commit
3251 3251
3252 3252 Mark the specified files so they will no longer be tracked
3253 3253 after the next commit.
3254 3254
3255 3255 This only removes files from the current branch, not from the
3256 3256 entire project history, and it does not delete them from the
3257 3257 working directory.
3258 3258
3259 3259 To undo a forget before the next commit, see :hg:`add`.
3260 3260
3261 3261 .. container:: verbose
3262 3262
3263 3263 Examples:
3264 3264
3265 3265 - forget newly-added binary files::
3266 3266
3267 3267 hg forget "set:added() and binary()"
3268 3268
3269 3269 - forget files that would be excluded by .hgignore::
3270 3270
3271 3271 hg forget "set:hgignore()"
3272 3272
3273 3273 Returns 0 on success.
3274 3274 """
3275 3275
3276 3276 if not pats:
3277 3277 raise util.Abort(_('no files specified'))
3278 3278
3279 3279 m = scmutil.match(repo[None], pats, opts)
3280 3280 rejected = cmdutil.forget(ui, repo, m, prefix="", explicitonly=False)[0]
3281 3281 return rejected and 1 or 0
3282 3282
3283 3283 @command(
3284 3284 'graft',
3285 3285 [('r', 'rev', [], _('revisions to graft'), _('REV')),
3286 3286 ('c', 'continue', False, _('resume interrupted graft')),
3287 3287 ('e', 'edit', False, _('invoke editor on commit messages')),
3288 3288 ('', 'log', None, _('append graft info to log message')),
3289 3289 ('f', 'force', False, _('force graft')),
3290 3290 ('D', 'currentdate', False,
3291 3291 _('record the current date as commit date')),
3292 3292 ('U', 'currentuser', False,
3293 3293 _('record the current user as committer'), _('DATE'))]
3294 3294 + commitopts2 + mergetoolopts + dryrunopts,
3295 3295 _('[OPTION]... [-r] REV...'))
3296 3296 def graft(ui, repo, *revs, **opts):
3297 3297 '''copy changes from other branches onto the current branch
3298 3298
3299 3299 This command uses Mercurial's merge logic to copy individual
3300 3300 changes from other branches without merging branches in the
3301 3301 history graph. This is sometimes known as 'backporting' or
3302 3302 'cherry-picking'. By default, graft will copy user, date, and
3303 3303 description from the source changesets.
3304 3304
3305 3305 Changesets that are ancestors of the current revision, that have
3306 3306 already been grafted, or that are merges will be skipped.
3307 3307
3308 3308 If --log is specified, log messages will have a comment appended
3309 3309 of the form::
3310 3310
3311 3311 (grafted from CHANGESETHASH)
3312 3312
3313 3313 If --force is specified, revisions will be grafted even if they
3314 3314 are already ancestors of or have been grafted to the destination.
3315 3315 This is useful when the revisions have since been backed out.
3316 3316
3317 3317 If a graft merge results in conflicts, the graft process is
3318 3318 interrupted so that the current merge can be manually resolved.
3319 3319 Once all conflicts are addressed, the graft process can be
3320 3320 continued with the -c/--continue option.
3321 3321
3322 3322 .. note::
3323 3323
3324 3324 The -c/--continue option does not reapply earlier options, except
3325 3325 for --force.
3326 3326
3327 3327 .. container:: verbose
3328 3328
3329 3329 Examples:
3330 3330
3331 3331 - copy a single change to the stable branch and edit its description::
3332 3332
3333 3333 hg update stable
3334 3334 hg graft --edit 9393
3335 3335
3336 3336 - graft a range of changesets with one exception, updating dates::
3337 3337
3338 3338 hg graft -D "2085::2093 and not 2091"
3339 3339
3340 3340 - continue a graft after resolving conflicts::
3341 3341
3342 3342 hg graft -c
3343 3343
3344 3344 - show the source of a grafted changeset::
3345 3345
3346 3346 hg log --debug -r .
3347 3347
3348 3348 See :hg:`help revisions` and :hg:`help revsets` for more about
3349 3349 specifying revisions.
3350 3350
3351 3351 Returns 0 on successful completion.
3352 3352 '''
3353 3353
3354 3354 revs = list(revs)
3355 3355 revs.extend(opts['rev'])
3356 3356
3357 3357 if not opts.get('user') and opts.get('currentuser'):
3358 3358 opts['user'] = ui.username()
3359 3359 if not opts.get('date') and opts.get('currentdate'):
3360 3360 opts['date'] = "%d %d" % util.makedate()
3361 3361
3362 3362 editor = cmdutil.getcommiteditor(editform='graft', **opts)
3363 3363
3364 3364 cont = False
3365 3365 if opts['continue']:
3366 3366 cont = True
3367 3367 if revs:
3368 3368 raise util.Abort(_("can't specify --continue and revisions"))
3369 3369 # read in unfinished revisions
3370 3370 try:
3371 3371 nodes = repo.opener.read('graftstate').splitlines()
3372 3372 revs = [repo[node].rev() for node in nodes]
3373 3373 except IOError, inst:
3374 3374 if inst.errno != errno.ENOENT:
3375 3375 raise
3376 3376 raise util.Abort(_("no graft state found, can't continue"))
3377 3377 else:
3378 3378 cmdutil.checkunfinished(repo)
3379 3379 cmdutil.bailifchanged(repo)
3380 3380 if not revs:
3381 3381 raise util.Abort(_('no revisions specified'))
3382 3382 revs = scmutil.revrange(repo, revs)
3383 3383
3384 3384 skipped = set()
3385 3385 # check for merges
3386 3386 for rev in repo.revs('%ld and merge()', revs):
3387 3387 ui.warn(_('skipping ungraftable merge revision %s\n') % rev)
3388 3388 skipped.add(rev)
3389 3389 revs = [r for r in revs if r not in skipped]
3390 3390 if not revs:
3391 3391 return -1
3392 3392
3393 3393 # Don't check in the --continue case, in effect retaining --force across
3394 3394 # --continues. That's because without --force, any revisions we decided to
3395 3395 # skip would have been filtered out here, so they wouldn't have made their
3396 3396 # way to the graftstate. With --force, any revisions we would have otherwise
3397 3397 # skipped would not have been filtered out, and if they hadn't been applied
3398 3398 # already, they'd have been in the graftstate.
3399 3399 if not (cont or opts.get('force')):
3400 3400 # check for ancestors of dest branch
3401 3401 crev = repo['.'].rev()
3402 3402 ancestors = repo.changelog.ancestors([crev], inclusive=True)
3403 3403 # Cannot use x.remove(y) on smart set, this has to be a list.
3404 3404 # XXX make this lazy in the future
3405 3405 revs = list(revs)
3406 3406 # don't mutate while iterating, create a copy
3407 3407 for rev in list(revs):
3408 3408 if rev in ancestors:
3409 3409 ui.warn(_('skipping ancestor revision %s\n') % rev)
3410 3410 # XXX remove on list is slow
3411 3411 revs.remove(rev)
3412 3412 if not revs:
3413 3413 return -1
3414 3414
3415 3415 # analyze revs for earlier grafts
3416 3416 ids = {}
3417 3417 for ctx in repo.set("%ld", revs):
3418 3418 ids[ctx.hex()] = ctx.rev()
3419 3419 n = ctx.extra().get('source')
3420 3420 if n:
3421 3421 ids[n] = ctx.rev()
3422 3422
3423 3423 # check ancestors for earlier grafts
3424 3424 ui.debug('scanning for duplicate grafts\n')
3425 3425
3426 3426 for rev in repo.changelog.findmissingrevs(revs, [crev]):
3427 3427 ctx = repo[rev]
3428 3428 n = ctx.extra().get('source')
3429 3429 if n in ids:
3430 3430 try:
3431 3431 r = repo[n].rev()
3432 3432 except error.RepoLookupError:
3433 3433 r = None
3434 3434 if r in revs:
3435 3435 ui.warn(_('skipping revision %s (already grafted to %s)\n')
3436 3436 % (r, rev))
3437 3437 revs.remove(r)
3438 3438 elif ids[n] in revs:
3439 3439 if r is None:
3440 3440 ui.warn(_('skipping already grafted revision %s '
3441 3441 '(%s also has unknown origin %s)\n')
3442 3442 % (ids[n], rev, n))
3443 3443 else:
3444 3444 ui.warn(_('skipping already grafted revision %s '
3445 3445 '(%s also has origin %d)\n')
3446 3446 % (ids[n], rev, r))
3447 3447 revs.remove(ids[n])
3448 3448 elif ctx.hex() in ids:
3449 3449 r = ids[ctx.hex()]
3450 3450 ui.warn(_('skipping already grafted revision %s '
3451 3451 '(was grafted from %d)\n') % (r, rev))
3452 3452 revs.remove(r)
3453 3453 if not revs:
3454 3454 return -1
3455 3455
3456 3456 wlock = repo.wlock()
3457 3457 try:
3458 3458 for pos, ctx in enumerate(repo.set("%ld", revs)):
3459 3459
3460 3460 ui.status(_('grafting revision %s\n') % ctx.rev())
3461 3461 if opts.get('dry_run'):
3462 3462 continue
3463 3463
3464 3464 source = ctx.extra().get('source')
3465 3465 if not source:
3466 3466 source = ctx.hex()
3467 3467 extra = {'source': source}
3468 3468 user = ctx.user()
3469 3469 if opts.get('user'):
3470 3470 user = opts['user']
3471 3471 date = ctx.date()
3472 3472 if opts.get('date'):
3473 3473 date = opts['date']
3474 3474 message = ctx.description()
3475 3475 if opts.get('log'):
3476 3476 message += '\n(grafted from %s)' % ctx.hex()
3477 3477
3478 3478 # we don't merge the first commit when continuing
3479 3479 if not cont:
3480 3480 # perform the graft merge with p1(rev) as 'ancestor'
3481 3481 try:
3482 3482 # ui.forcemerge is an internal variable, do not document
3483 3483 repo.ui.setconfig('ui', 'forcemerge', opts.get('tool', ''),
3484 3484 'graft')
3485 3485 stats = mergemod.graft(repo, ctx, ctx.p1(),
3486 3486 ['local', 'graft'])
3487 3487 finally:
3488 3488 repo.ui.setconfig('ui', 'forcemerge', '', 'graft')
3489 3489 # report any conflicts
3490 3490 if stats and stats[3] > 0:
3491 3491 # write out state for --continue
3492 3492 nodelines = [repo[rev].hex() + "\n" for rev in revs[pos:]]
3493 3493 repo.opener.write('graftstate', ''.join(nodelines))
3494 3494 raise util.Abort(
3495 3495 _("unresolved conflicts, can't continue"),
3496 3496 hint=_('use hg resolve and hg graft --continue'))
3497 3497 else:
3498 3498 cont = False
3499 3499
3500 3500 # commit
3501 3501 node = repo.commit(text=message, user=user,
3502 3502 date=date, extra=extra, editor=editor)
3503 3503 if node is None:
3504 3504 ui.status(_('graft for revision %s is empty\n') % ctx.rev())
3505 3505 finally:
3506 3506 wlock.release()
3507 3507
3508 3508 # remove state when we complete successfully
3509 3509 if not opts.get('dry_run'):
3510 3510 util.unlinkpath(repo.join('graftstate'), ignoremissing=True)
3511 3511
3512 3512 return 0
3513 3513
3514 3514 @command('grep',
3515 3515 [('0', 'print0', None, _('end fields with NUL')),
3516 3516 ('', 'all', None, _('print all revisions that match')),
3517 3517 ('a', 'text', None, _('treat all files as text')),
3518 3518 ('f', 'follow', None,
3519 3519 _('follow changeset history,'
3520 3520 ' or file history across copies and renames')),
3521 3521 ('i', 'ignore-case', None, _('ignore case when matching')),
3522 3522 ('l', 'files-with-matches', None,
3523 3523 _('print only filenames and revisions that match')),
3524 3524 ('n', 'line-number', None, _('print matching line numbers')),
3525 3525 ('r', 'rev', [],
3526 3526 _('only search files changed within revision range'), _('REV')),
3527 3527 ('u', 'user', None, _('list the author (long with -v)')),
3528 3528 ('d', 'date', None, _('list the date (short with -q)')),
3529 3529 ] + walkopts,
3530 3530 _('[OPTION]... PATTERN [FILE]...'),
3531 3531 inferrepo=True)
3532 3532 def grep(ui, repo, pattern, *pats, **opts):
3533 3533 """search for a pattern in specified files and revisions
3534 3534
3535 3535 Search revisions of files for a regular expression.
3536 3536
3537 3537 This command behaves differently than Unix grep. It only accepts
3538 3538 Python/Perl regexps. It searches repository history, not the
3539 3539 working directory. It always prints the revision number in which a
3540 3540 match appears.
3541 3541
3542 3542 By default, grep only prints output for the first revision of a
3543 3543 file in which it finds a match. To get it to print every revision
3544 3544 that contains a change in match status ("-" for a match that
3545 3545 becomes a non-match, or "+" for a non-match that becomes a match),
3546 3546 use the --all flag.
3547 3547
3548 3548 Returns 0 if a match is found, 1 otherwise.
3549 3549 """
3550 3550 reflags = re.M
3551 3551 if opts.get('ignore_case'):
3552 3552 reflags |= re.I
3553 3553 try:
3554 3554 regexp = util.re.compile(pattern, reflags)
3555 3555 except re.error, inst:
3556 3556 ui.warn(_("grep: invalid match pattern: %s\n") % inst)
3557 3557 return 1
3558 3558 sep, eol = ':', '\n'
3559 3559 if opts.get('print0'):
3560 3560 sep = eol = '\0'
3561 3561
3562 3562 getfile = util.lrucachefunc(repo.file)
3563 3563
3564 3564 def matchlines(body):
3565 3565 begin = 0
3566 3566 linenum = 0
3567 3567 while begin < len(body):
3568 3568 match = regexp.search(body, begin)
3569 3569 if not match:
3570 3570 break
3571 3571 mstart, mend = match.span()
3572 3572 linenum += body.count('\n', begin, mstart) + 1
3573 3573 lstart = body.rfind('\n', begin, mstart) + 1 or begin
3574 3574 begin = body.find('\n', mend) + 1 or len(body) + 1
3575 3575 lend = begin - 1
3576 3576 yield linenum, mstart - lstart, mend - lstart, body[lstart:lend]
3577 3577
3578 3578 class linestate(object):
3579 3579 def __init__(self, line, linenum, colstart, colend):
3580 3580 self.line = line
3581 3581 self.linenum = linenum
3582 3582 self.colstart = colstart
3583 3583 self.colend = colend
3584 3584
3585 3585 def __hash__(self):
3586 3586 return hash((self.linenum, self.line))
3587 3587
3588 3588 def __eq__(self, other):
3589 3589 return self.line == other.line
3590 3590
3591 3591 def __iter__(self):
3592 3592 yield (self.line[:self.colstart], '')
3593 3593 yield (self.line[self.colstart:self.colend], 'grep.match')
3594 3594 rest = self.line[self.colend:]
3595 3595 while rest != '':
3596 3596 match = regexp.search(rest)
3597 3597 if not match:
3598 3598 yield (rest, '')
3599 3599 break
3600 3600 mstart, mend = match.span()
3601 3601 yield (rest[:mstart], '')
3602 3602 yield (rest[mstart:mend], 'grep.match')
3603 3603 rest = rest[mend:]
3604 3604
3605 3605 matches = {}
3606 3606 copies = {}
3607 3607 def grepbody(fn, rev, body):
3608 3608 matches[rev].setdefault(fn, [])
3609 3609 m = matches[rev][fn]
3610 3610 for lnum, cstart, cend, line in matchlines(body):
3611 3611 s = linestate(line, lnum, cstart, cend)
3612 3612 m.append(s)
3613 3613
3614 3614 def difflinestates(a, b):
3615 3615 sm = difflib.SequenceMatcher(None, a, b)
3616 3616 for tag, alo, ahi, blo, bhi in sm.get_opcodes():
3617 3617 if tag == 'insert':
3618 3618 for i in xrange(blo, bhi):
3619 3619 yield ('+', b[i])
3620 3620 elif tag == 'delete':
3621 3621 for i in xrange(alo, ahi):
3622 3622 yield ('-', a[i])
3623 3623 elif tag == 'replace':
3624 3624 for i in xrange(alo, ahi):
3625 3625 yield ('-', a[i])
3626 3626 for i in xrange(blo, bhi):
3627 3627 yield ('+', b[i])
3628 3628
3629 3629 def display(fn, ctx, pstates, states):
3630 3630 rev = ctx.rev()
3631 3631 datefunc = ui.quiet and util.shortdate or util.datestr
3632 3632 found = False
3633 3633 @util.cachefunc
3634 3634 def binary():
3635 3635 flog = getfile(fn)
3636 3636 return util.binary(flog.read(ctx.filenode(fn)))
3637 3637
3638 3638 if opts.get('all'):
3639 3639 iter = difflinestates(pstates, states)
3640 3640 else:
3641 3641 iter = [('', l) for l in states]
3642 3642 for change, l in iter:
3643 3643 cols = [(fn, 'grep.filename'), (str(rev), 'grep.rev')]
3644 3644
3645 3645 if opts.get('line_number'):
3646 3646 cols.append((str(l.linenum), 'grep.linenumber'))
3647 3647 if opts.get('all'):
3648 3648 cols.append((change, 'grep.change'))
3649 3649 if opts.get('user'):
3650 3650 cols.append((ui.shortuser(ctx.user()), 'grep.user'))
3651 3651 if opts.get('date'):
3652 3652 cols.append((datefunc(ctx.date()), 'grep.date'))
3653 3653 for col, label in cols[:-1]:
3654 3654 ui.write(col, label=label)
3655 3655 ui.write(sep, label='grep.sep')
3656 3656 ui.write(cols[-1][0], label=cols[-1][1])
3657 3657 if not opts.get('files_with_matches'):
3658 3658 ui.write(sep, label='grep.sep')
3659 3659 if not opts.get('text') and binary():
3660 3660 ui.write(" Binary file matches")
3661 3661 else:
3662 3662 for s, label in l:
3663 3663 ui.write(s, label=label)
3664 3664 ui.write(eol)
3665 3665 found = True
3666 3666 if opts.get('files_with_matches'):
3667 3667 break
3668 3668 return found
3669 3669
3670 3670 skip = {}
3671 3671 revfiles = {}
3672 3672 matchfn = scmutil.match(repo[None], pats, opts)
3673 3673 found = False
3674 3674 follow = opts.get('follow')
3675 3675
3676 3676 def prep(ctx, fns):
3677 3677 rev = ctx.rev()
3678 3678 pctx = ctx.p1()
3679 3679 parent = pctx.rev()
3680 3680 matches.setdefault(rev, {})
3681 3681 matches.setdefault(parent, {})
3682 3682 files = revfiles.setdefault(rev, [])
3683 3683 for fn in fns:
3684 3684 flog = getfile(fn)
3685 3685 try:
3686 3686 fnode = ctx.filenode(fn)
3687 3687 except error.LookupError:
3688 3688 continue
3689 3689
3690 3690 copied = flog.renamed(fnode)
3691 3691 copy = follow and copied and copied[0]
3692 3692 if copy:
3693 3693 copies.setdefault(rev, {})[fn] = copy
3694 3694 if fn in skip:
3695 3695 if copy:
3696 3696 skip[copy] = True
3697 3697 continue
3698 3698 files.append(fn)
3699 3699
3700 3700 if fn not in matches[rev]:
3701 3701 grepbody(fn, rev, flog.read(fnode))
3702 3702
3703 3703 pfn = copy or fn
3704 3704 if pfn not in matches[parent]:
3705 3705 try:
3706 3706 fnode = pctx.filenode(pfn)
3707 3707 grepbody(pfn, parent, flog.read(fnode))
3708 3708 except error.LookupError:
3709 3709 pass
3710 3710
3711 3711 for ctx in cmdutil.walkchangerevs(repo, matchfn, opts, prep):
3712 3712 rev = ctx.rev()
3713 3713 parent = ctx.p1().rev()
3714 3714 for fn in sorted(revfiles.get(rev, [])):
3715 3715 states = matches[rev][fn]
3716 3716 copy = copies.get(rev, {}).get(fn)
3717 3717 if fn in skip:
3718 3718 if copy:
3719 3719 skip[copy] = True
3720 3720 continue
3721 3721 pstates = matches.get(parent, {}).get(copy or fn, [])
3722 3722 if pstates or states:
3723 3723 r = display(fn, ctx, pstates, states)
3724 3724 found = found or r
3725 3725 if r and not opts.get('all'):
3726 3726 skip[fn] = True
3727 3727 if copy:
3728 3728 skip[copy] = True
3729 3729 del matches[rev]
3730 3730 del revfiles[rev]
3731 3731
3732 3732 return not found
3733 3733
3734 3734 @command('heads',
3735 3735 [('r', 'rev', '',
3736 3736 _('show only heads which are descendants of STARTREV'), _('STARTREV')),
3737 3737 ('t', 'topo', False, _('show topological heads only')),
3738 3738 ('a', 'active', False, _('show active branchheads only (DEPRECATED)')),
3739 3739 ('c', 'closed', False, _('show normal and closed branch heads')),
3740 3740 ] + templateopts,
3741 3741 _('[-ct] [-r STARTREV] [REV]...'))
3742 3742 def heads(ui, repo, *branchrevs, **opts):
3743 3743 """show branch heads
3744 3744
3745 3745 With no arguments, show all open branch heads in the repository.
3746 3746 Branch heads are changesets that have no descendants on the
3747 3747 same branch. They are where development generally takes place and
3748 3748 are the usual targets for update and merge operations.
3749 3749
3750 3750 If one or more REVs are given, only open branch heads on the
3751 3751 branches associated with the specified changesets are shown. This
3752 3752 means that you can use :hg:`heads .` to see the heads on the
3753 3753 currently checked-out branch.
3754 3754
3755 3755 If -c/--closed is specified, also show branch heads marked closed
3756 3756 (see :hg:`commit --close-branch`).
3757 3757
3758 3758 If STARTREV is specified, only those heads that are descendants of
3759 3759 STARTREV will be displayed.
3760 3760
3761 3761 If -t/--topo is specified, named branch mechanics will be ignored and only
3762 3762 topological heads (changesets with no children) will be shown.
3763 3763
3764 3764 Returns 0 if matching heads are found, 1 if not.
3765 3765 """
3766 3766
3767 3767 start = None
3768 3768 if 'rev' in opts:
3769 3769 start = scmutil.revsingle(repo, opts['rev'], None).node()
3770 3770
3771 3771 if opts.get('topo'):
3772 3772 heads = [repo[h] for h in repo.heads(start)]
3773 3773 else:
3774 3774 heads = []
3775 3775 for branch in repo.branchmap():
3776 3776 heads += repo.branchheads(branch, start, opts.get('closed'))
3777 3777 heads = [repo[h] for h in heads]
3778 3778
3779 3779 if branchrevs:
3780 3780 branches = set(repo[br].branch() for br in branchrevs)
3781 3781 heads = [h for h in heads if h.branch() in branches]
3782 3782
3783 3783 if opts.get('active') and branchrevs:
3784 3784 dagheads = repo.heads(start)
3785 3785 heads = [h for h in heads if h.node() in dagheads]
3786 3786
3787 3787 if branchrevs:
3788 3788 haveheads = set(h.branch() for h in heads)
3789 3789 if branches - haveheads:
3790 3790 headless = ', '.join(b for b in branches - haveheads)
3791 3791 msg = _('no open branch heads found on branches %s')
3792 3792 if opts.get('rev'):
3793 3793 msg += _(' (started at %s)') % opts['rev']
3794 3794 ui.warn((msg + '\n') % headless)
3795 3795
3796 3796 if not heads:
3797 3797 return 1
3798 3798
3799 3799 heads = sorted(heads, key=lambda x: -x.rev())
3800 3800 displayer = cmdutil.show_changeset(ui, repo, opts)
3801 3801 for ctx in heads:
3802 3802 displayer.show(ctx)
3803 3803 displayer.close()
3804 3804
3805 3805 @command('help',
3806 3806 [('e', 'extension', None, _('show only help for extensions')),
3807 3807 ('c', 'command', None, _('show only help for commands')),
3808 3808 ('k', 'keyword', '', _('show topics matching keyword')),
3809 3809 ],
3810 3810 _('[-ec] [TOPIC]'),
3811 3811 norepo=True)
3812 3812 def help_(ui, name=None, **opts):
3813 3813 """show help for a given topic or a help overview
3814 3814
3815 3815 With no arguments, print a list of commands with short help messages.
3816 3816
3817 3817 Given a topic, extension, or command name, print help for that
3818 3818 topic.
3819 3819
3820 3820 Returns 0 if successful.
3821 3821 """
3822 3822
3823 3823 textwidth = min(ui.termwidth(), 80) - 2
3824 3824
3825 3825 keep = []
3826 3826 if ui.verbose:
3827 3827 keep.append('verbose')
3828 3828 if sys.platform.startswith('win'):
3829 3829 keep.append('windows')
3830 3830 elif sys.platform == 'OpenVMS':
3831 3831 keep.append('vms')
3832 3832 elif sys.platform == 'plan9':
3833 3833 keep.append('plan9')
3834 3834 else:
3835 3835 keep.append('unix')
3836 3836 keep.append(sys.platform.lower())
3837 3837
3838 3838 section = None
3839 3839 if name and '.' in name:
3840 3840 name, section = name.split('.', 1)
3841 3841
3842 3842 text = help.help_(ui, name, **opts)
3843 3843
3844 3844 formatted, pruned = minirst.format(text, textwidth, keep=keep,
3845 3845 section=section)
3846 3846 if section and not formatted:
3847 3847 raise util.Abort(_("help section not found"))
3848 3848
3849 3849 if 'verbose' in pruned:
3850 3850 keep.append('omitted')
3851 3851 else:
3852 3852 keep.append('notomitted')
3853 3853 formatted, pruned = minirst.format(text, textwidth, keep=keep,
3854 3854 section=section)
3855 3855 ui.write(formatted)
3856 3856
3857 3857
3858 3858 @command('identify|id',
3859 3859 [('r', 'rev', '',
3860 3860 _('identify the specified revision'), _('REV')),
3861 3861 ('n', 'num', None, _('show local revision number')),
3862 3862 ('i', 'id', None, _('show global revision id')),
3863 3863 ('b', 'branch', None, _('show branch')),
3864 3864 ('t', 'tags', None, _('show tags')),
3865 3865 ('B', 'bookmarks', None, _('show bookmarks')),
3866 3866 ] + remoteopts,
3867 3867 _('[-nibtB] [-r REV] [SOURCE]'),
3868 3868 optionalrepo=True)
3869 3869 def identify(ui, repo, source=None, rev=None,
3870 3870 num=None, id=None, branch=None, tags=None, bookmarks=None, **opts):
3871 3871 """identify the working copy or specified revision
3872 3872
3873 3873 Print a summary identifying the repository state at REV using one or
3874 3874 two parent hash identifiers, followed by a "+" if the working
3875 3875 directory has uncommitted changes, the branch name (if not default),
3876 3876 a list of tags, and a list of bookmarks.
3877 3877
3878 3878 When REV is not given, print a summary of the current state of the
3879 3879 repository.
3880 3880
3881 3881 Specifying a path to a repository root or Mercurial bundle will
3882 3882 cause lookup to operate on that repository/bundle.
3883 3883
3884 3884 .. container:: verbose
3885 3885
3886 3886 Examples:
3887 3887
3888 3888 - generate a build identifier for the working directory::
3889 3889
3890 3890 hg id --id > build-id.dat
3891 3891
3892 3892 - find the revision corresponding to a tag::
3893 3893
3894 3894 hg id -n -r 1.3
3895 3895
3896 3896 - check the most recent revision of a remote repository::
3897 3897
3898 3898 hg id -r tip http://selenic.com/hg/
3899 3899
3900 3900 Returns 0 if successful.
3901 3901 """
3902 3902
3903 3903 if not repo and not source:
3904 3904 raise util.Abort(_("there is no Mercurial repository here "
3905 3905 "(.hg not found)"))
3906 3906
3907 3907 hexfunc = ui.debugflag and hex or short
3908 3908 default = not (num or id or branch or tags or bookmarks)
3909 3909 output = []
3910 3910 revs = []
3911 3911
3912 3912 if source:
3913 3913 source, branches = hg.parseurl(ui.expandpath(source))
3914 3914 peer = hg.peer(repo or ui, opts, source) # only pass ui when no repo
3915 3915 repo = peer.local()
3916 3916 revs, checkout = hg.addbranchrevs(repo, peer, branches, None)
3917 3917
3918 3918 if not repo:
3919 3919 if num or branch or tags:
3920 3920 raise util.Abort(
3921 3921 _("can't query remote revision number, branch, or tags"))
3922 3922 if not rev and revs:
3923 3923 rev = revs[0]
3924 3924 if not rev:
3925 3925 rev = "tip"
3926 3926
3927 3927 remoterev = peer.lookup(rev)
3928 3928 if default or id:
3929 3929 output = [hexfunc(remoterev)]
3930 3930
3931 3931 def getbms():
3932 3932 bms = []
3933 3933
3934 3934 if 'bookmarks' in peer.listkeys('namespaces'):
3935 3935 hexremoterev = hex(remoterev)
3936 3936 bms = [bm for bm, bmr in peer.listkeys('bookmarks').iteritems()
3937 3937 if bmr == hexremoterev]
3938 3938
3939 3939 return sorted(bms)
3940 3940
3941 3941 if bookmarks:
3942 3942 output.extend(getbms())
3943 3943 elif default and not ui.quiet:
3944 3944 # multiple bookmarks for a single parent separated by '/'
3945 3945 bm = '/'.join(getbms())
3946 3946 if bm:
3947 3947 output.append(bm)
3948 3948 else:
3949 3949 if not rev:
3950 3950 ctx = repo[None]
3951 3951 parents = ctx.parents()
3952 3952 changed = ""
3953 3953 if default or id or num:
3954 3954 if (util.any(repo.status())
3955 3955 or util.any(ctx.sub(s).dirty() for s in ctx.substate)):
3956 3956 changed = '+'
3957 3957 if default or id:
3958 3958 output = ["%s%s" %
3959 3959 ('+'.join([hexfunc(p.node()) for p in parents]), changed)]
3960 3960 if num:
3961 3961 output.append("%s%s" %
3962 3962 ('+'.join([str(p.rev()) for p in parents]), changed))
3963 3963 else:
3964 3964 ctx = scmutil.revsingle(repo, rev)
3965 3965 if default or id:
3966 3966 output = [hexfunc(ctx.node())]
3967 3967 if num:
3968 3968 output.append(str(ctx.rev()))
3969 3969
3970 3970 if default and not ui.quiet:
3971 3971 b = ctx.branch()
3972 3972 if b != 'default':
3973 3973 output.append("(%s)" % b)
3974 3974
3975 3975 # multiple tags for a single parent separated by '/'
3976 3976 t = '/'.join(ctx.tags())
3977 3977 if t:
3978 3978 output.append(t)
3979 3979
3980 3980 # multiple bookmarks for a single parent separated by '/'
3981 3981 bm = '/'.join(ctx.bookmarks())
3982 3982 if bm:
3983 3983 output.append(bm)
3984 3984 else:
3985 3985 if branch:
3986 3986 output.append(ctx.branch())
3987 3987
3988 3988 if tags:
3989 3989 output.extend(ctx.tags())
3990 3990
3991 3991 if bookmarks:
3992 3992 output.extend(ctx.bookmarks())
3993 3993
3994 3994 ui.write("%s\n" % ' '.join(output))
3995 3995
3996 3996 @command('import|patch',
3997 3997 [('p', 'strip', 1,
3998 3998 _('directory strip option for patch. This has the same '
3999 3999 'meaning as the corresponding patch option'), _('NUM')),
4000 4000 ('b', 'base', '', _('base path (DEPRECATED)'), _('PATH')),
4001 4001 ('e', 'edit', False, _('invoke editor on commit messages')),
4002 4002 ('f', 'force', None,
4003 4003 _('skip check for outstanding uncommitted changes (DEPRECATED)')),
4004 4004 ('', 'no-commit', None,
4005 4005 _("don't commit, just update the working directory")),
4006 4006 ('', 'bypass', None,
4007 4007 _("apply patch without touching the working directory")),
4008 4008 ('', 'partial', None,
4009 4009 _('commit even if some hunks fail')),
4010 4010 ('', 'exact', None,
4011 4011 _('apply patch to the nodes from which it was generated')),
4012 4012 ('', 'import-branch', None,
4013 4013 _('use any branch information in patch (implied by --exact)'))] +
4014 4014 commitopts + commitopts2 + similarityopts,
4015 4015 _('[OPTION]... PATCH...'))
4016 4016 def import_(ui, repo, patch1=None, *patches, **opts):
4017 4017 """import an ordered set of patches
4018 4018
4019 4019 Import a list of patches and commit them individually (unless
4020 4020 --no-commit is specified).
4021 4021
4022 4022 Because import first applies changes to the working directory,
4023 4023 import will abort if there are outstanding changes.
4024 4024
4025 4025 You can import a patch straight from a mail message. Even patches
4026 4026 as attachments work (to use the body part, it must have type
4027 4027 text/plain or text/x-patch). From and Subject headers of email
4028 4028 message are used as default committer and commit message. All
4029 4029 text/plain body parts before first diff are added to commit
4030 4030 message.
4031 4031
4032 4032 If the imported patch was generated by :hg:`export`, user and
4033 4033 description from patch override values from message headers and
4034 4034 body. Values given on command line with -m/--message and -u/--user
4035 4035 override these.
4036 4036
4037 4037 If --exact is specified, import will set the working directory to
4038 4038 the parent of each patch before applying it, and will abort if the
4039 4039 resulting changeset has a different ID than the one recorded in
4040 4040 the patch. This may happen due to character set problems or other
4041 4041 deficiencies in the text patch format.
4042 4042
4043 4043 Use --bypass to apply and commit patches directly to the
4044 4044 repository, not touching the working directory. Without --exact,
4045 4045 patches will be applied on top of the working directory parent
4046 4046 revision.
4047 4047
4048 4048 With -s/--similarity, hg will attempt to discover renames and
4049 4049 copies in the patch in the same way as :hg:`addremove`.
4050 4050
4051 4051 Use --partial to ensure a changeset will be created from the patch
4052 4052 even if some hunks fail to apply. Hunks that fail to apply will be
4053 4053 written to a <target-file>.rej file. Conflicts can then be resolved
4054 4054 by hand before :hg:`commit --amend` is run to update the created
4055 4055 changeset. This flag exists to let people import patches that
4056 4056 partially apply without losing the associated metadata (author,
4057 4057 date, description, ...). Note that when none of the hunk applies
4058 4058 cleanly, :hg:`import --partial` will create an empty changeset,
4059 4059 importing only the patch metadata.
4060 4060
4061 4061 To read a patch from standard input, use "-" as the patch name. If
4062 4062 a URL is specified, the patch will be downloaded from it.
4063 4063 See :hg:`help dates` for a list of formats valid for -d/--date.
4064 4064
4065 4065 .. container:: verbose
4066 4066
4067 4067 Examples:
4068 4068
4069 4069 - import a traditional patch from a website and detect renames::
4070 4070
4071 4071 hg import -s 80 http://example.com/bugfix.patch
4072 4072
4073 4073 - import a changeset from an hgweb server::
4074 4074
4075 4075 hg import http://www.selenic.com/hg/rev/5ca8c111e9aa
4076 4076
4077 4077 - import all the patches in an Unix-style mbox::
4078 4078
4079 4079 hg import incoming-patches.mbox
4080 4080
4081 4081 - attempt to exactly restore an exported changeset (not always
4082 4082 possible)::
4083 4083
4084 4084 hg import --exact proposed-fix.patch
4085 4085
4086 4086 Returns 0 on success, 1 on partial success (see --partial).
4087 4087 """
4088 4088
4089 4089 if not patch1:
4090 4090 raise util.Abort(_('need at least one patch to import'))
4091 4091
4092 4092 patches = (patch1,) + patches
4093 4093
4094 4094 date = opts.get('date')
4095 4095 if date:
4096 4096 opts['date'] = util.parsedate(date)
4097 4097
4098 4098 update = not opts.get('bypass')
4099 4099 if not update and opts.get('no_commit'):
4100 4100 raise util.Abort(_('cannot use --no-commit with --bypass'))
4101 4101 try:
4102 4102 sim = float(opts.get('similarity') or 0)
4103 4103 except ValueError:
4104 4104 raise util.Abort(_('similarity must be a number'))
4105 4105 if sim < 0 or sim > 100:
4106 4106 raise util.Abort(_('similarity must be between 0 and 100'))
4107 4107 if sim and not update:
4108 4108 raise util.Abort(_('cannot use --similarity with --bypass'))
4109 4109 if opts.get('exact') and opts.get('edit'):
4110 4110 raise util.Abort(_('cannot use --exact with --edit'))
4111 4111
4112 4112 if update:
4113 4113 cmdutil.checkunfinished(repo)
4114 4114 if (opts.get('exact') or not opts.get('force')) and update:
4115 4115 cmdutil.bailifchanged(repo)
4116 4116
4117 4117 base = opts["base"]
4118 4118 wlock = lock = tr = None
4119 4119 msgs = []
4120 4120 ret = 0
4121 4121
4122 4122
4123 4123 try:
4124 4124 try:
4125 4125 wlock = repo.wlock()
4126 4126 repo.dirstate.beginparentchange()
4127 4127 if not opts.get('no_commit'):
4128 4128 lock = repo.lock()
4129 4129 tr = repo.transaction('import')
4130 4130 parents = repo.parents()
4131 4131 for patchurl in patches:
4132 4132 if patchurl == '-':
4133 4133 ui.status(_('applying patch from stdin\n'))
4134 4134 patchfile = ui.fin
4135 4135 patchurl = 'stdin' # for error message
4136 4136 else:
4137 4137 patchurl = os.path.join(base, patchurl)
4138 4138 ui.status(_('applying %s\n') % patchurl)
4139 4139 patchfile = hg.openpath(ui, patchurl)
4140 4140
4141 4141 haspatch = False
4142 4142 for hunk in patch.split(patchfile):
4143 4143 (msg, node, rej) = cmdutil.tryimportone(ui, repo, hunk,
4144 4144 parents, opts,
4145 4145 msgs, hg.clean)
4146 4146 if msg:
4147 4147 haspatch = True
4148 4148 ui.note(msg + '\n')
4149 4149 if update or opts.get('exact'):
4150 4150 parents = repo.parents()
4151 4151 else:
4152 4152 parents = [repo[node]]
4153 4153 if rej:
4154 4154 ui.write_err(_("patch applied partially\n"))
4155 4155 ui.write_err(_("(fix the .rej files and run "
4156 4156 "`hg commit --amend`)\n"))
4157 4157 ret = 1
4158 4158 break
4159 4159
4160 4160 if not haspatch:
4161 4161 raise util.Abort(_('%s: no diffs found') % patchurl)
4162 4162
4163 4163 if tr:
4164 4164 tr.close()
4165 4165 if msgs:
4166 4166 repo.savecommitmessage('\n* * *\n'.join(msgs))
4167 4167 repo.dirstate.endparentchange()
4168 4168 return ret
4169 4169 except: # re-raises
4170 4170 # wlock.release() indirectly calls dirstate.write(): since
4171 4171 # we're crashing, we do not want to change the working dir
4172 4172 # parent after all, so make sure it writes nothing
4173 4173 repo.dirstate.invalidate()
4174 4174 raise
4175 4175 finally:
4176 4176 if tr:
4177 4177 tr.release()
4178 4178 release(lock, wlock)
4179 4179
4180 4180 @command('incoming|in',
4181 4181 [('f', 'force', None,
4182 4182 _('run even if remote repository is unrelated')),
4183 4183 ('n', 'newest-first', None, _('show newest record first')),
4184 4184 ('', 'bundle', '',
4185 4185 _('file to store the bundles into'), _('FILE')),
4186 4186 ('r', 'rev', [], _('a remote changeset intended to be added'), _('REV')),
4187 4187 ('B', 'bookmarks', False, _("compare bookmarks")),
4188 4188 ('b', 'branch', [],
4189 4189 _('a specific branch you would like to pull'), _('BRANCH')),
4190 4190 ] + logopts + remoteopts + subrepoopts,
4191 4191 _('[-p] [-n] [-M] [-f] [-r REV]... [--bundle FILENAME] [SOURCE]'))
4192 4192 def incoming(ui, repo, source="default", **opts):
4193 4193 """show new changesets found in source
4194 4194
4195 4195 Show new changesets found in the specified path/URL or the default
4196 4196 pull location. These are the changesets that would have been pulled
4197 4197 if a pull at the time you issued this command.
4198 4198
4199 4199 For remote repository, using --bundle avoids downloading the
4200 4200 changesets twice if the incoming is followed by a pull.
4201 4201
4202 4202 See pull for valid source format details.
4203 4203
4204 4204 .. container:: verbose
4205 4205
4206 4206 Examples:
4207 4207
4208 4208 - show incoming changes with patches and full description::
4209 4209
4210 4210 hg incoming -vp
4211 4211
4212 4212 - show incoming changes excluding merges, store a bundle::
4213 4213
4214 4214 hg in -vpM --bundle incoming.hg
4215 4215 hg pull incoming.hg
4216 4216
4217 4217 - briefly list changes inside a bundle::
4218 4218
4219 4219 hg in changes.hg -T "{desc|firstline}\\n"
4220 4220
4221 4221 Returns 0 if there are incoming changes, 1 otherwise.
4222 4222 """
4223 4223 if opts.get('graph'):
4224 4224 cmdutil.checkunsupportedgraphflags([], opts)
4225 4225 def display(other, chlist, displayer):
4226 4226 revdag = cmdutil.graphrevs(other, chlist, opts)
4227 4227 showparents = [ctx.node() for ctx in repo[None].parents()]
4228 4228 cmdutil.displaygraph(ui, revdag, displayer, showparents,
4229 4229 graphmod.asciiedges)
4230 4230
4231 4231 hg._incoming(display, lambda: 1, ui, repo, source, opts, buffered=True)
4232 4232 return 0
4233 4233
4234 4234 if opts.get('bundle') and opts.get('subrepos'):
4235 4235 raise util.Abort(_('cannot combine --bundle and --subrepos'))
4236 4236
4237 4237 if opts.get('bookmarks'):
4238 4238 source, branches = hg.parseurl(ui.expandpath(source),
4239 4239 opts.get('branch'))
4240 4240 other = hg.peer(repo, opts, source)
4241 4241 if 'bookmarks' not in other.listkeys('namespaces'):
4242 4242 ui.warn(_("remote doesn't support bookmarks\n"))
4243 4243 return 0
4244 4244 ui.status(_('comparing with %s\n') % util.hidepassword(source))
4245 4245 return bookmarks.diff(ui, repo, other)
4246 4246
4247 4247 repo._subtoppath = ui.expandpath(source)
4248 4248 try:
4249 4249 return hg.incoming(ui, repo, source, opts)
4250 4250 finally:
4251 4251 del repo._subtoppath
4252 4252
4253 4253
4254 4254 @command('^init', remoteopts, _('[-e CMD] [--remotecmd CMD] [DEST]'),
4255 4255 norepo=True)
4256 4256 def init(ui, dest=".", **opts):
4257 4257 """create a new repository in the given directory
4258 4258
4259 4259 Initialize a new repository in the given directory. If the given
4260 4260 directory does not exist, it will be created.
4261 4261
4262 4262 If no directory is given, the current directory is used.
4263 4263
4264 4264 It is possible to specify an ``ssh://`` URL as the destination.
4265 4265 See :hg:`help urls` for more information.
4266 4266
4267 4267 Returns 0 on success.
4268 4268 """
4269 4269 hg.peer(ui, opts, ui.expandpath(dest), create=True)
4270 4270
4271 4271 @command('locate',
4272 4272 [('r', 'rev', '', _('search the repository as it is in REV'), _('REV')),
4273 4273 ('0', 'print0', None, _('end filenames with NUL, for use with xargs')),
4274 4274 ('f', 'fullpath', None, _('print complete paths from the filesystem root')),
4275 4275 ] + walkopts,
4276 4276 _('[OPTION]... [PATTERN]...'))
4277 4277 def locate(ui, repo, *pats, **opts):
4278 4278 """locate files matching specific patterns (DEPRECATED)
4279 4279
4280 4280 Print files under Mercurial control in the working directory whose
4281 4281 names match the given patterns.
4282 4282
4283 4283 By default, this command searches all directories in the working
4284 4284 directory. To search just the current directory and its
4285 4285 subdirectories, use "--include .".
4286 4286
4287 4287 If no patterns are given to match, this command prints the names
4288 4288 of all files under Mercurial control in the working directory.
4289 4289
4290 4290 If you want to feed the output of this command into the "xargs"
4291 4291 command, use the -0 option to both this command and "xargs". This
4292 4292 will avoid the problem of "xargs" treating single filenames that
4293 4293 contain whitespace as multiple filenames.
4294 4294
4295 4295 See :hg:`help files` for a more versatile command.
4296 4296
4297 4297 Returns 0 if a match is found, 1 otherwise.
4298 4298 """
4299 4299 end = opts.get('print0') and '\0' or '\n'
4300 4300 rev = scmutil.revsingle(repo, opts.get('rev'), None).node()
4301 4301
4302 4302 ret = 1
4303 4303 ctx = repo[rev]
4304 4304 m = scmutil.match(ctx, pats, opts, default='relglob')
4305 4305 m.bad = lambda x, y: False
4306 4306
4307 4307 for abs in ctx.matches(m):
4308 4308 if opts.get('fullpath'):
4309 4309 ui.write(repo.wjoin(abs), end)
4310 4310 else:
4311 4311 ui.write(((pats and m.rel(abs)) or abs), end)
4312 4312 ret = 0
4313 4313
4314 4314 return ret
4315 4315
4316 4316 @command('^log|history',
4317 4317 [('f', 'follow', None,
4318 4318 _('follow changeset history, or file history across copies and renames')),
4319 4319 ('', 'follow-first', None,
4320 4320 _('only follow the first parent of merge changesets (DEPRECATED)')),
4321 4321 ('d', 'date', '', _('show revisions matching date spec'), _('DATE')),
4322 4322 ('C', 'copies', None, _('show copied files')),
4323 4323 ('k', 'keyword', [],
4324 4324 _('do case-insensitive search for a given text'), _('TEXT')),
4325 4325 ('r', 'rev', [], _('show the specified revision or revset'), _('REV')),
4326 4326 ('', 'removed', None, _('include revisions where files were removed')),
4327 4327 ('m', 'only-merges', None, _('show only merges (DEPRECATED)')),
4328 4328 ('u', 'user', [], _('revisions committed by user'), _('USER')),
4329 4329 ('', 'only-branch', [],
4330 4330 _('show only changesets within the given named branch (DEPRECATED)'),
4331 4331 _('BRANCH')),
4332 4332 ('b', 'branch', [],
4333 4333 _('show changesets within the given named branch'), _('BRANCH')),
4334 4334 ('P', 'prune', [],
4335 4335 _('do not display revision or any of its ancestors'), _('REV')),
4336 4336 ] + logopts + walkopts,
4337 4337 _('[OPTION]... [FILE]'),
4338 4338 inferrepo=True)
4339 4339 def log(ui, repo, *pats, **opts):
4340 4340 """show revision history of entire repository or files
4341 4341
4342 4342 Print the revision history of the specified files or the entire
4343 4343 project.
4344 4344
4345 4345 If no revision range is specified, the default is ``tip:0`` unless
4346 4346 --follow is set, in which case the working directory parent is
4347 4347 used as the starting revision.
4348 4348
4349 4349 File history is shown without following rename or copy history of
4350 4350 files. Use -f/--follow with a filename to follow history across
4351 4351 renames and copies. --follow without a filename will only show
4352 4352 ancestors or descendants of the starting revision.
4353 4353
4354 4354 By default this command prints revision number and changeset id,
4355 4355 tags, non-trivial parents, user, date and time, and a summary for
4356 4356 each commit. When the -v/--verbose switch is used, the list of
4357 4357 changed files and full commit message are shown.
4358 4358
4359 4359 With --graph the revisions are shown as an ASCII art DAG with the most
4360 4360 recent changeset at the top.
4361 4361 'o' is a changeset, '@' is a working directory parent, 'x' is obsolete,
4362 4362 and '+' represents a fork where the changeset from the lines below is a
4363 4363 parent of the 'o' merge on the same line.
4364 4364
4365 4365 .. note::
4366 4366
4367 4367 log -p/--patch may generate unexpected diff output for merge
4368 4368 changesets, as it will only compare the merge changeset against
4369 4369 its first parent. Also, only files different from BOTH parents
4370 4370 will appear in files:.
4371 4371
4372 4372 .. note::
4373 4373
4374 4374 for performance reasons, log FILE may omit duplicate changes
4375 4375 made on branches and will not show removals or mode changes. To
4376 4376 see all such changes, use the --removed switch.
4377 4377
4378 4378 .. container:: verbose
4379 4379
4380 4380 Some examples:
4381 4381
4382 4382 - changesets with full descriptions and file lists::
4383 4383
4384 4384 hg log -v
4385 4385
4386 4386 - changesets ancestral to the working directory::
4387 4387
4388 4388 hg log -f
4389 4389
4390 4390 - last 10 commits on the current branch::
4391 4391
4392 4392 hg log -l 10 -b .
4393 4393
4394 4394 - changesets showing all modifications of a file, including removals::
4395 4395
4396 4396 hg log --removed file.c
4397 4397
4398 4398 - all changesets that touch a directory, with diffs, excluding merges::
4399 4399
4400 4400 hg log -Mp lib/
4401 4401
4402 4402 - all revision numbers that match a keyword::
4403 4403
4404 4404 hg log -k bug --template "{rev}\\n"
4405 4405
4406 4406 - list available log templates::
4407 4407
4408 4408 hg log -T list
4409 4409
4410 4410 - check if a given changeset is included in a tagged release::
4411 4411
4412 4412 hg log -r "a21ccf and ancestor(1.9)"
4413 4413
4414 4414 - find all changesets by some user in a date range::
4415 4415
4416 4416 hg log -k alice -d "may 2008 to jul 2008"
4417 4417
4418 4418 - summary of all changesets after the last tag::
4419 4419
4420 4420 hg log -r "last(tagged())::" --template "{desc|firstline}\\n"
4421 4421
4422 4422 See :hg:`help dates` for a list of formats valid for -d/--date.
4423 4423
4424 4424 See :hg:`help revisions` and :hg:`help revsets` for more about
4425 4425 specifying revisions.
4426 4426
4427 4427 See :hg:`help templates` for more about pre-packaged styles and
4428 4428 specifying custom templates.
4429 4429
4430 4430 Returns 0 on success.
4431 4431
4432 4432 """
4433 4433 if opts.get('graph'):
4434 4434 return cmdutil.graphlog(ui, repo, *pats, **opts)
4435 4435
4436 4436 revs, expr, filematcher = cmdutil.getlogrevs(repo, pats, opts)
4437 4437 limit = cmdutil.loglimit(opts)
4438 4438 count = 0
4439 4439
4440 4440 getrenamed = None
4441 4441 if opts.get('copies'):
4442 4442 endrev = None
4443 4443 if opts.get('rev'):
4444 4444 endrev = scmutil.revrange(repo, opts.get('rev')).max() + 1
4445 4445 getrenamed = templatekw.getrenamedfn(repo, endrev=endrev)
4446 4446
4447 4447 displayer = cmdutil.show_changeset(ui, repo, opts, buffered=True)
4448 4448 for rev in revs:
4449 4449 if count == limit:
4450 4450 break
4451 4451 ctx = repo[rev]
4452 4452 copies = None
4453 4453 if getrenamed is not None and rev:
4454 4454 copies = []
4455 4455 for fn in ctx.files():
4456 4456 rename = getrenamed(fn, rev)
4457 4457 if rename:
4458 4458 copies.append((fn, rename[0]))
4459 4459 revmatchfn = filematcher and filematcher(ctx.rev()) or None
4460 4460 displayer.show(ctx, copies=copies, matchfn=revmatchfn)
4461 4461 if displayer.flush(rev):
4462 4462 count += 1
4463 4463
4464 4464 displayer.close()
4465 4465
4466 4466 @command('manifest',
4467 4467 [('r', 'rev', '', _('revision to display'), _('REV')),
4468 4468 ('', 'all', False, _("list files from all revisions"))]
4469 4469 + formatteropts,
4470 4470 _('[-r REV]'))
4471 4471 def manifest(ui, repo, node=None, rev=None, **opts):
4472 4472 """output the current or given revision of the project manifest
4473 4473
4474 4474 Print a list of version controlled files for the given revision.
4475 4475 If no revision is given, the first parent of the working directory
4476 4476 is used, or the null revision if no revision is checked out.
4477 4477
4478 4478 With -v, print file permissions, symlink and executable bits.
4479 4479 With --debug, print file revision hashes.
4480 4480
4481 4481 If option --all is specified, the list of all files from all revisions
4482 4482 is printed. This includes deleted and renamed files.
4483 4483
4484 4484 Returns 0 on success.
4485 4485 """
4486 4486
4487 4487 fm = ui.formatter('manifest', opts)
4488 4488
4489 4489 if opts.get('all'):
4490 4490 if rev or node:
4491 4491 raise util.Abort(_("can't specify a revision with --all"))
4492 4492
4493 4493 res = []
4494 4494 prefix = "data/"
4495 4495 suffix = ".i"
4496 4496 plen = len(prefix)
4497 4497 slen = len(suffix)
4498 4498 lock = repo.lock()
4499 4499 try:
4500 4500 for fn, b, size in repo.store.datafiles():
4501 4501 if size != 0 and fn[-slen:] == suffix and fn[:plen] == prefix:
4502 4502 res.append(fn[plen:-slen])
4503 4503 finally:
4504 4504 lock.release()
4505 4505 for f in res:
4506 4506 fm.startitem()
4507 4507 fm.write("path", '%s\n', f)
4508 4508 fm.end()
4509 4509 return
4510 4510
4511 4511 if rev and node:
4512 4512 raise util.Abort(_("please specify just one revision"))
4513 4513
4514 4514 if not node:
4515 4515 node = rev
4516 4516
4517 4517 char = {'l': '@', 'x': '*', '': ''}
4518 4518 mode = {'l': '644', 'x': '755', '': '644'}
4519 4519 ctx = scmutil.revsingle(repo, node)
4520 4520 mf = ctx.manifest()
4521 4521 for f in ctx:
4522 4522 fm.startitem()
4523 4523 fl = ctx[f].flags()
4524 4524 fm.condwrite(ui.debugflag, 'hash', '%s ', hex(mf[f]))
4525 4525 fm.condwrite(ui.verbose, 'mode type', '%s %1s ', mode[fl], char[fl])
4526 4526 fm.write('path', '%s\n', f)
4527 4527 fm.end()
4528 4528
4529 4529 @command('^merge',
4530 4530 [('f', 'force', None,
4531 4531 _('force a merge including outstanding changes (DEPRECATED)')),
4532 4532 ('r', 'rev', '', _('revision to merge'), _('REV')),
4533 4533 ('P', 'preview', None,
4534 4534 _('review revisions to merge (no merge is performed)'))
4535 4535 ] + mergetoolopts,
4536 4536 _('[-P] [-f] [[-r] REV]'))
4537 4537 def merge(ui, repo, node=None, **opts):
4538 4538 """merge working directory with another revision
4539 4539
4540 4540 The current working directory is updated with all changes made in
4541 4541 the requested revision since the last common predecessor revision.
4542 4542
4543 4543 Files that changed between either parent are marked as changed for
4544 4544 the next commit and a commit must be performed before any further
4545 4545 updates to the repository are allowed. The next commit will have
4546 4546 two parents.
4547 4547
4548 4548 ``--tool`` can be used to specify the merge tool used for file
4549 4549 merges. It overrides the HGMERGE environment variable and your
4550 4550 configuration files. See :hg:`help merge-tools` for options.
4551 4551
4552 4552 If no revision is specified, the working directory's parent is a
4553 4553 head revision, and the current branch contains exactly one other
4554 4554 head, the other head is merged with by default. Otherwise, an
4555 4555 explicit revision with which to merge with must be provided.
4556 4556
4557 4557 :hg:`resolve` must be used to resolve unresolved files.
4558 4558
4559 4559 To undo an uncommitted merge, use :hg:`update --clean .` which
4560 4560 will check out a clean copy of the original merge parent, losing
4561 4561 all changes.
4562 4562
4563 4563 Returns 0 on success, 1 if there are unresolved files.
4564 4564 """
4565 4565
4566 4566 if opts.get('rev') and node:
4567 4567 raise util.Abort(_("please specify just one revision"))
4568 4568 if not node:
4569 4569 node = opts.get('rev')
4570 4570
4571 4571 if node:
4572 4572 node = scmutil.revsingle(repo, node).node()
4573 4573
4574 4574 if not node and repo._bookmarkcurrent:
4575 4575 bmheads = repo.bookmarkheads(repo._bookmarkcurrent)
4576 4576 curhead = repo[repo._bookmarkcurrent].node()
4577 4577 if len(bmheads) == 2:
4578 4578 if curhead == bmheads[0]:
4579 4579 node = bmheads[1]
4580 4580 else:
4581 4581 node = bmheads[0]
4582 4582 elif len(bmheads) > 2:
4583 4583 raise util.Abort(_("multiple matching bookmarks to merge - "
4584 4584 "please merge with an explicit rev or bookmark"),
4585 4585 hint=_("run 'hg heads' to see all heads"))
4586 4586 elif len(bmheads) <= 1:
4587 4587 raise util.Abort(_("no matching bookmark to merge - "
4588 4588 "please merge with an explicit rev or bookmark"),
4589 4589 hint=_("run 'hg heads' to see all heads"))
4590 4590
4591 4591 if not node and not repo._bookmarkcurrent:
4592 4592 branch = repo[None].branch()
4593 4593 bheads = repo.branchheads(branch)
4594 4594 nbhs = [bh for bh in bheads if not repo[bh].bookmarks()]
4595 4595
4596 4596 if len(nbhs) > 2:
4597 4597 raise util.Abort(_("branch '%s' has %d heads - "
4598 4598 "please merge with an explicit rev")
4599 4599 % (branch, len(bheads)),
4600 4600 hint=_("run 'hg heads .' to see heads"))
4601 4601
4602 4602 parent = repo.dirstate.p1()
4603 4603 if len(nbhs) <= 1:
4604 4604 if len(bheads) > 1:
4605 4605 raise util.Abort(_("heads are bookmarked - "
4606 4606 "please merge with an explicit rev"),
4607 4607 hint=_("run 'hg heads' to see all heads"))
4608 4608 if len(repo.heads()) > 1:
4609 4609 raise util.Abort(_("branch '%s' has one head - "
4610 4610 "please merge with an explicit rev")
4611 4611 % branch,
4612 4612 hint=_("run 'hg heads' to see all heads"))
4613 4613 msg, hint = _('nothing to merge'), None
4614 4614 if parent != repo.lookup(branch):
4615 4615 hint = _("use 'hg update' instead")
4616 4616 raise util.Abort(msg, hint=hint)
4617 4617
4618 4618 if parent not in bheads:
4619 4619 raise util.Abort(_('working directory not at a head revision'),
4620 4620 hint=_("use 'hg update' or merge with an "
4621 4621 "explicit revision"))
4622 4622 if parent == nbhs[0]:
4623 4623 node = nbhs[-1]
4624 4624 else:
4625 4625 node = nbhs[0]
4626 4626
4627 4627 if opts.get('preview'):
4628 4628 # find nodes that are ancestors of p2 but not of p1
4629 4629 p1 = repo.lookup('.')
4630 4630 p2 = repo.lookup(node)
4631 4631 nodes = repo.changelog.findmissing(common=[p1], heads=[p2])
4632 4632
4633 4633 displayer = cmdutil.show_changeset(ui, repo, opts)
4634 4634 for node in nodes:
4635 4635 displayer.show(repo[node])
4636 4636 displayer.close()
4637 4637 return 0
4638 4638
4639 4639 try:
4640 4640 # ui.forcemerge is an internal variable, do not document
4641 4641 repo.ui.setconfig('ui', 'forcemerge', opts.get('tool', ''), 'merge')
4642 4642 return hg.merge(repo, node, force=opts.get('force'))
4643 4643 finally:
4644 4644 ui.setconfig('ui', 'forcemerge', '', 'merge')
4645 4645
4646 4646 @command('outgoing|out',
4647 4647 [('f', 'force', None, _('run even when the destination is unrelated')),
4648 4648 ('r', 'rev', [],
4649 4649 _('a changeset intended to be included in the destination'), _('REV')),
4650 4650 ('n', 'newest-first', None, _('show newest record first')),
4651 4651 ('B', 'bookmarks', False, _('compare bookmarks')),
4652 4652 ('b', 'branch', [], _('a specific branch you would like to push'),
4653 4653 _('BRANCH')),
4654 4654 ] + logopts + remoteopts + subrepoopts,
4655 4655 _('[-M] [-p] [-n] [-f] [-r REV]... [DEST]'))
4656 4656 def outgoing(ui, repo, dest=None, **opts):
4657 4657 """show changesets not found in the destination
4658 4658
4659 4659 Show changesets not found in the specified destination repository
4660 4660 or the default push location. These are the changesets that would
4661 4661 be pushed if a push was requested.
4662 4662
4663 4663 See pull for details of valid destination formats.
4664 4664
4665 4665 Returns 0 if there are outgoing changes, 1 otherwise.
4666 4666 """
4667 4667 if opts.get('graph'):
4668 4668 cmdutil.checkunsupportedgraphflags([], opts)
4669 4669 o, other = hg._outgoing(ui, repo, dest, opts)
4670 4670 if not o:
4671 4671 cmdutil.outgoinghooks(ui, repo, other, opts, o)
4672 4672 return
4673 4673
4674 4674 revdag = cmdutil.graphrevs(repo, o, opts)
4675 4675 displayer = cmdutil.show_changeset(ui, repo, opts, buffered=True)
4676 4676 showparents = [ctx.node() for ctx in repo[None].parents()]
4677 4677 cmdutil.displaygraph(ui, revdag, displayer, showparents,
4678 4678 graphmod.asciiedges)
4679 4679 cmdutil.outgoinghooks(ui, repo, other, opts, o)
4680 4680 return 0
4681 4681
4682 4682 if opts.get('bookmarks'):
4683 4683 dest = ui.expandpath(dest or 'default-push', dest or 'default')
4684 4684 dest, branches = hg.parseurl(dest, opts.get('branch'))
4685 4685 other = hg.peer(repo, opts, dest)
4686 4686 if 'bookmarks' not in other.listkeys('namespaces'):
4687 4687 ui.warn(_("remote doesn't support bookmarks\n"))
4688 4688 return 0
4689 4689 ui.status(_('comparing with %s\n') % util.hidepassword(dest))
4690 4690 return bookmarks.diff(ui, other, repo)
4691 4691
4692 4692 repo._subtoppath = ui.expandpath(dest or 'default-push', dest or 'default')
4693 4693 try:
4694 4694 return hg.outgoing(ui, repo, dest, opts)
4695 4695 finally:
4696 4696 del repo._subtoppath
4697 4697
4698 4698 @command('parents',
4699 4699 [('r', 'rev', '', _('show parents of the specified revision'), _('REV')),
4700 4700 ] + templateopts,
4701 4701 _('[-r REV] [FILE]'),
4702 4702 inferrepo=True)
4703 4703 def parents(ui, repo, file_=None, **opts):
4704 4704 """show the parents of the working directory or revision (DEPRECATED)
4705 4705
4706 4706 Print the working directory's parent revisions. If a revision is
4707 4707 given via -r/--rev, the parent of that revision will be printed.
4708 4708 If a file argument is given, the revision in which the file was
4709 4709 last changed (before the working directory revision or the
4710 4710 argument to --rev if given) is printed.
4711 4711
4712 4712 See :hg:`summary` and :hg:`help revsets` for related information.
4713 4713
4714 4714 Returns 0 on success.
4715 4715 """
4716 4716
4717 4717 ctx = scmutil.revsingle(repo, opts.get('rev'), None)
4718 4718
4719 4719 if file_:
4720 4720 m = scmutil.match(ctx, (file_,), opts)
4721 4721 if m.anypats() or len(m.files()) != 1:
4722 4722 raise util.Abort(_('can only specify an explicit filename'))
4723 4723 file_ = m.files()[0]
4724 4724 filenodes = []
4725 4725 for cp in ctx.parents():
4726 4726 if not cp:
4727 4727 continue
4728 4728 try:
4729 4729 filenodes.append(cp.filenode(file_))
4730 4730 except error.LookupError:
4731 4731 pass
4732 4732 if not filenodes:
4733 4733 raise util.Abort(_("'%s' not found in manifest!") % file_)
4734 4734 p = []
4735 4735 for fn in filenodes:
4736 4736 fctx = repo.filectx(file_, fileid=fn)
4737 4737 p.append(fctx.node())
4738 4738 else:
4739 4739 p = [cp.node() for cp in ctx.parents()]
4740 4740
4741 4741 displayer = cmdutil.show_changeset(ui, repo, opts)
4742 4742 for n in p:
4743 4743 if n != nullid:
4744 4744 displayer.show(repo[n])
4745 4745 displayer.close()
4746 4746
4747 4747 @command('paths', [], _('[NAME]'), optionalrepo=True)
4748 4748 def paths(ui, repo, search=None):
4749 4749 """show aliases for remote repositories
4750 4750
4751 4751 Show definition of symbolic path name NAME. If no name is given,
4752 4752 show definition of all available names.
4753 4753
4754 4754 Option -q/--quiet suppresses all output when searching for NAME
4755 4755 and shows only the path names when listing all definitions.
4756 4756
4757 4757 Path names are defined in the [paths] section of your
4758 4758 configuration file and in ``/etc/mercurial/hgrc``. If run inside a
4759 4759 repository, ``.hg/hgrc`` is used, too.
4760 4760
4761 4761 The path names ``default`` and ``default-push`` have a special
4762 4762 meaning. When performing a push or pull operation, they are used
4763 4763 as fallbacks if no location is specified on the command-line.
4764 4764 When ``default-push`` is set, it will be used for push and
4765 4765 ``default`` will be used for pull; otherwise ``default`` is used
4766 4766 as the fallback for both. When cloning a repository, the clone
4767 4767 source is written as ``default`` in ``.hg/hgrc``. Note that
4768 4768 ``default`` and ``default-push`` apply to all inbound (e.g.
4769 4769 :hg:`incoming`) and outbound (e.g. :hg:`outgoing`, :hg:`email` and
4770 4770 :hg:`bundle`) operations.
4771 4771
4772 4772 See :hg:`help urls` for more information.
4773 4773
4774 4774 Returns 0 on success.
4775 4775 """
4776 4776 if search:
4777 4777 for name, path in ui.configitems("paths"):
4778 4778 if name == search:
4779 4779 ui.status("%s\n" % util.hidepassword(path))
4780 4780 return
4781 4781 if not ui.quiet:
4782 4782 ui.warn(_("not found!\n"))
4783 4783 return 1
4784 4784 else:
4785 4785 for name, path in ui.configitems("paths"):
4786 4786 if ui.quiet:
4787 4787 ui.write("%s\n" % name)
4788 4788 else:
4789 4789 ui.write("%s = %s\n" % (name, util.hidepassword(path)))
4790 4790
4791 4791 @command('phase',
4792 4792 [('p', 'public', False, _('set changeset phase to public')),
4793 4793 ('d', 'draft', False, _('set changeset phase to draft')),
4794 4794 ('s', 'secret', False, _('set changeset phase to secret')),
4795 4795 ('f', 'force', False, _('allow to move boundary backward')),
4796 4796 ('r', 'rev', [], _('target revision'), _('REV')),
4797 4797 ],
4798 4798 _('[-p|-d|-s] [-f] [-r] REV...'))
4799 4799 def phase(ui, repo, *revs, **opts):
4800 4800 """set or show the current phase name
4801 4801
4802 4802 With no argument, show the phase name of specified revisions.
4803 4803
4804 4804 With one of -p/--public, -d/--draft or -s/--secret, change the
4805 4805 phase value of the specified revisions.
4806 4806
4807 4807 Unless -f/--force is specified, :hg:`phase` won't move changeset from a
4808 4808 lower phase to an higher phase. Phases are ordered as follows::
4809 4809
4810 4810 public < draft < secret
4811 4811
4812 4812 Returns 0 on success, 1 if no phases were changed or some could not
4813 4813 be changed.
4814 4814 """
4815 4815 # search for a unique phase argument
4816 4816 targetphase = None
4817 4817 for idx, name in enumerate(phases.phasenames):
4818 4818 if opts[name]:
4819 4819 if targetphase is not None:
4820 4820 raise util.Abort(_('only one phase can be specified'))
4821 4821 targetphase = idx
4822 4822
4823 4823 # look for specified revision
4824 4824 revs = list(revs)
4825 4825 revs.extend(opts['rev'])
4826 4826 if not revs:
4827 4827 raise util.Abort(_('no revisions specified'))
4828 4828
4829 4829 revs = scmutil.revrange(repo, revs)
4830 4830
4831 4831 lock = None
4832 4832 ret = 0
4833 4833 if targetphase is None:
4834 4834 # display
4835 4835 for r in revs:
4836 4836 ctx = repo[r]
4837 4837 ui.write('%i: %s\n' % (ctx.rev(), ctx.phasestr()))
4838 4838 else:
4839 4839 tr = None
4840 4840 lock = repo.lock()
4841 4841 try:
4842 4842 tr = repo.transaction("phase")
4843 4843 # set phase
4844 4844 if not revs:
4845 4845 raise util.Abort(_('empty revision set'))
4846 4846 nodes = [repo[r].node() for r in revs]
4847 4847 # moving revision from public to draft may hide them
4848 4848 # We have to check result on an unfiltered repository
4849 4849 unfi = repo.unfiltered()
4850 4850 getphase = unfi._phasecache.phase
4851 4851 olddata = [getphase(unfi, r) for r in unfi]
4852 4852 phases.advanceboundary(repo, tr, targetphase, nodes)
4853 4853 if opts['force']:
4854 4854 phases.retractboundary(repo, tr, targetphase, nodes)
4855 4855 tr.close()
4856 4856 finally:
4857 4857 if tr is not None:
4858 4858 tr.release()
4859 4859 lock.release()
4860 4860 getphase = unfi._phasecache.phase
4861 4861 newdata = [getphase(unfi, r) for r in unfi]
4862 4862 changes = sum(newdata[r] != olddata[r] for r in unfi)
4863 4863 cl = unfi.changelog
4864 4864 rejected = [n for n in nodes
4865 4865 if newdata[cl.rev(n)] < targetphase]
4866 4866 if rejected:
4867 4867 ui.warn(_('cannot move %i changesets to a higher '
4868 4868 'phase, use --force\n') % len(rejected))
4869 4869 ret = 1
4870 4870 if changes:
4871 4871 msg = _('phase changed for %i changesets\n') % changes
4872 4872 if ret:
4873 4873 ui.status(msg)
4874 4874 else:
4875 4875 ui.note(msg)
4876 4876 else:
4877 4877 ui.warn(_('no phases changed\n'))
4878 4878 ret = 1
4879 4879 return ret
4880 4880
4881 4881 def postincoming(ui, repo, modheads, optupdate, checkout):
4882 4882 if modheads == 0:
4883 4883 return
4884 4884 if optupdate:
4885 4885 checkout, movemarkfrom = bookmarks.calculateupdate(ui, repo, checkout)
4886 4886 try:
4887 4887 ret = hg.update(repo, checkout)
4888 4888 except util.Abort, inst:
4889 4889 ui.warn(_("not updating: %s\n") % str(inst))
4890 4890 if inst.hint:
4891 4891 ui.warn(_("(%s)\n") % inst.hint)
4892 4892 return 0
4893 4893 if not ret and not checkout:
4894 4894 if bookmarks.update(repo, [movemarkfrom], repo['.'].node()):
4895 4895 ui.status(_("updating bookmark %s\n") % repo._bookmarkcurrent)
4896 4896 return ret
4897 4897 if modheads > 1:
4898 4898 currentbranchheads = len(repo.branchheads())
4899 4899 if currentbranchheads == modheads:
4900 4900 ui.status(_("(run 'hg heads' to see heads, 'hg merge' to merge)\n"))
4901 4901 elif currentbranchheads > 1:
4902 4902 ui.status(_("(run 'hg heads .' to see heads, 'hg merge' to "
4903 4903 "merge)\n"))
4904 4904 else:
4905 4905 ui.status(_("(run 'hg heads' to see heads)\n"))
4906 4906 else:
4907 4907 ui.status(_("(run 'hg update' to get a working copy)\n"))
4908 4908
4909 4909 @command('^pull',
4910 4910 [('u', 'update', None,
4911 4911 _('update to new branch head if changesets were pulled')),
4912 4912 ('f', 'force', None, _('run even when remote repository is unrelated')),
4913 4913 ('r', 'rev', [], _('a remote changeset intended to be added'), _('REV')),
4914 4914 ('B', 'bookmark', [], _("bookmark to pull"), _('BOOKMARK')),
4915 4915 ('b', 'branch', [], _('a specific branch you would like to pull'),
4916 4916 _('BRANCH')),
4917 4917 ] + remoteopts,
4918 4918 _('[-u] [-f] [-r REV]... [-e CMD] [--remotecmd CMD] [SOURCE]'))
4919 4919 def pull(ui, repo, source="default", **opts):
4920 4920 """pull changes from the specified source
4921 4921
4922 4922 Pull changes from a remote repository to a local one.
4923 4923
4924 4924 This finds all changes from the repository at the specified path
4925 4925 or URL and adds them to a local repository (the current one unless
4926 4926 -R is specified). By default, this does not update the copy of the
4927 4927 project in the working directory.
4928 4928
4929 4929 Use :hg:`incoming` if you want to see what would have been added
4930 4930 by a pull at the time you issued this command. If you then decide
4931 4931 to add those changes to the repository, you should use :hg:`pull
4932 4932 -r X` where ``X`` is the last changeset listed by :hg:`incoming`.
4933 4933
4934 4934 If SOURCE is omitted, the 'default' path will be used.
4935 4935 See :hg:`help urls` for more information.
4936 4936
4937 4937 Returns 0 on success, 1 if an update had unresolved files.
4938 4938 """
4939 4939 source, branches = hg.parseurl(ui.expandpath(source), opts.get('branch'))
4940 4940 other = hg.peer(repo, opts, source)
4941 4941 try:
4942 4942 ui.status(_('pulling from %s\n') % util.hidepassword(source))
4943 4943 revs, checkout = hg.addbranchrevs(repo, other, branches,
4944 4944 opts.get('rev'))
4945 4945
4946 4946 remotebookmarks = other.listkeys('bookmarks')
4947 4947
4948 4948 if opts.get('bookmark'):
4949 4949 if not revs:
4950 4950 revs = []
4951 4951 for b in opts['bookmark']:
4952 4952 if b not in remotebookmarks:
4953 4953 raise util.Abort(_('remote bookmark %s not found!') % b)
4954 4954 revs.append(remotebookmarks[b])
4955 4955
4956 4956 if revs:
4957 4957 try:
4958 4958 revs = [other.lookup(rev) for rev in revs]
4959 4959 except error.CapabilityError:
4960 4960 err = _("other repository doesn't support revision lookup, "
4961 4961 "so a rev cannot be specified.")
4962 4962 raise util.Abort(err)
4963 4963
4964 4964 modheads = exchange.pull(repo, other, heads=revs,
4965 4965 force=opts.get('force'),
4966 4966 bookmarks=opts.get('bookmark', ())).cgresult
4967 4967 if checkout:
4968 4968 checkout = str(repo.changelog.rev(other.lookup(checkout)))
4969 4969 repo._subtoppath = source
4970 4970 try:
4971 4971 ret = postincoming(ui, repo, modheads, opts.get('update'), checkout)
4972 4972
4973 4973 finally:
4974 4974 del repo._subtoppath
4975 4975
4976 4976 finally:
4977 4977 other.close()
4978 4978 return ret
4979 4979
4980 4980 @command('^push',
4981 4981 [('f', 'force', None, _('force push')),
4982 4982 ('r', 'rev', [],
4983 4983 _('a changeset intended to be included in the destination'),
4984 4984 _('REV')),
4985 4985 ('B', 'bookmark', [], _("bookmark to push"), _('BOOKMARK')),
4986 4986 ('b', 'branch', [],
4987 4987 _('a specific branch you would like to push'), _('BRANCH')),
4988 4988 ('', 'new-branch', False, _('allow pushing a new branch')),
4989 4989 ] + remoteopts,
4990 4990 _('[-f] [-r REV]... [-e CMD] [--remotecmd CMD] [DEST]'))
4991 4991 def push(ui, repo, dest=None, **opts):
4992 4992 """push changes to the specified destination
4993 4993
4994 4994 Push changesets from the local repository to the specified
4995 4995 destination.
4996 4996
4997 4997 This operation is symmetrical to pull: it is identical to a pull
4998 4998 in the destination repository from the current one.
4999 4999
5000 5000 By default, push will not allow creation of new heads at the
5001 5001 destination, since multiple heads would make it unclear which head
5002 5002 to use. In this situation, it is recommended to pull and merge
5003 5003 before pushing.
5004 5004
5005 5005 Use --new-branch if you want to allow push to create a new named
5006 5006 branch that is not present at the destination. This allows you to
5007 5007 only create a new branch without forcing other changes.
5008 5008
5009 5009 .. note::
5010 5010
5011 5011 Extra care should be taken with the -f/--force option,
5012 5012 which will push all new heads on all branches, an action which will
5013 5013 almost always cause confusion for collaborators.
5014 5014
5015 5015 If -r/--rev is used, the specified revision and all its ancestors
5016 5016 will be pushed to the remote repository.
5017 5017
5018 5018 If -B/--bookmark is used, the specified bookmarked revision, its
5019 5019 ancestors, and the bookmark will be pushed to the remote
5020 5020 repository.
5021 5021
5022 5022 Please see :hg:`help urls` for important details about ``ssh://``
5023 5023 URLs. If DESTINATION is omitted, a default path will be used.
5024 5024
5025 5025 Returns 0 if push was successful, 1 if nothing to push.
5026 5026 """
5027 5027
5028 5028 if opts.get('bookmark'):
5029 5029 ui.setconfig('bookmarks', 'pushing', opts['bookmark'], 'push')
5030 5030 for b in opts['bookmark']:
5031 5031 # translate -B options to -r so changesets get pushed
5032 5032 if b in repo._bookmarks:
5033 5033 opts.setdefault('rev', []).append(b)
5034 5034 else:
5035 5035 # if we try to push a deleted bookmark, translate it to null
5036 5036 # this lets simultaneous -r, -b options continue working
5037 5037 opts.setdefault('rev', []).append("null")
5038 5038
5039 5039 dest = ui.expandpath(dest or 'default-push', dest or 'default')
5040 5040 dest, branches = hg.parseurl(dest, opts.get('branch'))
5041 5041 ui.status(_('pushing to %s\n') % util.hidepassword(dest))
5042 5042 revs, checkout = hg.addbranchrevs(repo, repo, branches, opts.get('rev'))
5043 5043 try:
5044 5044 other = hg.peer(repo, opts, dest)
5045 5045 except error.RepoError:
5046 5046 if dest == "default-push":
5047 5047 raise util.Abort(_("default repository not configured!"),
5048 5048 hint=_('see the "path" section in "hg help config"'))
5049 5049 else:
5050 5050 raise
5051 5051
5052 5052 if revs:
5053 5053 revs = [repo.lookup(r) for r in scmutil.revrange(repo, revs)]
5054 5054
5055 5055 repo._subtoppath = dest
5056 5056 try:
5057 5057 # push subrepos depth-first for coherent ordering
5058 5058 c = repo['']
5059 5059 subs = c.substate # only repos that are committed
5060 5060 for s in sorted(subs):
5061 5061 result = c.sub(s).push(opts)
5062 5062 if result == 0:
5063 5063 return not result
5064 5064 finally:
5065 5065 del repo._subtoppath
5066 5066 pushop = exchange.push(repo, other, opts.get('force'), revs=revs,
5067 5067 newbranch=opts.get('new_branch'),
5068 5068 bookmarks=opts.get('bookmark', ()))
5069 5069
5070 5070 result = not pushop.cgresult
5071 5071
5072 5072 if pushop.bkresult is not None:
5073 5073 if pushop.bkresult == 2:
5074 5074 result = 2
5075 5075 elif not result and pushop.bkresult:
5076 5076 result = 2
5077 5077
5078 5078 return result
5079 5079
5080 5080 @command('recover', [])
5081 5081 def recover(ui, repo):
5082 5082 """roll back an interrupted transaction
5083 5083
5084 5084 Recover from an interrupted commit or pull.
5085 5085
5086 5086 This command tries to fix the repository status after an
5087 5087 interrupted operation. It should only be necessary when Mercurial
5088 5088 suggests it.
5089 5089
5090 5090 Returns 0 if successful, 1 if nothing to recover or verify fails.
5091 5091 """
5092 5092 if repo.recover():
5093 5093 return hg.verify(repo)
5094 5094 return 1
5095 5095
5096 5096 @command('^remove|rm',
5097 5097 [('A', 'after', None, _('record delete for missing files')),
5098 5098 ('f', 'force', None,
5099 5099 _('remove (and delete) file even if added or modified')),
5100 5100 ] + walkopts,
5101 5101 _('[OPTION]... FILE...'),
5102 5102 inferrepo=True)
5103 5103 def remove(ui, repo, *pats, **opts):
5104 5104 """remove the specified files on the next commit
5105 5105
5106 5106 Schedule the indicated files for removal from the current branch.
5107 5107
5108 5108 This command schedules the files to be removed at the next commit.
5109 5109 To undo a remove before that, see :hg:`revert`. To undo added
5110 5110 files, see :hg:`forget`.
5111 5111
5112 5112 .. container:: verbose
5113 5113
5114 5114 -A/--after can be used to remove only files that have already
5115 5115 been deleted, -f/--force can be used to force deletion, and -Af
5116 5116 can be used to remove files from the next revision without
5117 5117 deleting them from the working directory.
5118 5118
5119 5119 The following table details the behavior of remove for different
5120 5120 file states (columns) and option combinations (rows). The file
5121 5121 states are Added [A], Clean [C], Modified [M] and Missing [!]
5122 5122 (as reported by :hg:`status`). The actions are Warn, Remove
5123 5123 (from branch) and Delete (from disk):
5124 5124
5125 5125 ========= == == == ==
5126 5126 opt/state A C M !
5127 5127 ========= == == == ==
5128 5128 none W RD W R
5129 5129 -f R RD RD R
5130 5130 -A W W W R
5131 5131 -Af R R R R
5132 5132 ========= == == == ==
5133 5133
5134 5134 Note that remove never deletes files in Added [A] state from the
5135 5135 working directory, not even if option --force is specified.
5136 5136
5137 5137 Returns 0 on success, 1 if any warnings encountered.
5138 5138 """
5139 5139
5140 5140 ret = 0
5141 5141 after, force = opts.get('after'), opts.get('force')
5142 5142 if not pats and not after:
5143 5143 raise util.Abort(_('no files specified'))
5144 5144
5145 5145 m = scmutil.match(repo[None], pats, opts)
5146 5146 s = repo.status(match=m, clean=True)
5147 5147 modified, added, deleted, clean = s[0], s[1], s[3], s[6]
5148 5148
5149 5149 # warn about failure to delete explicit files/dirs
5150 5150 wctx = repo[None]
5151 5151 for f in m.files():
5152 5152 if f in repo.dirstate or f in wctx.dirs():
5153 5153 continue
5154 5154 if os.path.exists(m.rel(f)):
5155 5155 if os.path.isdir(m.rel(f)):
5156 5156 ui.warn(_('not removing %s: no tracked files\n') % m.rel(f))
5157 5157 else:
5158 5158 ui.warn(_('not removing %s: file is untracked\n') % m.rel(f))
5159 5159 # missing files will generate a warning elsewhere
5160 5160 ret = 1
5161 5161
5162 5162 if force:
5163 5163 list = modified + deleted + clean + added
5164 5164 elif after:
5165 5165 list = deleted
5166 5166 for f in modified + added + clean:
5167 5167 ui.warn(_('not removing %s: file still exists\n') % m.rel(f))
5168 5168 ret = 1
5169 5169 else:
5170 5170 list = deleted + clean
5171 5171 for f in modified:
5172 5172 ui.warn(_('not removing %s: file is modified (use -f'
5173 5173 ' to force removal)\n') % m.rel(f))
5174 5174 ret = 1
5175 5175 for f in added:
5176 5176 ui.warn(_('not removing %s: file has been marked for add'
5177 5177 ' (use forget to undo)\n') % m.rel(f))
5178 5178 ret = 1
5179 5179
5180 5180 for f in sorted(list):
5181 5181 if ui.verbose or not m.exact(f):
5182 5182 ui.status(_('removing %s\n') % m.rel(f))
5183 5183
5184 5184 wlock = repo.wlock()
5185 5185 try:
5186 5186 if not after:
5187 5187 for f in list:
5188 5188 if f in added:
5189 5189 continue # we never unlink added files on remove
5190 5190 util.unlinkpath(repo.wjoin(f), ignoremissing=True)
5191 5191 repo[None].forget(list)
5192 5192 finally:
5193 5193 wlock.release()
5194 5194
5195 5195 return ret
5196 5196
5197 5197 @command('rename|move|mv',
5198 5198 [('A', 'after', None, _('record a rename that has already occurred')),
5199 5199 ('f', 'force', None, _('forcibly copy over an existing managed file')),
5200 5200 ] + walkopts + dryrunopts,
5201 5201 _('[OPTION]... SOURCE... DEST'))
5202 5202 def rename(ui, repo, *pats, **opts):
5203 5203 """rename files; equivalent of copy + remove
5204 5204
5205 5205 Mark dest as copies of sources; mark sources for deletion. If dest
5206 5206 is a directory, copies are put in that directory. If dest is a
5207 5207 file, there can only be one source.
5208 5208
5209 5209 By default, this command copies the contents of files as they
5210 5210 exist in the working directory. If invoked with -A/--after, the
5211 5211 operation is recorded, but no copying is performed.
5212 5212
5213 5213 This command takes effect at the next commit. To undo a rename
5214 5214 before that, see :hg:`revert`.
5215 5215
5216 5216 Returns 0 on success, 1 if errors are encountered.
5217 5217 """
5218 5218 wlock = repo.wlock(False)
5219 5219 try:
5220 5220 return cmdutil.copy(ui, repo, pats, opts, rename=True)
5221 5221 finally:
5222 5222 wlock.release()
5223 5223
5224 5224 @command('resolve',
5225 5225 [('a', 'all', None, _('select all unresolved files')),
5226 5226 ('l', 'list', None, _('list state of files needing merge')),
5227 5227 ('m', 'mark', None, _('mark files as resolved')),
5228 5228 ('u', 'unmark', None, _('mark files as unresolved')),
5229 5229 ('n', 'no-status', None, _('hide status prefix'))]
5230 5230 + mergetoolopts + walkopts,
5231 5231 _('[OPTION]... [FILE]...'),
5232 5232 inferrepo=True)
5233 5233 def resolve(ui, repo, *pats, **opts):
5234 5234 """redo merges or set/view the merge status of files
5235 5235
5236 5236 Merges with unresolved conflicts are often the result of
5237 5237 non-interactive merging using the ``internal:merge`` configuration
5238 5238 setting, or a command-line merge tool like ``diff3``. The resolve
5239 5239 command is used to manage the files involved in a merge, after
5240 5240 :hg:`merge` has been run, and before :hg:`commit` is run (i.e. the
5241 5241 working directory must have two parents). See :hg:`help
5242 5242 merge-tools` for information on configuring merge tools.
5243 5243
5244 5244 The resolve command can be used in the following ways:
5245 5245
5246 5246 - :hg:`resolve [--tool TOOL] FILE...`: attempt to re-merge the specified
5247 5247 files, discarding any previous merge attempts. Re-merging is not
5248 5248 performed for files already marked as resolved. Use ``--all/-a``
5249 5249 to select all unresolved files. ``--tool`` can be used to specify
5250 5250 the merge tool used for the given files. It overrides the HGMERGE
5251 5251 environment variable and your configuration files. Previous file
5252 5252 contents are saved with a ``.orig`` suffix.
5253 5253
5254 5254 - :hg:`resolve -m [FILE]`: mark a file as having been resolved
5255 5255 (e.g. after having manually fixed-up the files). The default is
5256 5256 to mark all unresolved files.
5257 5257
5258 5258 - :hg:`resolve -u [FILE]...`: mark a file as unresolved. The
5259 5259 default is to mark all resolved files.
5260 5260
5261 5261 - :hg:`resolve -l`: list files which had or still have conflicts.
5262 5262 In the printed list, ``U`` = unresolved and ``R`` = resolved.
5263 5263
5264 5264 Note that Mercurial will not let you commit files with unresolved
5265 5265 merge conflicts. You must use :hg:`resolve -m ...` before you can
5266 5266 commit after a conflicting merge.
5267 5267
5268 5268 Returns 0 on success, 1 if any files fail a resolve attempt.
5269 5269 """
5270 5270
5271 5271 all, mark, unmark, show, nostatus = \
5272 5272 [opts.get(o) for o in 'all mark unmark list no_status'.split()]
5273 5273
5274 5274 if (show and (mark or unmark)) or (mark and unmark):
5275 5275 raise util.Abort(_("too many options specified"))
5276 5276 if pats and all:
5277 5277 raise util.Abort(_("can't specify --all and patterns"))
5278 5278 if not (all or pats or show or mark or unmark):
5279 5279 raise util.Abort(_('no files or directories specified'),
5280 5280 hint=('use --all to remerge all files'))
5281 5281
5282 5282 wlock = repo.wlock()
5283 5283 try:
5284 5284 ms = mergemod.mergestate(repo)
5285 5285
5286 5286 if not (ms.active() or repo.dirstate.p2() != nullid) and not show:
5287 5287 raise util.Abort(
5288 5288 _('resolve command not applicable when not merging'))
5289 5289
5290 5290 m = scmutil.match(repo[None], pats, opts)
5291 5291 ret = 0
5292 5292 didwork = False
5293 5293
5294 5294 for f in ms:
5295 5295 if not m(f):
5296 5296 continue
5297 5297
5298 5298 didwork = True
5299 5299
5300 5300 if show:
5301 5301 if nostatus:
5302 5302 ui.write("%s\n" % f)
5303 5303 else:
5304 5304 ui.write("%s %s\n" % (ms[f].upper(), f),
5305 5305 label='resolve.' +
5306 5306 {'u': 'unresolved', 'r': 'resolved'}[ms[f]])
5307 5307 elif mark:
5308 5308 ms.mark(f, "r")
5309 5309 elif unmark:
5310 5310 ms.mark(f, "u")
5311 5311 else:
5312 5312 wctx = repo[None]
5313 5313
5314 5314 # backup pre-resolve (merge uses .orig for its own purposes)
5315 5315 a = repo.wjoin(f)
5316 5316 util.copyfile(a, a + ".resolve")
5317 5317
5318 5318 try:
5319 5319 # resolve file
5320 5320 ui.setconfig('ui', 'forcemerge', opts.get('tool', ''),
5321 5321 'resolve')
5322 5322 if ms.resolve(f, wctx):
5323 5323 ret = 1
5324 5324 finally:
5325 5325 ui.setconfig('ui', 'forcemerge', '', 'resolve')
5326 5326 ms.commit()
5327 5327
5328 5328 # replace filemerge's .orig file with our resolve file
5329 5329 util.rename(a + ".resolve", a + ".orig")
5330 5330
5331 5331 ms.commit()
5332 5332
5333 5333 if not didwork and pats:
5334 5334 ui.warn(_("arguments do not match paths that need resolving\n"))
5335 5335
5336 5336 finally:
5337 5337 wlock.release()
5338 5338
5339 5339 # Nudge users into finishing an unfinished operation. We don't print
5340 5340 # this with the list/show operation because we want list/show to remain
5341 5341 # machine readable.
5342 5342 if not list(ms.unresolved()) and not show:
5343 5343 ui.status(_('(no more unresolved files)\n'))
5344 5344
5345 5345 return ret
5346 5346
5347 5347 @command('revert',
5348 5348 [('a', 'all', None, _('revert all changes when no arguments given')),
5349 5349 ('d', 'date', '', _('tipmost revision matching date'), _('DATE')),
5350 5350 ('r', 'rev', '', _('revert to the specified revision'), _('REV')),
5351 5351 ('C', 'no-backup', None, _('do not save backup copies of files')),
5352 5352 ] + walkopts + dryrunopts,
5353 5353 _('[OPTION]... [-r REV] [NAME]...'))
5354 5354 def revert(ui, repo, *pats, **opts):
5355 5355 """restore files to their checkout state
5356 5356
5357 5357 .. note::
5358 5358
5359 5359 To check out earlier revisions, you should use :hg:`update REV`.
5360 5360 To cancel an uncommitted merge (and lose your changes),
5361 5361 use :hg:`update --clean .`.
5362 5362
5363 5363 With no revision specified, revert the specified files or directories
5364 5364 to the contents they had in the parent of the working directory.
5365 5365 This restores the contents of files to an unmodified
5366 5366 state and unschedules adds, removes, copies, and renames. If the
5367 5367 working directory has two parents, you must explicitly specify a
5368 5368 revision.
5369 5369
5370 5370 Using the -r/--rev or -d/--date options, revert the given files or
5371 5371 directories to their states as of a specific revision. Because
5372 5372 revert does not change the working directory parents, this will
5373 5373 cause these files to appear modified. This can be helpful to "back
5374 5374 out" some or all of an earlier change. See :hg:`backout` for a
5375 5375 related method.
5376 5376
5377 5377 Modified files are saved with a .orig suffix before reverting.
5378 5378 To disable these backups, use --no-backup.
5379 5379
5380 5380 See :hg:`help dates` for a list of formats valid for -d/--date.
5381 5381
5382 5382 Returns 0 on success.
5383 5383 """
5384 5384
5385 5385 if opts.get("date"):
5386 5386 if opts.get("rev"):
5387 5387 raise util.Abort(_("you can't specify a revision and a date"))
5388 5388 opts["rev"] = cmdutil.finddate(ui, repo, opts["date"])
5389 5389
5390 5390 parent, p2 = repo.dirstate.parents()
5391 5391 if not opts.get('rev') and p2 != nullid:
5392 5392 # revert after merge is a trap for new users (issue2915)
5393 5393 raise util.Abort(_('uncommitted merge with no revision specified'),
5394 5394 hint=_('use "hg update" or see "hg help revert"'))
5395 5395
5396 5396 ctx = scmutil.revsingle(repo, opts.get('rev'))
5397 5397
5398 5398 if not pats and not opts.get('all'):
5399 5399 msg = _("no files or directories specified")
5400 5400 if p2 != nullid:
5401 5401 hint = _("uncommitted merge, use --all to discard all changes,"
5402 5402 " or 'hg update -C .' to abort the merge")
5403 5403 raise util.Abort(msg, hint=hint)
5404 5404 dirty = util.any(repo.status())
5405 5405 node = ctx.node()
5406 5406 if node != parent:
5407 5407 if dirty:
5408 5408 hint = _("uncommitted changes, use --all to discard all"
5409 5409 " changes, or 'hg update %s' to update") % ctx.rev()
5410 5410 else:
5411 5411 hint = _("use --all to revert all files,"
5412 5412 " or 'hg update %s' to update") % ctx.rev()
5413 5413 elif dirty:
5414 5414 hint = _("uncommitted changes, use --all to discard all changes")
5415 5415 else:
5416 5416 hint = _("use --all to revert all files")
5417 5417 raise util.Abort(msg, hint=hint)
5418 5418
5419 5419 return cmdutil.revert(ui, repo, ctx, (parent, p2), *pats, **opts)
5420 5420
5421 5421 @command('rollback', dryrunopts +
5422 5422 [('f', 'force', False, _('ignore safety measures'))])
5423 5423 def rollback(ui, repo, **opts):
5424 5424 """roll back the last transaction (DANGEROUS) (DEPRECATED)
5425 5425
5426 5426 Please use :hg:`commit --amend` instead of rollback to correct
5427 5427 mistakes in the last commit.
5428 5428
5429 5429 This command should be used with care. There is only one level of
5430 5430 rollback, and there is no way to undo a rollback. It will also
5431 5431 restore the dirstate at the time of the last transaction, losing
5432 5432 any dirstate changes since that time. This command does not alter
5433 5433 the working directory.
5434 5434
5435 5435 Transactions are used to encapsulate the effects of all commands
5436 5436 that create new changesets or propagate existing changesets into a
5437 5437 repository.
5438 5438
5439 5439 .. container:: verbose
5440 5440
5441 5441 For example, the following commands are transactional, and their
5442 5442 effects can be rolled back:
5443 5443
5444 5444 - commit
5445 5445 - import
5446 5446 - pull
5447 5447 - push (with this repository as the destination)
5448 5448 - unbundle
5449 5449
5450 5450 To avoid permanent data loss, rollback will refuse to rollback a
5451 5451 commit transaction if it isn't checked out. Use --force to
5452 5452 override this protection.
5453 5453
5454 5454 This command is not intended for use on public repositories. Once
5455 5455 changes are visible for pull by other users, rolling a transaction
5456 5456 back locally is ineffective (someone else may already have pulled
5457 5457 the changes). Furthermore, a race is possible with readers of the
5458 5458 repository; for example an in-progress pull from the repository
5459 5459 may fail if a rollback is performed.
5460 5460
5461 5461 Returns 0 on success, 1 if no rollback data is available.
5462 5462 """
5463 5463 return repo.rollback(dryrun=opts.get('dry_run'),
5464 5464 force=opts.get('force'))
5465 5465
5466 5466 @command('root', [])
5467 5467 def root(ui, repo):
5468 5468 """print the root (top) of the current working directory
5469 5469
5470 5470 Print the root directory of the current repository.
5471 5471
5472 5472 Returns 0 on success.
5473 5473 """
5474 5474 ui.write(repo.root + "\n")
5475 5475
5476 5476 @command('^serve',
5477 5477 [('A', 'accesslog', '', _('name of access log file to write to'),
5478 5478 _('FILE')),
5479 5479 ('d', 'daemon', None, _('run server in background')),
5480 ('', 'daemon-pipefds', '', _('used internally by daemon mode'), _('NUM')),
5480 ('', 'daemon-pipefds', '', _('used internally by daemon mode'), _('FILE')),
5481 5481 ('E', 'errorlog', '', _('name of error log file to write to'), _('FILE')),
5482 5482 # use string type, then we can check if something was passed
5483 5483 ('p', 'port', '', _('port to listen on (default: 8000)'), _('PORT')),
5484 5484 ('a', 'address', '', _('address to listen on (default: all interfaces)'),
5485 5485 _('ADDR')),
5486 5486 ('', 'prefix', '', _('prefix path to serve from (default: server root)'),
5487 5487 _('PREFIX')),
5488 5488 ('n', 'name', '',
5489 5489 _('name to show in web pages (default: working directory)'), _('NAME')),
5490 5490 ('', 'web-conf', '',
5491 5491 _('name of the hgweb config file (see "hg help hgweb")'), _('FILE')),
5492 5492 ('', 'webdir-conf', '', _('name of the hgweb config file (DEPRECATED)'),
5493 5493 _('FILE')),
5494 5494 ('', 'pid-file', '', _('name of file to write process ID to'), _('FILE')),
5495 5495 ('', 'stdio', None, _('for remote clients')),
5496 5496 ('', 'cmdserver', '', _('for remote clients'), _('MODE')),
5497 5497 ('t', 'templates', '', _('web templates to use'), _('TEMPLATE')),
5498 5498 ('', 'style', '', _('template style to use'), _('STYLE')),
5499 5499 ('6', 'ipv6', None, _('use IPv6 in addition to IPv4')),
5500 5500 ('', 'certificate', '', _('SSL certificate file'), _('FILE'))],
5501 5501 _('[OPTION]...'),
5502 5502 optionalrepo=True)
5503 5503 def serve(ui, repo, **opts):
5504 5504 """start stand-alone webserver
5505 5505
5506 5506 Start a local HTTP repository browser and pull server. You can use
5507 5507 this for ad-hoc sharing and browsing of repositories. It is
5508 5508 recommended to use a real web server to serve a repository for
5509 5509 longer periods of time.
5510 5510
5511 5511 Please note that the server does not implement access control.
5512 5512 This means that, by default, anybody can read from the server and
5513 5513 nobody can write to it by default. Set the ``web.allow_push``
5514 5514 option to ``*`` to allow everybody to push to the server. You
5515 5515 should use a real web server if you need to authenticate users.
5516 5516
5517 5517 By default, the server logs accesses to stdout and errors to
5518 5518 stderr. Use the -A/--accesslog and -E/--errorlog options to log to
5519 5519 files.
5520 5520
5521 5521 To have the server choose a free port number to listen on, specify
5522 5522 a port number of 0; in this case, the server will print the port
5523 5523 number it uses.
5524 5524
5525 5525 Returns 0 on success.
5526 5526 """
5527 5527
5528 5528 if opts["stdio"] and opts["cmdserver"]:
5529 5529 raise util.Abort(_("cannot use --stdio with --cmdserver"))
5530 5530
5531 5531 if opts["stdio"]:
5532 5532 if repo is None:
5533 5533 raise error.RepoError(_("there is no Mercurial repository here"
5534 5534 " (.hg not found)"))
5535 5535 s = sshserver.sshserver(ui, repo)
5536 5536 s.serve_forever()
5537 5537
5538 5538 if opts["cmdserver"]:
5539 5539 service = commandserver.createservice(ui, repo, opts)
5540 5540 return cmdutil.service(opts, initfn=service.init, runfn=service.run)
5541 5541
5542 5542 # this way we can check if something was given in the command-line
5543 5543 if opts.get('port'):
5544 5544 opts['port'] = util.getport(opts.get('port'))
5545 5545
5546 5546 baseui = repo and repo.baseui or ui
5547 5547 optlist = ("name templates style address port prefix ipv6"
5548 5548 " accesslog errorlog certificate encoding")
5549 5549 for o in optlist.split():
5550 5550 val = opts.get(o, '')
5551 5551 if val in (None, ''): # should check against default options instead
5552 5552 continue
5553 5553 baseui.setconfig("web", o, val, 'serve')
5554 5554 if repo and repo.ui != baseui:
5555 5555 repo.ui.setconfig("web", o, val, 'serve')
5556 5556
5557 5557 o = opts.get('web_conf') or opts.get('webdir_conf')
5558 5558 if not o:
5559 5559 if not repo:
5560 5560 raise error.RepoError(_("there is no Mercurial repository"
5561 5561 " here (.hg not found)"))
5562 5562 o = repo
5563 5563
5564 5564 app = hgweb.hgweb(o, baseui=baseui)
5565 5565 service = httpservice(ui, app, opts)
5566 5566 cmdutil.service(opts, initfn=service.init, runfn=service.run)
5567 5567
5568 5568 class httpservice(object):
5569 5569 def __init__(self, ui, app, opts):
5570 5570 self.ui = ui
5571 5571 self.app = app
5572 5572 self.opts = opts
5573 5573
5574 5574 def init(self):
5575 5575 util.setsignalhandler()
5576 5576 self.httpd = hgweb_server.create_server(self.ui, self.app)
5577 5577
5578 5578 if self.opts['port'] and not self.ui.verbose:
5579 5579 return
5580 5580
5581 5581 if self.httpd.prefix:
5582 5582 prefix = self.httpd.prefix.strip('/') + '/'
5583 5583 else:
5584 5584 prefix = ''
5585 5585
5586 5586 port = ':%d' % self.httpd.port
5587 5587 if port == ':80':
5588 5588 port = ''
5589 5589
5590 5590 bindaddr = self.httpd.addr
5591 5591 if bindaddr == '0.0.0.0':
5592 5592 bindaddr = '*'
5593 5593 elif ':' in bindaddr: # IPv6
5594 5594 bindaddr = '[%s]' % bindaddr
5595 5595
5596 5596 fqaddr = self.httpd.fqaddr
5597 5597 if ':' in fqaddr:
5598 5598 fqaddr = '[%s]' % fqaddr
5599 5599 if self.opts['port']:
5600 5600 write = self.ui.status
5601 5601 else:
5602 5602 write = self.ui.write
5603 5603 write(_('listening at http://%s%s/%s (bound to %s:%d)\n') %
5604 5604 (fqaddr, port, prefix, bindaddr, self.httpd.port))
5605 5605 self.ui.flush() # avoid buffering of status message
5606 5606
5607 5607 def run(self):
5608 5608 self.httpd.serve_forever()
5609 5609
5610 5610
5611 5611 @command('^status|st',
5612 5612 [('A', 'all', None, _('show status of all files')),
5613 5613 ('m', 'modified', None, _('show only modified files')),
5614 5614 ('a', 'added', None, _('show only added files')),
5615 5615 ('r', 'removed', None, _('show only removed files')),
5616 5616 ('d', 'deleted', None, _('show only deleted (but tracked) files')),
5617 5617 ('c', 'clean', None, _('show only files without changes')),
5618 5618 ('u', 'unknown', None, _('show only unknown (not tracked) files')),
5619 5619 ('i', 'ignored', None, _('show only ignored files')),
5620 5620 ('n', 'no-status', None, _('hide status prefix')),
5621 5621 ('C', 'copies', None, _('show source of copied files')),
5622 5622 ('0', 'print0', None, _('end filenames with NUL, for use with xargs')),
5623 5623 ('', 'rev', [], _('show difference from revision'), _('REV')),
5624 5624 ('', 'change', '', _('list the changed files of a revision'), _('REV')),
5625 5625 ] + walkopts + subrepoopts + formatteropts,
5626 5626 _('[OPTION]... [FILE]...'),
5627 5627 inferrepo=True)
5628 5628 def status(ui, repo, *pats, **opts):
5629 5629 """show changed files in the working directory
5630 5630
5631 5631 Show status of files in the repository. If names are given, only
5632 5632 files that match are shown. Files that are clean or ignored or
5633 5633 the source of a copy/move operation, are not listed unless
5634 5634 -c/--clean, -i/--ignored, -C/--copies or -A/--all are given.
5635 5635 Unless options described with "show only ..." are given, the
5636 5636 options -mardu are used.
5637 5637
5638 5638 Option -q/--quiet hides untracked (unknown and ignored) files
5639 5639 unless explicitly requested with -u/--unknown or -i/--ignored.
5640 5640
5641 5641 .. note::
5642 5642
5643 5643 status may appear to disagree with diff if permissions have
5644 5644 changed or a merge has occurred. The standard diff format does
5645 5645 not report permission changes and diff only reports changes
5646 5646 relative to one merge parent.
5647 5647
5648 5648 If one revision is given, it is used as the base revision.
5649 5649 If two revisions are given, the differences between them are
5650 5650 shown. The --change option can also be used as a shortcut to list
5651 5651 the changed files of a revision from its first parent.
5652 5652
5653 5653 The codes used to show the status of files are::
5654 5654
5655 5655 M = modified
5656 5656 A = added
5657 5657 R = removed
5658 5658 C = clean
5659 5659 ! = missing (deleted by non-hg command, but still tracked)
5660 5660 ? = not tracked
5661 5661 I = ignored
5662 5662 = origin of the previous file (with --copies)
5663 5663
5664 5664 .. container:: verbose
5665 5665
5666 5666 Examples:
5667 5667
5668 5668 - show changes in the working directory relative to a
5669 5669 changeset::
5670 5670
5671 5671 hg status --rev 9353
5672 5672
5673 5673 - show all changes including copies in an existing changeset::
5674 5674
5675 5675 hg status --copies --change 9353
5676 5676
5677 5677 - get a NUL separated list of added files, suitable for xargs::
5678 5678
5679 5679 hg status -an0
5680 5680
5681 5681 Returns 0 on success.
5682 5682 """
5683 5683
5684 5684 revs = opts.get('rev')
5685 5685 change = opts.get('change')
5686 5686
5687 5687 if revs and change:
5688 5688 msg = _('cannot specify --rev and --change at the same time')
5689 5689 raise util.Abort(msg)
5690 5690 elif change:
5691 5691 node2 = scmutil.revsingle(repo, change, None).node()
5692 5692 node1 = repo[node2].p1().node()
5693 5693 else:
5694 5694 node1, node2 = scmutil.revpair(repo, revs)
5695 5695
5696 5696 cwd = (pats and repo.getcwd()) or ''
5697 5697 end = opts.get('print0') and '\0' or '\n'
5698 5698 copy = {}
5699 5699 states = 'modified added removed deleted unknown ignored clean'.split()
5700 5700 show = [k for k in states if opts.get(k)]
5701 5701 if opts.get('all'):
5702 5702 show += ui.quiet and (states[:4] + ['clean']) or states
5703 5703 if not show:
5704 5704 show = ui.quiet and states[:4] or states[:5]
5705 5705
5706 5706 stat = repo.status(node1, node2, scmutil.match(repo[node2], pats, opts),
5707 5707 'ignored' in show, 'clean' in show, 'unknown' in show,
5708 5708 opts.get('subrepos'))
5709 5709 changestates = zip(states, 'MAR!?IC', stat)
5710 5710
5711 5711 if (opts.get('all') or opts.get('copies')) and not opts.get('no_status'):
5712 5712 copy = copies.pathcopies(repo[node1], repo[node2])
5713 5713
5714 5714 fm = ui.formatter('status', opts)
5715 5715 fmt = '%s' + end
5716 5716 showchar = not opts.get('no_status')
5717 5717
5718 5718 for state, char, files in changestates:
5719 5719 if state in show:
5720 5720 label = 'status.' + state
5721 5721 for f in files:
5722 5722 fm.startitem()
5723 5723 fm.condwrite(showchar, 'status', '%s ', char, label=label)
5724 5724 fm.write('path', fmt, repo.pathto(f, cwd), label=label)
5725 5725 if f in copy:
5726 5726 fm.write("copy", ' %s' + end, repo.pathto(copy[f], cwd),
5727 5727 label='status.copied')
5728 5728 fm.end()
5729 5729
5730 5730 @command('^summary|sum',
5731 5731 [('', 'remote', None, _('check for push and pull'))], '[--remote]')
5732 5732 def summary(ui, repo, **opts):
5733 5733 """summarize working directory state
5734 5734
5735 5735 This generates a brief summary of the working directory state,
5736 5736 including parents, branch, commit status, and available updates.
5737 5737
5738 5738 With the --remote option, this will check the default paths for
5739 5739 incoming and outgoing changes. This can be time-consuming.
5740 5740
5741 5741 Returns 0 on success.
5742 5742 """
5743 5743
5744 5744 ctx = repo[None]
5745 5745 parents = ctx.parents()
5746 5746 pnode = parents[0].node()
5747 5747 marks = []
5748 5748
5749 5749 for p in parents:
5750 5750 # label with log.changeset (instead of log.parent) since this
5751 5751 # shows a working directory parent *changeset*:
5752 5752 # i18n: column positioning for "hg summary"
5753 5753 ui.write(_('parent: %d:%s ') % (p.rev(), str(p)),
5754 5754 label='log.changeset changeset.%s' % p.phasestr())
5755 5755 ui.write(' '.join(p.tags()), label='log.tag')
5756 5756 if p.bookmarks():
5757 5757 marks.extend(p.bookmarks())
5758 5758 if p.rev() == -1:
5759 5759 if not len(repo):
5760 5760 ui.write(_(' (empty repository)'))
5761 5761 else:
5762 5762 ui.write(_(' (no revision checked out)'))
5763 5763 ui.write('\n')
5764 5764 if p.description():
5765 5765 ui.status(' ' + p.description().splitlines()[0].strip() + '\n',
5766 5766 label='log.summary')
5767 5767
5768 5768 branch = ctx.branch()
5769 5769 bheads = repo.branchheads(branch)
5770 5770 # i18n: column positioning for "hg summary"
5771 5771 m = _('branch: %s\n') % branch
5772 5772 if branch != 'default':
5773 5773 ui.write(m, label='log.branch')
5774 5774 else:
5775 5775 ui.status(m, label='log.branch')
5776 5776
5777 5777 if marks:
5778 5778 current = repo._bookmarkcurrent
5779 5779 # i18n: column positioning for "hg summary"
5780 5780 ui.write(_('bookmarks:'), label='log.bookmark')
5781 5781 if current is not None:
5782 5782 if current in marks:
5783 5783 ui.write(' *' + current, label='bookmarks.current')
5784 5784 marks.remove(current)
5785 5785 else:
5786 5786 ui.write(' [%s]' % current, label='bookmarks.current')
5787 5787 for m in marks:
5788 5788 ui.write(' ' + m, label='log.bookmark')
5789 5789 ui.write('\n', label='log.bookmark')
5790 5790
5791 5791 status = repo.status(unknown=True)
5792 5792
5793 5793 c = repo.dirstate.copies()
5794 5794 copied, renamed = [], []
5795 5795 for d, s in c.iteritems():
5796 5796 if s in status.removed:
5797 5797 status.removed.remove(s)
5798 5798 renamed.append(d)
5799 5799 else:
5800 5800 copied.append(d)
5801 5801 if d in status.added:
5802 5802 status.added.remove(d)
5803 5803
5804 5804 ms = mergemod.mergestate(repo)
5805 5805 unresolved = [f for f in ms if ms[f] == 'u']
5806 5806
5807 5807 subs = [s for s in ctx.substate if ctx.sub(s).dirty()]
5808 5808
5809 5809 labels = [(ui.label(_('%d modified'), 'status.modified'), status.modified),
5810 5810 (ui.label(_('%d added'), 'status.added'), status.added),
5811 5811 (ui.label(_('%d removed'), 'status.removed'), status.removed),
5812 5812 (ui.label(_('%d renamed'), 'status.copied'), renamed),
5813 5813 (ui.label(_('%d copied'), 'status.copied'), copied),
5814 5814 (ui.label(_('%d deleted'), 'status.deleted'), status.deleted),
5815 5815 (ui.label(_('%d unknown'), 'status.unknown'), status.unknown),
5816 5816 (ui.label(_('%d unresolved'), 'resolve.unresolved'), unresolved),
5817 5817 (ui.label(_('%d subrepos'), 'status.modified'), subs)]
5818 5818 t = []
5819 5819 for l, s in labels:
5820 5820 if s:
5821 5821 t.append(l % len(s))
5822 5822
5823 5823 t = ', '.join(t)
5824 5824 cleanworkdir = False
5825 5825
5826 5826 if repo.vfs.exists('updatestate'):
5827 5827 t += _(' (interrupted update)')
5828 5828 elif len(parents) > 1:
5829 5829 t += _(' (merge)')
5830 5830 elif branch != parents[0].branch():
5831 5831 t += _(' (new branch)')
5832 5832 elif (parents[0].closesbranch() and
5833 5833 pnode in repo.branchheads(branch, closed=True)):
5834 5834 t += _(' (head closed)')
5835 5835 elif not (status.modified or status.added or status.removed or renamed or
5836 5836 copied or subs):
5837 5837 t += _(' (clean)')
5838 5838 cleanworkdir = True
5839 5839 elif pnode not in bheads:
5840 5840 t += _(' (new branch head)')
5841 5841
5842 5842 if cleanworkdir:
5843 5843 # i18n: column positioning for "hg summary"
5844 5844 ui.status(_('commit: %s\n') % t.strip())
5845 5845 else:
5846 5846 # i18n: column positioning for "hg summary"
5847 5847 ui.write(_('commit: %s\n') % t.strip())
5848 5848
5849 5849 # all ancestors of branch heads - all ancestors of parent = new csets
5850 5850 new = len(repo.changelog.findmissing([pctx.node() for pctx in parents],
5851 5851 bheads))
5852 5852
5853 5853 if new == 0:
5854 5854 # i18n: column positioning for "hg summary"
5855 5855 ui.status(_('update: (current)\n'))
5856 5856 elif pnode not in bheads:
5857 5857 # i18n: column positioning for "hg summary"
5858 5858 ui.write(_('update: %d new changesets (update)\n') % new)
5859 5859 else:
5860 5860 # i18n: column positioning for "hg summary"
5861 5861 ui.write(_('update: %d new changesets, %d branch heads (merge)\n') %
5862 5862 (new, len(bheads)))
5863 5863
5864 5864 cmdutil.summaryhooks(ui, repo)
5865 5865
5866 5866 if opts.get('remote'):
5867 5867 needsincoming, needsoutgoing = True, True
5868 5868 else:
5869 5869 needsincoming, needsoutgoing = False, False
5870 5870 for i, o in cmdutil.summaryremotehooks(ui, repo, opts, None):
5871 5871 if i:
5872 5872 needsincoming = True
5873 5873 if o:
5874 5874 needsoutgoing = True
5875 5875 if not needsincoming and not needsoutgoing:
5876 5876 return
5877 5877
5878 5878 def getincoming():
5879 5879 source, branches = hg.parseurl(ui.expandpath('default'))
5880 5880 sbranch = branches[0]
5881 5881 try:
5882 5882 other = hg.peer(repo, {}, source)
5883 5883 except error.RepoError:
5884 5884 if opts.get('remote'):
5885 5885 raise
5886 5886 return source, sbranch, None, None, None
5887 5887 revs, checkout = hg.addbranchrevs(repo, other, branches, None)
5888 5888 if revs:
5889 5889 revs = [other.lookup(rev) for rev in revs]
5890 5890 ui.debug('comparing with %s\n' % util.hidepassword(source))
5891 5891 repo.ui.pushbuffer()
5892 5892 commoninc = discovery.findcommonincoming(repo, other, heads=revs)
5893 5893 repo.ui.popbuffer()
5894 5894 return source, sbranch, other, commoninc, commoninc[1]
5895 5895
5896 5896 if needsincoming:
5897 5897 source, sbranch, sother, commoninc, incoming = getincoming()
5898 5898 else:
5899 5899 source = sbranch = sother = commoninc = incoming = None
5900 5900
5901 5901 def getoutgoing():
5902 5902 dest, branches = hg.parseurl(ui.expandpath('default-push', 'default'))
5903 5903 dbranch = branches[0]
5904 5904 revs, checkout = hg.addbranchrevs(repo, repo, branches, None)
5905 5905 if source != dest:
5906 5906 try:
5907 5907 dother = hg.peer(repo, {}, dest)
5908 5908 except error.RepoError:
5909 5909 if opts.get('remote'):
5910 5910 raise
5911 5911 return dest, dbranch, None, None
5912 5912 ui.debug('comparing with %s\n' % util.hidepassword(dest))
5913 5913 elif sother is None:
5914 5914 # there is no explicit destination peer, but source one is invalid
5915 5915 return dest, dbranch, None, None
5916 5916 else:
5917 5917 dother = sother
5918 5918 if (source != dest or (sbranch is not None and sbranch != dbranch)):
5919 5919 common = None
5920 5920 else:
5921 5921 common = commoninc
5922 5922 if revs:
5923 5923 revs = [repo.lookup(rev) for rev in revs]
5924 5924 repo.ui.pushbuffer()
5925 5925 outgoing = discovery.findcommonoutgoing(repo, dother, onlyheads=revs,
5926 5926 commoninc=common)
5927 5927 repo.ui.popbuffer()
5928 5928 return dest, dbranch, dother, outgoing
5929 5929
5930 5930 if needsoutgoing:
5931 5931 dest, dbranch, dother, outgoing = getoutgoing()
5932 5932 else:
5933 5933 dest = dbranch = dother = outgoing = None
5934 5934
5935 5935 if opts.get('remote'):
5936 5936 t = []
5937 5937 if incoming:
5938 5938 t.append(_('1 or more incoming'))
5939 5939 o = outgoing.missing
5940 5940 if o:
5941 5941 t.append(_('%d outgoing') % len(o))
5942 5942 other = dother or sother
5943 5943 if 'bookmarks' in other.listkeys('namespaces'):
5944 5944 lmarks = repo.listkeys('bookmarks')
5945 5945 rmarks = other.listkeys('bookmarks')
5946 5946 diff = set(rmarks) - set(lmarks)
5947 5947 if len(diff) > 0:
5948 5948 t.append(_('%d incoming bookmarks') % len(diff))
5949 5949 diff = set(lmarks) - set(rmarks)
5950 5950 if len(diff) > 0:
5951 5951 t.append(_('%d outgoing bookmarks') % len(diff))
5952 5952
5953 5953 if t:
5954 5954 # i18n: column positioning for "hg summary"
5955 5955 ui.write(_('remote: %s\n') % (', '.join(t)))
5956 5956 else:
5957 5957 # i18n: column positioning for "hg summary"
5958 5958 ui.status(_('remote: (synced)\n'))
5959 5959
5960 5960 cmdutil.summaryremotehooks(ui, repo, opts,
5961 5961 ((source, sbranch, sother, commoninc),
5962 5962 (dest, dbranch, dother, outgoing)))
5963 5963
5964 5964 @command('tag',
5965 5965 [('f', 'force', None, _('force tag')),
5966 5966 ('l', 'local', None, _('make the tag local')),
5967 5967 ('r', 'rev', '', _('revision to tag'), _('REV')),
5968 5968 ('', 'remove', None, _('remove a tag')),
5969 5969 # -l/--local is already there, commitopts cannot be used
5970 5970 ('e', 'edit', None, _('invoke editor on commit messages')),
5971 5971 ('m', 'message', '', _('use text as commit message'), _('TEXT')),
5972 5972 ] + commitopts2,
5973 5973 _('[-f] [-l] [-m TEXT] [-d DATE] [-u USER] [-r REV] NAME...'))
5974 5974 def tag(ui, repo, name1, *names, **opts):
5975 5975 """add one or more tags for the current or given revision
5976 5976
5977 5977 Name a particular revision using <name>.
5978 5978
5979 5979 Tags are used to name particular revisions of the repository and are
5980 5980 very useful to compare different revisions, to go back to significant
5981 5981 earlier versions or to mark branch points as releases, etc. Changing
5982 5982 an existing tag is normally disallowed; use -f/--force to override.
5983 5983
5984 5984 If no revision is given, the parent of the working directory is
5985 5985 used.
5986 5986
5987 5987 To facilitate version control, distribution, and merging of tags,
5988 5988 they are stored as a file named ".hgtags" which is managed similarly
5989 5989 to other project files and can be hand-edited if necessary. This
5990 5990 also means that tagging creates a new commit. The file
5991 5991 ".hg/localtags" is used for local tags (not shared among
5992 5992 repositories).
5993 5993
5994 5994 Tag commits are usually made at the head of a branch. If the parent
5995 5995 of the working directory is not a branch head, :hg:`tag` aborts; use
5996 5996 -f/--force to force the tag commit to be based on a non-head
5997 5997 changeset.
5998 5998
5999 5999 See :hg:`help dates` for a list of formats valid for -d/--date.
6000 6000
6001 6001 Since tag names have priority over branch names during revision
6002 6002 lookup, using an existing branch name as a tag name is discouraged.
6003 6003
6004 6004 Returns 0 on success.
6005 6005 """
6006 6006 wlock = lock = None
6007 6007 try:
6008 6008 wlock = repo.wlock()
6009 6009 lock = repo.lock()
6010 6010 rev_ = "."
6011 6011 names = [t.strip() for t in (name1,) + names]
6012 6012 if len(names) != len(set(names)):
6013 6013 raise util.Abort(_('tag names must be unique'))
6014 6014 for n in names:
6015 6015 scmutil.checknewlabel(repo, n, 'tag')
6016 6016 if not n:
6017 6017 raise util.Abort(_('tag names cannot consist entirely of '
6018 6018 'whitespace'))
6019 6019 if opts.get('rev') and opts.get('remove'):
6020 6020 raise util.Abort(_("--rev and --remove are incompatible"))
6021 6021 if opts.get('rev'):
6022 6022 rev_ = opts['rev']
6023 6023 message = opts.get('message')
6024 6024 if opts.get('remove'):
6025 6025 expectedtype = opts.get('local') and 'local' or 'global'
6026 6026 for n in names:
6027 6027 if not repo.tagtype(n):
6028 6028 raise util.Abort(_("tag '%s' does not exist") % n)
6029 6029 if repo.tagtype(n) != expectedtype:
6030 6030 if expectedtype == 'global':
6031 6031 raise util.Abort(_("tag '%s' is not a global tag") % n)
6032 6032 else:
6033 6033 raise util.Abort(_("tag '%s' is not a local tag") % n)
6034 6034 rev_ = nullid
6035 6035 if not message:
6036 6036 # we don't translate commit messages
6037 6037 message = 'Removed tag %s' % ', '.join(names)
6038 6038 elif not opts.get('force'):
6039 6039 for n in names:
6040 6040 if n in repo.tags():
6041 6041 raise util.Abort(_("tag '%s' already exists "
6042 6042 "(use -f to force)") % n)
6043 6043 if not opts.get('local'):
6044 6044 p1, p2 = repo.dirstate.parents()
6045 6045 if p2 != nullid:
6046 6046 raise util.Abort(_('uncommitted merge'))
6047 6047 bheads = repo.branchheads()
6048 6048 if not opts.get('force') and bheads and p1 not in bheads:
6049 6049 raise util.Abort(_('not at a branch head (use -f to force)'))
6050 6050 r = scmutil.revsingle(repo, rev_).node()
6051 6051
6052 6052 if not message:
6053 6053 # we don't translate commit messages
6054 6054 message = ('Added tag %s for changeset %s' %
6055 6055 (', '.join(names), short(r)))
6056 6056
6057 6057 date = opts.get('date')
6058 6058 if date:
6059 6059 date = util.parsedate(date)
6060 6060
6061 6061 if opts.get('remove'):
6062 6062 editform = 'tag.remove'
6063 6063 else:
6064 6064 editform = 'tag.add'
6065 6065 editor = cmdutil.getcommiteditor(editform=editform, **opts)
6066 6066
6067 6067 # don't allow tagging the null rev
6068 6068 if (not opts.get('remove') and
6069 6069 scmutil.revsingle(repo, rev_).rev() == nullrev):
6070 6070 raise util.Abort(_("cannot tag null revision"))
6071 6071
6072 6072 repo.tag(names, r, message, opts.get('local'), opts.get('user'), date,
6073 6073 editor=editor)
6074 6074 finally:
6075 6075 release(lock, wlock)
6076 6076
6077 6077 @command('tags', formatteropts, '')
6078 6078 def tags(ui, repo, **opts):
6079 6079 """list repository tags
6080 6080
6081 6081 This lists both regular and local tags. When the -v/--verbose
6082 6082 switch is used, a third column "local" is printed for local tags.
6083 6083
6084 6084 Returns 0 on success.
6085 6085 """
6086 6086
6087 6087 fm = ui.formatter('tags', opts)
6088 6088 hexfunc = fm.hexfunc
6089 6089 tagtype = ""
6090 6090
6091 6091 for t, n in reversed(repo.tagslist()):
6092 6092 hn = hexfunc(n)
6093 6093 label = 'tags.normal'
6094 6094 tagtype = ''
6095 6095 if repo.tagtype(t) == 'local':
6096 6096 label = 'tags.local'
6097 6097 tagtype = 'local'
6098 6098
6099 6099 fm.startitem()
6100 6100 fm.write('tag', '%s', t, label=label)
6101 6101 fmt = " " * (30 - encoding.colwidth(t)) + ' %5d:%s'
6102 6102 fm.condwrite(not ui.quiet, 'rev node', fmt,
6103 6103 repo.changelog.rev(n), hn, label=label)
6104 6104 fm.condwrite(ui.verbose and tagtype, 'type', ' %s',
6105 6105 tagtype, label=label)
6106 6106 fm.plain('\n')
6107 6107 fm.end()
6108 6108
6109 6109 @command('tip',
6110 6110 [('p', 'patch', None, _('show patch')),
6111 6111 ('g', 'git', None, _('use git extended diff format')),
6112 6112 ] + templateopts,
6113 6113 _('[-p] [-g]'))
6114 6114 def tip(ui, repo, **opts):
6115 6115 """show the tip revision (DEPRECATED)
6116 6116
6117 6117 The tip revision (usually just called the tip) is the changeset
6118 6118 most recently added to the repository (and therefore the most
6119 6119 recently changed head).
6120 6120
6121 6121 If you have just made a commit, that commit will be the tip. If
6122 6122 you have just pulled changes from another repository, the tip of
6123 6123 that repository becomes the current tip. The "tip" tag is special
6124 6124 and cannot be renamed or assigned to a different changeset.
6125 6125
6126 6126 This command is deprecated, please use :hg:`heads` instead.
6127 6127
6128 6128 Returns 0 on success.
6129 6129 """
6130 6130 displayer = cmdutil.show_changeset(ui, repo, opts)
6131 6131 displayer.show(repo['tip'])
6132 6132 displayer.close()
6133 6133
6134 6134 @command('unbundle',
6135 6135 [('u', 'update', None,
6136 6136 _('update to new branch head if changesets were unbundled'))],
6137 6137 _('[-u] FILE...'))
6138 6138 def unbundle(ui, repo, fname1, *fnames, **opts):
6139 6139 """apply one or more changegroup files
6140 6140
6141 6141 Apply one or more compressed changegroup files generated by the
6142 6142 bundle command.
6143 6143
6144 6144 Returns 0 on success, 1 if an update has unresolved files.
6145 6145 """
6146 6146 fnames = (fname1,) + fnames
6147 6147
6148 6148 lock = repo.lock()
6149 6149 try:
6150 6150 for fname in fnames:
6151 6151 f = hg.openpath(ui, fname)
6152 6152 gen = exchange.readbundle(ui, f, fname)
6153 6153 modheads = changegroup.addchangegroup(repo, gen, 'unbundle',
6154 6154 'bundle:' + fname)
6155 6155 finally:
6156 6156 lock.release()
6157 6157
6158 6158 return postincoming(ui, repo, modheads, opts.get('update'), None)
6159 6159
6160 6160 @command('^update|up|checkout|co',
6161 6161 [('C', 'clean', None, _('discard uncommitted changes (no backup)')),
6162 6162 ('c', 'check', None,
6163 6163 _('update across branches if no uncommitted changes')),
6164 6164 ('d', 'date', '', _('tipmost revision matching date'), _('DATE')),
6165 6165 ('r', 'rev', '', _('revision'), _('REV'))
6166 6166 ] + mergetoolopts,
6167 6167 _('[-c] [-C] [-d DATE] [[-r] REV]'))
6168 6168 def update(ui, repo, node=None, rev=None, clean=False, date=None, check=False,
6169 6169 tool=None):
6170 6170 """update working directory (or switch revisions)
6171 6171
6172 6172 Update the repository's working directory to the specified
6173 6173 changeset. If no changeset is specified, update to the tip of the
6174 6174 current named branch and move the current bookmark (see :hg:`help
6175 6175 bookmarks`).
6176 6176
6177 6177 Update sets the working directory's parent revision to the specified
6178 6178 changeset (see :hg:`help parents`).
6179 6179
6180 6180 If the changeset is not a descendant or ancestor of the working
6181 6181 directory's parent, the update is aborted. With the -c/--check
6182 6182 option, the working directory is checked for uncommitted changes; if
6183 6183 none are found, the working directory is updated to the specified
6184 6184 changeset.
6185 6185
6186 6186 .. container:: verbose
6187 6187
6188 6188 The following rules apply when the working directory contains
6189 6189 uncommitted changes:
6190 6190
6191 6191 1. If neither -c/--check nor -C/--clean is specified, and if
6192 6192 the requested changeset is an ancestor or descendant of
6193 6193 the working directory's parent, the uncommitted changes
6194 6194 are merged into the requested changeset and the merged
6195 6195 result is left uncommitted. If the requested changeset is
6196 6196 not an ancestor or descendant (that is, it is on another
6197 6197 branch), the update is aborted and the uncommitted changes
6198 6198 are preserved.
6199 6199
6200 6200 2. With the -c/--check option, the update is aborted and the
6201 6201 uncommitted changes are preserved.
6202 6202
6203 6203 3. With the -C/--clean option, uncommitted changes are discarded and
6204 6204 the working directory is updated to the requested changeset.
6205 6205
6206 6206 To cancel an uncommitted merge (and lose your changes), use
6207 6207 :hg:`update --clean .`.
6208 6208
6209 6209 Use null as the changeset to remove the working directory (like
6210 6210 :hg:`clone -U`).
6211 6211
6212 6212 If you want to revert just one file to an older revision, use
6213 6213 :hg:`revert [-r REV] NAME`.
6214 6214
6215 6215 See :hg:`help dates` for a list of formats valid for -d/--date.
6216 6216
6217 6217 Returns 0 on success, 1 if there are unresolved files.
6218 6218 """
6219 6219 if rev and node:
6220 6220 raise util.Abort(_("please specify just one revision"))
6221 6221
6222 6222 if rev is None or rev == '':
6223 6223 rev = node
6224 6224
6225 6225 cmdutil.clearunfinished(repo)
6226 6226
6227 6227 # with no argument, we also move the current bookmark, if any
6228 6228 rev, movemarkfrom = bookmarks.calculateupdate(ui, repo, rev)
6229 6229
6230 6230 # if we defined a bookmark, we have to remember the original bookmark name
6231 6231 brev = rev
6232 6232 rev = scmutil.revsingle(repo, rev, rev).rev()
6233 6233
6234 6234 if check and clean:
6235 6235 raise util.Abort(_("cannot specify both -c/--check and -C/--clean"))
6236 6236
6237 6237 if date:
6238 6238 if rev is not None:
6239 6239 raise util.Abort(_("you can't specify a revision and a date"))
6240 6240 rev = cmdutil.finddate(ui, repo, date)
6241 6241
6242 6242 if check:
6243 6243 c = repo[None]
6244 6244 if c.dirty(merge=False, branch=False, missing=True):
6245 6245 raise util.Abort(_("uncommitted changes"))
6246 6246 if rev is None:
6247 6247 rev = repo[repo[None].branch()].rev()
6248 6248 mergemod._checkunknown(repo, repo[None], repo[rev])
6249 6249
6250 6250 repo.ui.setconfig('ui', 'forcemerge', tool, 'update')
6251 6251
6252 6252 if clean:
6253 6253 ret = hg.clean(repo, rev)
6254 6254 else:
6255 6255 ret = hg.update(repo, rev)
6256 6256
6257 6257 if not ret and movemarkfrom:
6258 6258 if bookmarks.update(repo, [movemarkfrom], repo['.'].node()):
6259 6259 ui.status(_("updating bookmark %s\n") % repo._bookmarkcurrent)
6260 6260 elif brev in repo._bookmarks:
6261 6261 bookmarks.setcurrent(repo, brev)
6262 6262 ui.status(_("(activating bookmark %s)\n") % brev)
6263 6263 elif brev:
6264 6264 if repo._bookmarkcurrent:
6265 6265 ui.status(_("(leaving bookmark %s)\n") %
6266 6266 repo._bookmarkcurrent)
6267 6267 bookmarks.unsetcurrent(repo)
6268 6268
6269 6269 return ret
6270 6270
6271 6271 @command('verify', [])
6272 6272 def verify(ui, repo):
6273 6273 """verify the integrity of the repository
6274 6274
6275 6275 Verify the integrity of the current repository.
6276 6276
6277 6277 This will perform an extensive check of the repository's
6278 6278 integrity, validating the hashes and checksums of each entry in
6279 6279 the changelog, manifest, and tracked files, as well as the
6280 6280 integrity of their crosslinks and indices.
6281 6281
6282 6282 Please see http://mercurial.selenic.com/wiki/RepositoryCorruption
6283 6283 for more information about recovery from corruption of the
6284 6284 repository.
6285 6285
6286 6286 Returns 0 on success, 1 if errors are encountered.
6287 6287 """
6288 6288 return hg.verify(repo)
6289 6289
6290 6290 @command('version', [], norepo=True)
6291 6291 def version_(ui):
6292 6292 """output version and copyright information"""
6293 6293 ui.write(_("Mercurial Distributed SCM (version %s)\n")
6294 6294 % util.version())
6295 6295 ui.status(_(
6296 6296 "(see http://mercurial.selenic.com for more information)\n"
6297 6297 "\nCopyright (C) 2005-2014 Matt Mackall and others\n"
6298 6298 "This is free software; see the source for copying conditions. "
6299 6299 "There is NO\nwarranty; "
6300 6300 "not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n"
6301 6301 ))
6302 6302
6303 6303 ui.note(_("\nEnabled extensions:\n\n"))
6304 6304 if ui.verbose:
6305 6305 # format names and versions into columns
6306 6306 names = []
6307 6307 vers = []
6308 6308 for name, module in extensions.extensions():
6309 6309 names.append(name)
6310 6310 vers.append(extensions.moduleversion(module))
6311 6311 if names:
6312 6312 maxnamelen = max(len(n) for n in names)
6313 6313 for i, name in enumerate(names):
6314 6314 ui.write(" %-*s %s\n" % (maxnamelen, name, vers[i]))
@@ -1,222 +1,234 b''
1 1 $ echo "[extensions]" >> $HGRCPATH
2 2 $ echo "extdiff=" >> $HGRCPATH
3 3
4 4 $ hg init a
5 5 $ cd a
6 6 $ echo a > a
7 7 $ echo b > b
8 8 $ hg add
9 9 adding a
10 10 adding b
11 11
12 12 Should diff cloned directories:
13 13
14 14 $ hg extdiff -o -r $opt
15 15 Only in a: a
16 16 Only in a: b
17 17 [1]
18 18
19 19 $ echo "[extdiff]" >> $HGRCPATH
20 20 $ echo "cmd.falabala=echo" >> $HGRCPATH
21 21 $ echo "opts.falabala=diffing" >> $HGRCPATH
22 $ echo "cmd.edspace=echo" >> $HGRCPATH
23 $ echo 'opts.edspace="name <user@example.com>"' >> $HGRCPATH
22 24
23 25 $ hg falabala
24 26 diffing a.000000000000 a
25 27 [1]
26 28
27 29 $ hg help falabala
28 30 hg falabala [OPTION]... [FILE]...
29 31
30 32 use 'echo' to diff repository (or selected files)
31 33
32 34 Show differences between revisions for the specified files, using the
33 35 'echo' program.
34 36
35 37 When two revision arguments are given, then changes are shown between
36 38 those revisions. If only one revision is specified then that revision is
37 39 compared to the working directory, and, when no revisions are specified,
38 40 the working directory files are compared to its parent.
39 41
40 42 options ([+] can be repeated):
41 43
42 44 -o --option OPT [+] pass option to comparison program
43 45 -r --rev REV [+] revision
44 46 -c --change REV change made by revision
45 47 -I --include PATTERN [+] include names matching the given patterns
46 48 -X --exclude PATTERN [+] exclude names matching the given patterns
47 49
48 50 (some details hidden, use --verbose to show complete help)
49 51
50 52 $ hg ci -d '0 0' -mtest1
51 53
52 54 $ echo b >> a
53 55 $ hg ci -d '1 0' -mtest2
54 56
55 57 Should diff cloned files directly:
56 58
57 59 $ hg falabala -r 0:1
58 60 diffing */extdiff.*/a.8a5febb7f867/a a.34eed99112ab/a (glob)
59 61 [1]
60 62
61 63 Test diff during merge:
62 64
63 65 $ hg update -C 0
64 66 1 files updated, 0 files merged, 0 files removed, 0 files unresolved
65 67 $ echo c >> c
66 68 $ hg add c
67 69 $ hg ci -m "new branch" -d '1 0'
68 70 created new head
69 71 $ hg merge 1
70 72 1 files updated, 0 files merged, 0 files removed, 0 files unresolved
71 73 (branch merge, don't forget to commit)
72 74
73 75 Should diff cloned file against wc file:
74 76
75 77 $ hg falabala
76 78 diffing */extdiff.*/a.2a13a4d2da36/a */a/a (glob)
77 79 [1]
78 80
79 81
80 82 Test --change option:
81 83
82 84 $ hg ci -d '2 0' -mtest3
83 85 $ hg falabala -c 1
84 86 diffing */extdiff.*/a.8a5febb7f867/a a.34eed99112ab/a (glob)
85 87 [1]
86 88
87 89 Check diff are made from the first parent:
88 90
89 91 $ hg falabala -c 3 || echo "diff-like tools yield a non-zero exit code"
90 92 diffing */extdiff.*/a.2a13a4d2da36/a a.46c0e4daeb72/a (glob)
91 93 diff-like tools yield a non-zero exit code
92 94
93 95 #if execbit
94 96
95 97 Test extdiff of multiple files in tmp dir:
96 98
97 99 $ hg update -C 0 > /dev/null
98 100 $ echo changed > a
99 101 $ echo changed > b
100 102 $ chmod +x b
101 103
102 104 Diff in working directory, before:
103 105
104 106 $ hg diff --git
105 107 diff --git a/a b/a
106 108 --- a/a
107 109 +++ b/a
108 110 @@ -1,1 +1,1 @@
109 111 -a
110 112 +changed
111 113 diff --git a/b b/b
112 114 old mode 100644
113 115 new mode 100755
114 116 --- a/b
115 117 +++ b/b
116 118 @@ -1,1 +1,1 @@
117 119 -b
118 120 +changed
119 121
120 122
121 123 Edit with extdiff -p:
122 124
123 125 Prepare custom diff/edit tool:
124 126
125 127 $ cat > 'diff tool.py' << EOT
126 128 > #!/usr/bin/env python
127 129 > import time
128 130 > time.sleep(1) # avoid unchanged-timestamp problems
129 131 > file('a/a', 'ab').write('edited\n')
130 132 > file('a/b', 'ab').write('edited\n')
131 133 > EOT
132 134
133 135 $ chmod +x 'diff tool.py'
134 136
135 137 will change to /tmp/extdiff.TMP and populate directories a.TMP and a
136 138 and start tool
137 139
138 140 $ hg extdiff -p "`pwd`/diff tool.py"
139 141 [1]
140 142
141 143 Diff in working directory, after:
142 144
143 145 $ hg diff --git
144 146 diff --git a/a b/a
145 147 --- a/a
146 148 +++ b/a
147 149 @@ -1,1 +1,2 @@
148 150 -a
149 151 +changed
150 152 +edited
151 153 diff --git a/b b/b
152 154 old mode 100644
153 155 new mode 100755
154 156 --- a/b
155 157 +++ b/b
156 158 @@ -1,1 +1,2 @@
157 159 -b
158 160 +changed
159 161 +edited
160 162
161 163 Test extdiff with --option:
162 164
163 165 $ hg extdiff -p echo -o this -c 1
164 166 this */extdiff.*/a.8a5febb7f867/a a.34eed99112ab/a (glob)
165 167 [1]
166 168
167 169 $ hg falabala -o this -c 1
168 170 diffing this */extdiff.*/a.8a5febb7f867/a a.34eed99112ab/a (glob)
169 171 [1]
170 172
173 Test extdiff's handling of options with spaces in them:
174
175 $ hg edspace -c 1
176 name <user@example.com> */extdiff.*/a.8a5febb7f867/a a.34eed99112ab/a (glob)
177 [1]
178
179 $ hg extdiff -p echo -o "name <user@example.com>" -c 1
180 name <user@example.com> */extdiff.*/a.8a5febb7f867/a a.34eed99112ab/a (glob)
181 [1]
182
171 183 Test with revsets:
172 184
173 185 $ hg extdif -p echo -c "rev(1)"
174 186 */extdiff.*/a.8a5febb7f867/a a.34eed99112ab/a (glob)
175 187 [1]
176 188
177 189 $ hg extdif -p echo -r "0::1"
178 190 */extdiff.*/a.8a5febb7f867/a a.34eed99112ab/a (glob)
179 191 [1]
180 192
181 193 Fallback to merge-tools.tool.executable|regkey
182 194 $ mkdir dir
183 195 $ cat > 'dir/tool.sh' << EOF
184 196 > #!/bin/sh
185 197 > echo "** custom diff **"
186 198 > EOF
187 199 $ chmod +x dir/tool.sh
188 200 $ tool=`pwd`/dir/tool.sh
189 201 $ hg --debug tl --config extdiff.tl= --config merge-tools.tl.executable=$tool
190 202 making snapshot of 2 files from rev * (glob)
191 203 a
192 204 b
193 205 making snapshot of 2 files from working directory
194 206 a
195 207 b
196 208 running "'$TESTTMP/a/dir/tool.sh' 'a.*' 'a'" in */extdiff.* (glob)
197 209 ** custom diff **
198 210 cleaning up temp directory
199 211 [1]
200 212
201 213 $ cd ..
202 214
203 215 #endif
204 216
205 217 #if symlink
206 218
207 219 Test symlinks handling (issue1909)
208 220
209 221 $ hg init testsymlinks
210 222 $ cd testsymlinks
211 223 $ echo a > a
212 224 $ hg ci -Am adda
213 225 adding a
214 226 $ echo a >> a
215 227 $ ln -s missing linka
216 228 $ hg add linka
217 229 $ hg falabala -r 0 --traceback
218 230 diffing testsymlinks.07f494440405 testsymlinks
219 231 [1]
220 232 $ cd ..
221 233
222 234 #endif
General Comments 0
You need to be logged in to leave comments. Login now