329
by Martin Pool
- refactor command functions into command classes |
1 |
# Copyright (C) 2004, 2005 by Canonical Ltd
|
1
by mbp at sourcefrog
import from baz patch-364 |
2 |
|
3 |
# This program is free software; you can redistribute it and/or modify
|
|
4 |
# it under the terms of the GNU General Public License as published by
|
|
5 |
# the Free Software Foundation; either version 2 of the License, or
|
|
6 |
# (at your option) any later version.
|
|
7 |
||
8 |
# This program is distributed in the hope that it will be useful,
|
|
9 |
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
10 |
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
11 |
# GNU General Public License for more details.
|
|
12 |
||
13 |
# You should have received a copy of the GNU General Public License
|
|
14 |
# along with this program; if not, write to the Free Software
|
|
15 |
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
|
16 |
||
17 |
||
18 |
||
338
by Martin Pool
- cleanup of some imports |
19 |
import sys, os, time, os.path |
1
by mbp at sourcefrog
import from baz patch-364 |
20 |
from sets import Set |
21 |
||
22 |
import bzrlib |
|
23 |
from bzrlib.trace import mutter, note, log_error |
|
329
by Martin Pool
- refactor command functions into command classes |
24 |
from bzrlib.errors import bailout, BzrError, BzrCheckError, BzrCommandError |
1
by mbp at sourcefrog
import from baz patch-364 |
25 |
from bzrlib.osutils import quotefn, pumpfile, isdir, isfile |
453
by Martin Pool
- Split WorkingTree into its own file |
26 |
from bzrlib.tree import RevisionTree, EmptyTree, Tree |
1
by mbp at sourcefrog
import from baz patch-364 |
27 |
from bzrlib.revision import Revision |
28 |
from bzrlib import Branch, Inventory, InventoryEntry, ScratchBranch, BZRDIR, \ |
|
29 |
format_date
|
|
30 |
||
31 |
||
350
by Martin Pool
- refactor command aliases into command classes |
32 |
def _squish_command_name(cmd): |
33 |
return 'cmd_' + cmd.replace('-', '_') |
|
34 |
||
35 |
||
36 |
def _unsquish_command_name(cmd): |
|
37 |
assert cmd.startswith("cmd_") |
|
38 |
return cmd[4:].replace('_','-') |
|
39 |
||
351
by Martin Pool
- Split out help functions into bzrlib.help |
40 |
def get_all_cmds(): |
350
by Martin Pool
- refactor command aliases into command classes |
41 |
"""Return canonical name and class for all registered commands."""
|
42 |
for k, v in globals().iteritems(): |
|
43 |
if k.startswith("cmd_"): |
|
44 |
yield _unsquish_command_name(k), v |
|
45 |
||
351
by Martin Pool
- Split out help functions into bzrlib.help |
46 |
def get_cmd_class(cmd): |
350
by Martin Pool
- refactor command aliases into command classes |
47 |
"""Return the canonical name and command class for a command.
|
48 |
"""
|
|
49 |
cmd = str(cmd) # not unicode |
|
50 |
||
51 |
# first look up this command under the specified name
|
|
272
by Martin Pool
- Add command aliases |
52 |
try: |
350
by Martin Pool
- refactor command aliases into command classes |
53 |
return cmd, globals()[_squish_command_name(cmd)] |
272
by Martin Pool
- Add command aliases |
54 |
except KeyError: |
350
by Martin Pool
- refactor command aliases into command classes |
55 |
pass
|
56 |
||
57 |
# look for any command which claims this as an alias
|
|
351
by Martin Pool
- Split out help functions into bzrlib.help |
58 |
for cmdname, cmdclass in get_all_cmds(): |
350
by Martin Pool
- refactor command aliases into command classes |
59 |
if cmd in cmdclass.aliases: |
60 |
return cmdname, cmdclass |
|
422
by Martin Pool
- External-command patch from mpe |
61 |
|
62 |
cmdclass = ExternalCommand.find_command(cmd) |
|
63 |
if cmdclass: |
|
64 |
return cmd, cmdclass |
|
65 |
||
66 |
raise BzrCommandError("unknown command %r" % cmd) |
|
272
by Martin Pool
- Add command aliases |
67 |
|
329
by Martin Pool
- refactor command functions into command classes |
68 |
|
69 |
class Command: |
|
70 |
"""Base class for commands.
|
|
71 |
||
72 |
The docstring for an actual command should give a single-line
|
|
73 |
summary, then a complete description of the command. A grammar
|
|
74 |
description will be inserted.
|
|
75 |
||
76 |
takes_args
|
|
77 |
List of argument forms, marked with whether they are optional,
|
|
78 |
repeated, etc.
|
|
79 |
||
80 |
takes_options
|
|
81 |
List of options that may be given for this command.
|
|
82 |
||
83 |
hidden
|
|
84 |
If true, this command isn't advertised.
|
|
85 |
"""
|
|
86 |
aliases = [] |
|
87 |
||
88 |
takes_args = [] |
|
89 |
takes_options = [] |
|
90 |
||
91 |
hidden = False |
|
92 |
||
93 |
def __init__(self, options, arguments): |
|
94 |
"""Construct and run the command.
|
|
95 |
||
96 |
Sets self.status to the return value of run()."""
|
|
97 |
assert isinstance(options, dict) |
|
98 |
assert isinstance(arguments, dict) |
|
99 |
cmdargs = options.copy() |
|
100 |
cmdargs.update(arguments) |
|
101 |
assert self.__doc__ != Command.__doc__, \ |
|
102 |
("No help message set for %r" % self) |
|
103 |
self.status = self.run(**cmdargs) |
|
104 |
||
105 |
||
106 |
def run(self): |
|
107 |
"""Override this in sub-classes.
|
|
108 |
||
109 |
This is invoked with the options and arguments bound to
|
|
110 |
keyword parameters.
|
|
111 |
||
337
by Martin Pool
- Clarify return codes from command objects |
112 |
Return 0 or None if the command was successful, or a shell
|
113 |
error code if not.
|
|
329
by Martin Pool
- refactor command functions into command classes |
114 |
"""
|
337
by Martin Pool
- Clarify return codes from command objects |
115 |
return 0 |
329
by Martin Pool
- refactor command functions into command classes |
116 |
|
117 |
||
422
by Martin Pool
- External-command patch from mpe |
118 |
class ExternalCommand(Command): |
119 |
"""Class to wrap external commands.
|
|
120 |
||
121 |
We cheat a little here, when get_cmd_class() calls us we actually give it back
|
|
122 |
an object we construct that has the appropriate path, help, options etc for the
|
|
123 |
specified command.
|
|
124 |
||
125 |
When run_bzr() tries to instantiate that 'class' it gets caught by the __call__
|
|
126 |
method, which we override to call the Command.__init__ method. That then calls
|
|
127 |
our run method which is pretty straight forward.
|
|
128 |
||
129 |
The only wrinkle is that we have to map bzr's dictionary of options and arguments
|
|
130 |
back into command line options and arguments for the script.
|
|
131 |
"""
|
|
132 |
||
133 |
def find_command(cls, cmd): |
|
134 |
bzrpath = os.environ.get('BZRPATH', '') |
|
135 |
||
136 |
for dir in bzrpath.split(':'): |
|
137 |
path = os.path.join(dir, cmd) |
|
138 |
if os.path.isfile(path): |
|
139 |
return ExternalCommand(path) |
|
140 |
||
141 |
return None |
|
142 |
||
143 |
find_command = classmethod(find_command) |
|
144 |
||
145 |
def __init__(self, path): |
|
146 |
self.path = path |
|
147 |
||
424
by Martin Pool
todo |
148 |
# TODO: If either of these fail, we should detect that and
|
149 |
# assume that path is not really a bzr plugin after all.
|
|
150 |
||
422
by Martin Pool
- External-command patch from mpe |
151 |
pipe = os.popen('%s --bzr-usage' % path, 'r') |
152 |
self.takes_options = pipe.readline().split() |
|
153 |
self.takes_args = pipe.readline().split() |
|
154 |
pipe.close() |
|
155 |
||
156 |
pipe = os.popen('%s --bzr-help' % path, 'r') |
|
157 |
self.__doc__ = pipe.read() |
|
158 |
pipe.close() |
|
159 |
||
160 |
def __call__(self, options, arguments): |
|
161 |
Command.__init__(self, options, arguments) |
|
162 |
return self |
|
163 |
||
164 |
def run(self, **kargs): |
|
165 |
opts = [] |
|
166 |
args = [] |
|
167 |
||
168 |
keys = kargs.keys() |
|
169 |
keys.sort() |
|
170 |
for name in keys: |
|
171 |
value = kargs[name] |
|
172 |
if OPTIONS.has_key(name): |
|
173 |
# it's an option
|
|
174 |
opts.append('--%s' % name) |
|
175 |
if value is not None and value is not True: |
|
176 |
opts.append(str(value)) |
|
177 |
else: |
|
178 |
# it's an arg, or arg list
|
|
179 |
if type(value) is not list: |
|
180 |
value = [value] |
|
181 |
for v in value: |
|
182 |
if v is not None: |
|
183 |
args.append(str(v)) |
|
184 |
||
185 |
self.status = os.spawnv(os.P_WAIT, self.path, [self.path] + opts + args) |
|
186 |
return self.status |
|
187 |
||
329
by Martin Pool
- refactor command functions into command classes |
188 |
|
189 |
class cmd_status(Command): |
|
1
by mbp at sourcefrog
import from baz patch-364 |
190 |
"""Display status summary.
|
191 |
||
466
by Martin Pool
- doc for status command |
192 |
This reports on versioned and unknown files, reporting them
|
193 |
grouped by state. Possible states are:
|
|
194 |
||
195 |
added
|
|
196 |
Versioned in the working copy but not in the previous revision.
|
|
197 |
||
198 |
removed
|
|
467
by Martin Pool
- doc for status command |
199 |
Versioned in the previous revision but removed or deleted
|
466
by Martin Pool
- doc for status command |
200 |
in the working copy.
|
201 |
||
202 |
renamed
|
|
203 |
Path of this file changed from the previous revision;
|
|
204 |
the text may also have changed. This includes files whose
|
|
467
by Martin Pool
- doc for status command |
205 |
parent directory was renamed.
|
466
by Martin Pool
- doc for status command |
206 |
|
207 |
modified
|
|
208 |
Text has changed since the previous revision.
|
|
209 |
||
210 |
unchanged
|
|
467
by Martin Pool
- doc for status command |
211 |
Nothing about this file has changed since the previous revision.
|
212 |
Only shown with --all.
|
|
466
by Martin Pool
- doc for status command |
213 |
|
214 |
unknown
|
|
215 |
Not versioned and not matching an ignore pattern.
|
|
216 |
||
217 |
To see ignored files use 'bzr ignored'. For details in the
|
|
218 |
changes to file texts, use 'bzr diff'.
|
|
468
by Martin Pool
- Interpret arguments to bzr status |
219 |
|
220 |
If no arguments are specified, the status of the entire working
|
|
221 |
directory is shown. Otherwise, only the status of the specified
|
|
222 |
files or directories is reported. If a directory is given, status
|
|
223 |
is reported for everything inside that directory.
|
|
1
by mbp at sourcefrog
import from baz patch-364 |
224 |
"""
|
404
by Martin Pool
- bzr status now optionally takes filenames to check |
225 |
takes_args = ['file*'] |
465
by Martin Pool
- Move show_status() out of Branch into a new function in |
226 |
takes_options = ['all', 'show-ids'] |
350
by Martin Pool
- refactor command aliases into command classes |
227 |
aliases = ['st', 'stat'] |
329
by Martin Pool
- refactor command functions into command classes |
228 |
|
465
by Martin Pool
- Move show_status() out of Branch into a new function in |
229 |
def run(self, all=False, show_ids=False, file_list=None): |
468
by Martin Pool
- Interpret arguments to bzr status |
230 |
if file_list: |
231 |
b = Branch(file_list[0], lock_mode='r') |
|
232 |
file_list = [b.relpath(x) for x in file_list] |
|
233 |
# special case: only one path was given and it's the root
|
|
234 |
# of the branch
|
|
235 |
if file_list == ['']: |
|
236 |
file_list = None |
|
237 |
else: |
|
238 |
b = Branch('.', lock_mode='r') |
|
465
by Martin Pool
- Move show_status() out of Branch into a new function in |
239 |
import status |
240 |
status.show_status(b, show_unchanged=all, show_ids=show_ids, |
|
483
by Martin Pool
- change 'file_list' to more explanatory 'specific_files' |
241 |
specific_files=file_list) |
329
by Martin Pool
- refactor command functions into command classes |
242 |
|
243 |
||
244 |
class cmd_cat_revision(Command): |
|
245 |
"""Write out metadata for a revision."""
|
|
246 |
||
247 |
hidden = True |
|
248 |
takes_args = ['revision_id'] |
|
249 |
||
250 |
def run(self, revision_id): |
|
251 |
Branch('.').get_revision(revision_id).write_xml(sys.stdout) |
|
252 |
||
253 |
||
254 |
class cmd_revno(Command): |
|
255 |
"""Show current revision number.
|
|
256 |
||
257 |
This is equal to the number of revisions on this branch."""
|
|
258 |
def run(self): |
|
259 |
print Branch('.').revno() |
|
260 |
||
261 |
||
262 |
class cmd_add(Command): |
|
70
by mbp at sourcefrog
Prepare for smart recursive add. |
263 |
"""Add specified files or directories.
|
264 |
||
265 |
In non-recursive mode, all the named items are added, regardless
|
|
266 |
of whether they were previously ignored. A warning is given if
|
|
267 |
any of the named files are already versioned.
|
|
268 |
||
269 |
In recursive mode (the default), files are treated the same way
|
|
270 |
but the behaviour for directories is different. Directories that
|
|
271 |
are already versioned do not give a warning. All directories,
|
|
272 |
whether already versioned or not, are searched for files or
|
|
273 |
subdirectories that are neither versioned or ignored, and these
|
|
274 |
are added. This search proceeds recursively into versioned
|
|
275 |
directories.
|
|
276 |
||
277 |
Therefore simply saying 'bzr add .' will version all files that
|
|
278 |
are currently unknown.
|
|
279
by Martin Pool
todo |
279 |
|
280 |
TODO: Perhaps adding a file whose directly is not versioned should
|
|
281 |
recursively add that parent, rather than giving an error?
|
|
70
by mbp at sourcefrog
Prepare for smart recursive add. |
282 |
"""
|
329
by Martin Pool
- refactor command functions into command classes |
283 |
takes_args = ['file+'] |
284 |
takes_options = ['verbose'] |
|
285 |
||
286 |
def run(self, file_list, verbose=False): |
|
287 |
bzrlib.add.smart_add(file_list, verbose) |
|
288 |
||
289 |
||
386
by Martin Pool
- Typo (reported by uws) |
290 |
class cmd_relpath(Command): |
329
by Martin Pool
- refactor command functions into command classes |
291 |
"""Show path of a file relative to root"""
|
392
by Martin Pool
- fix relpath and add tests |
292 |
takes_args = ['filename'] |
329
by Martin Pool
- refactor command functions into command classes |
293 |
|
392
by Martin Pool
- fix relpath and add tests |
294 |
def run(self, filename): |
295 |
print Branch(filename).relpath(filename) |
|
329
by Martin Pool
- refactor command functions into command classes |
296 |
|
297 |
||
298 |
||
299 |
class cmd_inventory(Command): |
|
300 |
"""Show inventory of the current working copy or a revision."""
|
|
301 |
takes_options = ['revision'] |
|
302 |
||
303 |
def run(self, revision=None): |
|
304 |
b = Branch('.') |
|
305 |
if revision == None: |
|
306 |
inv = b.read_working_inventory() |
|
307 |
else: |
|
308 |
inv = b.get_revision_inventory(b.lookup_revision(revision)) |
|
309 |
||
310 |
for path, entry in inv.iter_entries(): |
|
311 |
print '%-50s %s' % (entry.file_id, path) |
|
312 |
||
313 |
||
314 |
class cmd_move(Command): |
|
315 |
"""Move files to a different directory.
|
|
316 |
||
317 |
examples:
|
|
318 |
bzr move *.txt doc
|
|
319 |
||
320 |
The destination must be a versioned directory in the same branch.
|
|
321 |
"""
|
|
322 |
takes_args = ['source$', 'dest'] |
|
323 |
def run(self, source_list, dest): |
|
324 |
b = Branch('.') |
|
325 |
||
326 |
b.move([b.relpath(s) for s in source_list], b.relpath(dest)) |
|
327 |
||
328 |
||
329 |
class cmd_rename(Command): |
|
168
by mbp at sourcefrog
new "rename" command |
330 |
"""Change the name of an entry.
|
331 |
||
232
by mbp at sourcefrog
Allow docstrings for help to be in PEP0257 format. |
332 |
examples:
|
333 |
bzr rename frob.c frobber.c
|
|
334 |
bzr rename src/frob.c lib/frob.c
|
|
335 |
||
336 |
It is an error if the destination name exists.
|
|
337 |
||
338 |
See also the 'move' command, which moves files into a different
|
|
339 |
directory without changing their name.
|
|
340 |
||
341 |
TODO: Some way to rename multiple files without invoking bzr for each
|
|
342 |
one?"""
|
|
329
by Martin Pool
- refactor command functions into command classes |
343 |
takes_args = ['from_name', 'to_name'] |
168
by mbp at sourcefrog
new "rename" command |
344 |
|
329
by Martin Pool
- refactor command functions into command classes |
345 |
def run(self, from_name, to_name): |
346 |
b = Branch('.') |
|
347 |
b.rename_one(b.relpath(from_name), b.relpath(to_name)) |
|
348 |
||
349 |
||
350 |
||
351 |
class cmd_renames(Command): |
|
164
by mbp at sourcefrog
new 'renames' command |
352 |
"""Show list of renamed files.
|
353 |
||
232
by mbp at sourcefrog
Allow docstrings for help to be in PEP0257 format. |
354 |
TODO: Option to show renames between two historical versions.
|
355 |
||
356 |
TODO: Only show renames under dir, rather than in the whole branch.
|
|
357 |
"""
|
|
329
by Martin Pool
- refactor command functions into command classes |
358 |
takes_args = ['dir?'] |
359 |
||
360 |
def run(self, dir='.'): |
|
361 |
b = Branch(dir) |
|
362 |
old_inv = b.basis_tree().inventory |
|
363 |
new_inv = b.read_working_inventory() |
|
364 |
||
365 |
renames = list(bzrlib.tree.find_renames(old_inv, new_inv)) |
|
366 |
renames.sort() |
|
367 |
for old_name, new_name in renames: |
|
368 |
print "%s => %s" % (old_name, new_name) |
|
369 |
||
370 |
||
371 |
class cmd_info(Command): |
|
472
by Martin Pool
- Optional branch parameter to info command |
372 |
"""Show statistical information about a branch."""
|
373 |
takes_args = ['branch?'] |
|
374 |
||
375 |
def run(self, branch=None): |
|
329
by Martin Pool
- refactor command functions into command classes |
376 |
import info |
472
by Martin Pool
- Optional branch parameter to info command |
377 |
|
378 |
from branch import find_branch |
|
379 |
b = find_branch(branch) |
|
380 |
info.show_info(b) |
|
329
by Martin Pool
- refactor command functions into command classes |
381 |
|
382 |
||
383 |
class cmd_remove(Command): |
|
384 |
"""Make a file unversioned.
|
|
385 |
||
386 |
This makes bzr stop tracking changes to a versioned file. It does
|
|
387 |
not delete the working copy.
|
|
388 |
"""
|
|
389 |
takes_args = ['file+'] |
|
390 |
takes_options = ['verbose'] |
|
391 |
||
392 |
def run(self, file_list, verbose=False): |
|
393 |
b = Branch(file_list[0]) |
|
394 |
b.remove([b.relpath(f) for f in file_list], verbose=verbose) |
|
395 |
||
396 |
||
397 |
class cmd_file_id(Command): |
|
178
by mbp at sourcefrog
- Use a non-null file_id for the branch root directory. At the moment |
398 |
"""Print file_id of a particular file or directory.
|
399 |
||
232
by mbp at sourcefrog
Allow docstrings for help to be in PEP0257 format. |
400 |
The file_id is assigned when the file is first added and remains the
|
401 |
same through all revisions where the file exists, even when it is
|
|
402 |
moved or renamed.
|
|
403 |
"""
|
|
329
by Martin Pool
- refactor command functions into command classes |
404 |
hidden = True |
405 |
takes_args = ['filename'] |
|
406 |
def run(self, filename): |
|
407 |
b = Branch(filename) |
|
408 |
i = b.inventory.path2id(b.relpath(filename)) |
|
409 |
if i == None: |
|
410 |
bailout("%r is not a versioned file" % filename) |
|
411 |
else: |
|
412 |
print i |
|
413 |
||
414 |
||
415 |
class cmd_file_path(Command): |
|
178
by mbp at sourcefrog
- Use a non-null file_id for the branch root directory. At the moment |
416 |
"""Print path of file_ids to a file or directory.
|
417 |
||
232
by mbp at sourcefrog
Allow docstrings for help to be in PEP0257 format. |
418 |
This prints one line for each directory down to the target,
|
419 |
starting at the branch root."""
|
|
329
by Martin Pool
- refactor command functions into command classes |
420 |
hidden = True |
421 |
takes_args = ['filename'] |
|
422 |
def run(self, filename): |
|
423 |
b = Branch(filename) |
|
424 |
inv = b.inventory |
|
425 |
fid = inv.path2id(b.relpath(filename)) |
|
426 |
if fid == None: |
|
427 |
bailout("%r is not a versioned file" % filename) |
|
428 |
for fip in inv.get_idpath(fid): |
|
429 |
print fip |
|
430 |
||
431 |
||
432 |
class cmd_revision_history(Command): |
|
433 |
"""Display list of revision ids on this branch."""
|
|
434 |
def run(self): |
|
435 |
for patchid in Branch('.').revision_history(): |
|
436 |
print patchid |
|
437 |
||
438 |
||
439 |
class cmd_directories(Command): |
|
440 |
"""Display list of versioned directories in this branch."""
|
|
441 |
def run(self): |
|
442 |
for name, ie in Branch('.').read_working_inventory().directories(): |
|
443 |
if name == '': |
|
444 |
print '.' |
|
445 |
else: |
|
446 |
print name |
|
447 |
||
448 |
||
449 |
class cmd_init(Command): |
|
450 |
"""Make a directory into a versioned branch.
|
|
451 |
||
452 |
Use this to create an empty branch, or before importing an
|
|
453 |
existing project.
|
|
454 |
||
455 |
Recipe for importing a tree of files:
|
|
456 |
cd ~/project
|
|
457 |
bzr init
|
|
458 |
bzr add -v .
|
|
459 |
bzr status
|
|
460 |
bzr commit -m 'imported project'
|
|
461 |
"""
|
|
462 |
def run(self): |
|
463 |
Branch('.', init=True) |
|
464 |
||
465 |
||
466 |
class cmd_diff(Command): |
|
467 |
"""Show differences in working tree.
|
|
468 |
|
|
232
by mbp at sourcefrog
Allow docstrings for help to be in PEP0257 format. |
469 |
If files are listed, only the changes in those files are listed.
|
470 |
Otherwise, all changes for the tree are listed.
|
|
471 |
||
472 |
TODO: Given two revision arguments, show the difference between them.
|
|
473 |
||
474 |
TODO: Allow diff across branches.
|
|
475 |
||
476 |
TODO: Option to use external diff command; could be GNU diff, wdiff,
|
|
477 |
or a graphical diff.
|
|
478 |
||
276
by Martin Pool
Doc |
479 |
TODO: Python difflib is not exactly the same as unidiff; should
|
480 |
either fix it up or prefer to use an external diff.
|
|
481 |
||
232
by mbp at sourcefrog
Allow docstrings for help to be in PEP0257 format. |
482 |
TODO: If a directory is given, diff everything under that.
|
483 |
||
276
by Martin Pool
Doc |
484 |
TODO: Selected-file diff is inefficient and doesn't show you
|
485 |
deleted files.
|
|
278
by Martin Pool
- Better workaround for trailing newlines in diffs |
486 |
|
487 |
TODO: This probably handles non-Unix newlines poorly.
|
|
329
by Martin Pool
- refactor command functions into command classes |
488 |
"""
|
489 |
||
490 |
takes_args = ['file*'] |
|
491 |
takes_options = ['revision'] |
|
350
by Martin Pool
- refactor command aliases into command classes |
492 |
aliases = ['di'] |
329
by Martin Pool
- refactor command functions into command classes |
493 |
|
494 |
def run(self, revision=None, file_list=None): |
|
495 |
from bzrlib.diff import show_diff |
|
496 |
||
483
by Martin Pool
- change 'file_list' to more explanatory 'specific_files' |
497 |
show_diff(Branch('.'), revision, specific_files=file_list) |
329
by Martin Pool
- refactor command functions into command classes |
498 |
|
499 |
||
437
by Martin Pool
- new command 'bzr modified' to exercise the statcache |
500 |
|
501 |
||
502 |
||
329
by Martin Pool
- refactor command functions into command classes |
503 |
class cmd_deleted(Command): |
135
by mbp at sourcefrog
Simple new 'deleted' command |
504 |
"""List files deleted in the working tree.
|
505 |
||
232
by mbp at sourcefrog
Allow docstrings for help to be in PEP0257 format. |
506 |
TODO: Show files deleted since a previous revision, or between two revisions.
|
135
by mbp at sourcefrog
Simple new 'deleted' command |
507 |
"""
|
329
by Martin Pool
- refactor command functions into command classes |
508 |
def run(self, show_ids=False): |
509 |
b = Branch('.') |
|
510 |
old = b.basis_tree() |
|
511 |
new = b.working_tree() |
|
512 |
||
513 |
## TODO: Much more efficient way to do this: read in new
|
|
514 |
## directories with readdir, rather than stating each one. Same
|
|
515 |
## level of effort but possibly much less IO. (Or possibly not,
|
|
516 |
## if the directories are very large...)
|
|
517 |
||
518 |
for path, ie in old.inventory.iter_entries(): |
|
519 |
if not new.has_id(ie.file_id): |
|
520 |
if show_ids: |
|
521 |
print '%-50s %s' % (path, ie.file_id) |
|
522 |
else: |
|
523 |
print path |
|
524 |
||
437
by Martin Pool
- new command 'bzr modified' to exercise the statcache |
525 |
|
526 |
class cmd_modified(Command): |
|
527 |
"""List files modified in working tree."""
|
|
528 |
hidden = True |
|
529 |
def run(self): |
|
530 |
import statcache |
|
531 |
b = Branch('.') |
|
438
by Martin Pool
- Avoid calling Inventory.iter_entries() when finding modified |
532 |
inv = b.read_working_inventory() |
533 |
sc = statcache.update_cache(b, inv) |
|
437
by Martin Pool
- new command 'bzr modified' to exercise the statcache |
534 |
basis = b.basis_tree() |
535 |
basis_inv = basis.inventory |
|
438
by Martin Pool
- Avoid calling Inventory.iter_entries() when finding modified |
536 |
|
537 |
# We used to do this through iter_entries(), but that's slow
|
|
538 |
# when most of the files are unmodified, as is usually the
|
|
539 |
# case. So instead we iterate by inventory entry, and only
|
|
540 |
# calculate paths as necessary.
|
|
541 |
||
542 |
for file_id in basis_inv: |
|
543 |
cacheentry = sc.get(file_id) |
|
544 |
if not cacheentry: # deleted |
|
545 |
continue
|
|
546 |
ie = basis_inv[file_id] |
|
437
by Martin Pool
- new command 'bzr modified' to exercise the statcache |
547 |
if cacheentry[statcache.SC_SHA1] != ie.text_sha1: |
438
by Martin Pool
- Avoid calling Inventory.iter_entries() when finding modified |
548 |
path = inv.id2path(file_id) |
437
by Martin Pool
- new command 'bzr modified' to exercise the statcache |
549 |
print path |
439
by Martin Pool
- new command 'bzr added' |
550 |
|
551 |
||
552 |
||
553 |
class cmd_added(Command): |
|
554 |
"""List files added in working tree."""
|
|
555 |
hidden = True |
|
556 |
def run(self): |
|
557 |
b = Branch('.') |
|
558 |
wt = b.working_tree() |
|
559 |
basis_inv = b.basis_tree().inventory |
|
560 |
inv = wt.inventory |
|
561 |
for file_id in inv: |
|
562 |
if file_id in basis_inv: |
|
563 |
continue
|
|
564 |
path = inv.id2path(file_id) |
|
565 |
if not os.access(b.abspath(path), os.F_OK): |
|
566 |
continue
|
|
567 |
print path |
|
437
by Martin Pool
- new command 'bzr modified' to exercise the statcache |
568 |
|
569 |
||
570 |
||
329
by Martin Pool
- refactor command functions into command classes |
571 |
class cmd_root(Command): |
572 |
"""Show the tree root directory.
|
|
573 |
||
574 |
The root is the nearest enclosing directory with a .bzr control
|
|
575 |
directory."""
|
|
576 |
takes_args = ['filename?'] |
|
577 |
def run(self, filename=None): |
|
578 |
"""Print the branch root."""
|
|
416
by Martin Pool
- bzr log and bzr root now accept an http URL |
579 |
from branch import find_branch |
580 |
b = find_branch(filename) |
|
581 |
print getattr(b, 'base', None) or getattr(b, 'baseurl') |
|
329
by Martin Pool
- refactor command functions into command classes |
582 |
|
583 |
||
584 |
class cmd_log(Command): |
|
1
by mbp at sourcefrog
import from baz patch-364 |
585 |
"""Show log of this branch.
|
586 |
||
367
by Martin Pool
- New --show-ids option for bzr log |
587 |
TODO: Option to limit range.
|
588 |
||
589 |
TODO: Perhaps show most-recent first with an option for last.
|
|
1
by mbp at sourcefrog
import from baz patch-364 |
590 |
"""
|
378
by Martin Pool
- New usage bzr log FILENAME |
591 |
takes_args = ['filename?'] |
367
by Martin Pool
- New --show-ids option for bzr log |
592 |
takes_options = ['timezone', 'verbose', 'show-ids'] |
378
by Martin Pool
- New usage bzr log FILENAME |
593 |
def run(self, filename=None, timezone='original', verbose=False, show_ids=False): |
416
by Martin Pool
- bzr log and bzr root now accept an http URL |
594 |
from branch import find_branch |
595 |
b = find_branch((filename or '.'), lock_mode='r') |
|
378
by Martin Pool
- New usage bzr log FILENAME |
596 |
if filename: |
597 |
filename = b.relpath(filename) |
|
598 |
bzrlib.show_log(b, filename, |
|
371
by Martin Pool
- Fix up bzr log command |
599 |
show_timezone=timezone, |
600 |
verbose=verbose, |
|
601 |
show_ids=show_ids) |
|
329
by Martin Pool
- refactor command functions into command classes |
602 |
|
603 |
||
375
by Martin Pool
- New command touching-revisions and function to trace |
604 |
|
605 |
class cmd_touching_revisions(Command): |
|
606 |
"""Return revision-ids which affected a particular file."""
|
|
607 |
hidden = True |
|
608 |
takes_args = ["filename"] |
|
609 |
def run(self, filename): |
|
610 |
b = Branch(filename, lock_mode='r') |
|
611 |
inv = b.read_working_inventory() |
|
612 |
file_id = inv.path2id(b.relpath(filename)) |
|
613 |
for revno, revision_id, what in bzrlib.log.find_touching_revisions(b, file_id): |
|
614 |
print "%6d %s" % (revno, what) |
|
615 |
||
616 |
||
329
by Martin Pool
- refactor command functions into command classes |
617 |
class cmd_ls(Command): |
1
by mbp at sourcefrog
import from baz patch-364 |
618 |
"""List files in a tree.
|
619 |
||
254
by Martin Pool
- Doc cleanups from Magnus Therning |
620 |
TODO: Take a revision or remote path and list that tree instead.
|
1
by mbp at sourcefrog
import from baz patch-364 |
621 |
"""
|
329
by Martin Pool
- refactor command functions into command classes |
622 |
hidden = True |
623 |
def run(self, revision=None, verbose=False): |
|
624 |
b = Branch('.') |
|
625 |
if revision == None: |
|
626 |
tree = b.working_tree() |
|
627 |
else: |
|
628 |
tree = b.revision_tree(b.lookup_revision(revision)) |
|
629 |
||
630 |
for fp, fc, kind, fid in tree.list_files(): |
|
631 |
if verbose: |
|
632 |
if kind == 'directory': |
|
633 |
kindch = '/' |
|
634 |
elif kind == 'file': |
|
635 |
kindch = '' |
|
636 |
else: |
|
637 |
kindch = '???' |
|
638 |
||
639 |
print '%-8s %s%s' % (fc, fp, kindch) |
|
1
by mbp at sourcefrog
import from baz patch-364 |
640 |
else: |
329
by Martin Pool
- refactor command functions into command classes |
641 |
print fp |
642 |
||
643 |
||
644 |
||
645 |
class cmd_unknowns(Command): |
|
1
by mbp at sourcefrog
import from baz patch-364 |
646 |
"""List unknown files"""
|
329
by Martin Pool
- refactor command functions into command classes |
647 |
def run(self): |
648 |
for f in Branch('.').unknowns(): |
|
649 |
print quotefn(f) |
|
650 |
||
651 |
||
652 |
||
653 |
class cmd_ignore(Command): |
|
420
by Martin Pool
Doc |
654 |
"""Ignore a command or pattern
|
655 |
||
656 |
To remove patterns from the ignore list, edit the .bzrignore file.
|
|
657 |
||
658 |
If the pattern contains a slash, it is compared to the whole path
|
|
659 |
from the branch root. Otherwise, it is comapred to only the last
|
|
660 |
component of the path.
|
|
661 |
||
662 |
Ignore patterns are case-insensitive on case-insensitive systems.
|
|
663 |
||
664 |
Note: wildcards must be quoted from the shell on Unix.
|
|
665 |
||
666 |
examples:
|
|
667 |
bzr ignore ./Makefile
|
|
668 |
bzr ignore '*.class'
|
|
669 |
"""
|
|
329
by Martin Pool
- refactor command functions into command classes |
670 |
takes_args = ['name_pattern'] |
310
by Martin Pool
- new 'bzr ignored' command! |
671 |
|
329
by Martin Pool
- refactor command functions into command classes |
672 |
def run(self, name_pattern): |
409
by Martin Pool
- New AtomicFile class |
673 |
from bzrlib.atomicfile import AtomicFile |
674 |
import codecs |
|
675 |
||
329
by Martin Pool
- refactor command functions into command classes |
676 |
b = Branch('.') |
410
by Martin Pool
- Fix ignore command and add tests |
677 |
ifn = b.abspath('.bzrignore') |
329
by Martin Pool
- refactor command functions into command classes |
678 |
|
409
by Martin Pool
- New AtomicFile class |
679 |
# FIXME: probably doesn't handle non-ascii patterns
|
680 |
||
410
by Martin Pool
- Fix ignore command and add tests |
681 |
if os.path.exists(ifn): |
682 |
f = b.controlfile(ifn, 'rt') |
|
409
by Martin Pool
- New AtomicFile class |
683 |
igns = f.read() |
684 |
f.close() |
|
685 |
else: |
|
686 |
igns = '' |
|
687 |
||
688 |
if igns and igns[-1] != '\n': |
|
689 |
igns += '\n' |
|
690 |
igns += name_pattern + '\n' |
|
691 |
||
410
by Martin Pool
- Fix ignore command and add tests |
692 |
f = AtomicFile(ifn, 'wt') |
409
by Martin Pool
- New AtomicFile class |
693 |
f.write(igns) |
694 |
f.commit() |
|
329
by Martin Pool
- refactor command functions into command classes |
695 |
|
696 |
inv = b.working_tree().inventory |
|
697 |
if inv.path2id('.bzrignore'): |
|
698 |
mutter('.bzrignore is already versioned') |
|
699 |
else: |
|
700 |
mutter('need to make new .bzrignore file versioned') |
|
701 |
b.add(['.bzrignore']) |
|
702 |
||
703 |
||
704 |
||
705 |
class cmd_ignored(Command): |
|
421
by Martin Pool
doc |
706 |
"""List ignored files and the patterns that matched them.
|
707 |
||
708 |
See also: bzr ignore"""
|
|
329
by Martin Pool
- refactor command functions into command classes |
709 |
def run(self): |
710 |
tree = Branch('.').working_tree() |
|
711 |
for path, file_class, kind, file_id in tree.list_files(): |
|
712 |
if file_class != 'I': |
|
713 |
continue
|
|
714 |
## XXX: Slightly inefficient since this was already calculated
|
|
715 |
pat = tree.is_ignored(path) |
|
716 |
print '%-50s %s' % (path, pat) |
|
717 |
||
718 |
||
719 |
class cmd_lookup_revision(Command): |
|
720 |
"""Lookup the revision-id from a revision-number
|
|
721 |
||
722 |
example:
|
|
723 |
bzr lookup-revision 33
|
|
421
by Martin Pool
doc |
724 |
"""
|
329
by Martin Pool
- refactor command functions into command classes |
725 |
hidden = True |
338
by Martin Pool
- cleanup of some imports |
726 |
takes_args = ['revno'] |
727 |
||
329
by Martin Pool
- refactor command functions into command classes |
728 |
def run(self, revno): |
729 |
try: |
|
730 |
revno = int(revno) |
|
731 |
except ValueError: |
|
338
by Martin Pool
- cleanup of some imports |
732 |
raise BzrCommandError("not a valid revision-number: %r" % revno) |
733 |
||
734 |
print Branch('.').lookup_revision(revno) |
|
329
by Martin Pool
- refactor command functions into command classes |
735 |
|
736 |
||
737 |
class cmd_export(Command): |
|
738 |
"""Export past revision to destination directory.
|
|
739 |
||
740 |
If no revision is specified this exports the last committed revision."""
|
|
741 |
takes_args = ['dest'] |
|
742 |
takes_options = ['revision'] |
|
394
by Martin Pool
- Fix argument handling in export command |
743 |
def run(self, dest, revision=None): |
329
by Martin Pool
- refactor command functions into command classes |
744 |
b = Branch('.') |
394
by Martin Pool
- Fix argument handling in export command |
745 |
if revision == None: |
746 |
rh = b.revision_history()[-1] |
|
329
by Martin Pool
- refactor command functions into command classes |
747 |
else: |
394
by Martin Pool
- Fix argument handling in export command |
748 |
rh = b.lookup_revision(int(revision)) |
329
by Martin Pool
- refactor command functions into command classes |
749 |
t = b.revision_tree(rh) |
750 |
t.export(dest) |
|
751 |
||
752 |
||
753 |
class cmd_cat(Command): |
|
754 |
"""Write a file's text from a previous revision."""
|
|
755 |
||
756 |
takes_options = ['revision'] |
|
757 |
takes_args = ['filename'] |
|
758 |
||
759 |
def run(self, filename, revision=None): |
|
760 |
if revision == None: |
|
761 |
raise BzrCommandError("bzr cat requires a revision number") |
|
762 |
b = Branch('.') |
|
763 |
b.print_file(b.relpath(filename), int(revision)) |
|
764 |
||
765 |
||
766 |
class cmd_local_time_offset(Command): |
|
767 |
"""Show the offset in seconds from GMT to local time."""
|
|
768 |
hidden = True |
|
769 |
def run(self): |
|
770 |
print bzrlib.osutils.local_time_offset() |
|
771 |
||
772 |
||
773 |
||
774 |
class cmd_commit(Command): |
|
775 |
"""Commit changes into a new revision.
|
|
232
by mbp at sourcefrog
Allow docstrings for help to be in PEP0257 format. |
776 |
|
777 |
TODO: Commit only selected files.
|
|
778 |
||
779 |
TODO: Run hooks on tree to-be-committed, and after commit.
|
|
780 |
||
781 |
TODO: Strict commit that fails if there are unknown or deleted files.
|
|
782 |
"""
|
|
389
by Martin Pool
- new commit --file option! |
783 |
takes_options = ['message', 'file', 'verbose'] |
350
by Martin Pool
- refactor command aliases into command classes |
784 |
aliases = ['ci', 'checkin'] |
785 |
||
389
by Martin Pool
- new commit --file option! |
786 |
def run(self, message=None, file=None, verbose=False): |
485
by Martin Pool
- move commit code into its own module |
787 |
from bzrlib.commit import commit |
788 |
||
389
by Martin Pool
- new commit --file option! |
789 |
## Warning: shadows builtin file()
|
790 |
if not message and not file: |
|
791 |
raise BzrCommandError("please specify a commit message", |
|
792 |
["use either --message or --file"]) |
|
793 |
elif message and file: |
|
794 |
raise BzrCommandError("please specify either --message or --file") |
|
795 |
||
796 |
if file: |
|
797 |
import codecs |
|
798 |
message = codecs.open(file, 'rt', bzrlib.user_encoding).read() |
|
799 |
||
485
by Martin Pool
- move commit code into its own module |
800 |
b = Branch('.') |
801 |
commit(b, message, verbose=verbose) |
|
329
by Martin Pool
- refactor command functions into command classes |
802 |
|
803 |
||
804 |
class cmd_check(Command): |
|
805 |
"""Validate consistency of branch history.
|
|
232
by mbp at sourcefrog
Allow docstrings for help to be in PEP0257 format. |
806 |
|
807 |
This command checks various invariants about the branch storage to
|
|
808 |
detect data corruption or bzr bugs.
|
|
809 |
"""
|
|
329
by Martin Pool
- refactor command functions into command classes |
810 |
takes_args = ['dir?'] |
811 |
def run(self, dir='.'): |
|
812 |
import bzrlib.check |
|
813 |
bzrlib.check.check(Branch(dir, find_root=False)) |
|
814 |
||
815 |
||
816 |
||
817 |
class cmd_whoami(Command): |
|
818 |
"""Show bzr user id."""
|
|
819 |
takes_options = ['email'] |
|
286
by Martin Pool
- New bzr whoami --email option |
820 |
|
329
by Martin Pool
- refactor command functions into command classes |
821 |
def run(self, email=False): |
822 |
if email: |
|
823 |
print bzrlib.osutils.user_email() |
|
824 |
else: |
|
825 |
print bzrlib.osutils.username() |
|
826 |
||
827 |
||
828 |
class cmd_selftest(Command): |
|
55
by mbp at sourcefrog
bzr selftest shows some counts of tests |
829 |
"""Run internal test suite"""
|
329
by Martin Pool
- refactor command functions into command classes |
830 |
hidden = True |
831 |
def run(self): |
|
832 |
failures, tests = 0, 0 |
|
833 |
||
834 |
import doctest, bzrlib.store, bzrlib.tests |
|
835 |
bzrlib.trace.verbose = False |
|
836 |
||
837 |
for m in bzrlib.store, bzrlib.inventory, bzrlib.branch, bzrlib.osutils, \ |
|
838 |
bzrlib.tree, bzrlib.tests, bzrlib.commands, bzrlib.add: |
|
839 |
mf, mt = doctest.testmod(m) |
|
840 |
failures += mf |
|
841 |
tests += mt |
|
842 |
print '%-40s %3d tests' % (m.__name__, mt), |
|
843 |
if mf: |
|
844 |
print '%3d FAILED!' % mf |
|
845 |
else: |
|
846 |
print
|
|
847 |
||
848 |
print '%-40s %3d tests' % ('total', tests), |
|
849 |
if failures: |
|
850 |
print '%3d FAILED!' % failures |
|
55
by mbp at sourcefrog
bzr selftest shows some counts of tests |
851 |
else: |
852 |
print
|
|
853 |
||
329
by Martin Pool
- refactor command functions into command classes |
854 |
|
855 |
||
856 |
class cmd_version(Command): |
|
857 |
"""Show version of bzr"""
|
|
858 |
def run(self): |
|
859 |
show_version() |
|
860 |
||
861 |
def show_version(): |
|
862 |
print "bzr (bazaar-ng) %s" % bzrlib.__version__ |
|
863 |
print bzrlib.__copyright__ |
|
864 |
print "http://bazaar-ng.org/" |
|
865 |
print
|
|
866 |
print "bzr comes with ABSOLUTELY NO WARRANTY. bzr is free software, and" |
|
867 |
print "you may use, modify and redistribute it under the terms of the GNU" |
|
868 |
print "General Public License version 2 or later." |
|
869 |
||
870 |
||
871 |
class cmd_rocks(Command): |
|
872 |
"""Statement of optimism."""
|
|
873 |
hidden = True |
|
874 |
def run(self): |
|
875 |
print "it sure does!" |
|
876 |
||
877 |
||
878 |
class cmd_assert_fail(Command): |
|
879 |
"""Test reporting of assertion failures"""
|
|
880 |
hidden = True |
|
881 |
def run(self): |
|
882 |
assert False, "always fails" |
|
883 |
||
884 |
||
885 |
class cmd_help(Command): |
|
886 |
"""Show help on a command or other topic.
|
|
887 |
||
888 |
For a list of all available commands, say 'bzr help commands'."""
|
|
889 |
takes_args = ['topic?'] |
|
350
by Martin Pool
- refactor command aliases into command classes |
890 |
aliases = ['?'] |
329
by Martin Pool
- refactor command functions into command classes |
891 |
|
892 |
def run(self, topic=None): |
|
351
by Martin Pool
- Split out help functions into bzrlib.help |
893 |
import help |
894 |
help.help(topic) |
|
895 |
||
1
by mbp at sourcefrog
import from baz patch-364 |
896 |
|
429
by Martin Pool
- New command update-stat-cache for testing |
897 |
class cmd_update_stat_cache(Command): |
898 |
"""Update stat-cache mapping inodes to SHA-1 hashes.
|
|
899 |
||
900 |
For testing only."""
|
|
901 |
hidden = True |
|
902 |
def run(self): |
|
903 |
import statcache |
|
904 |
b = Branch('.') |
|
454
by Martin Pool
- fix update-stat-cache command |
905 |
statcache.update_cache(b.base, b.read_working_inventory()) |
429
by Martin Pool
- New command update-stat-cache for testing |
906 |
|
907 |
||
1
by mbp at sourcefrog
import from baz patch-364 |
908 |
######################################################################
|
909 |
# main routine
|
|
910 |
||
911 |
||
912 |
# list of all available options; the rhs can be either None for an
|
|
913 |
# option that takes no argument, or a constructor function that checks
|
|
914 |
# the type.
|
|
915 |
OPTIONS = { |
|
916 |
'all': None, |
|
917 |
'help': None, |
|
389
by Martin Pool
- new commit --file option! |
918 |
'file': unicode, |
1
by mbp at sourcefrog
import from baz patch-364 |
919 |
'message': unicode, |
137
by mbp at sourcefrog
new --profile option |
920 |
'profile': None, |
1
by mbp at sourcefrog
import from baz patch-364 |
921 |
'revision': int, |
922 |
'show-ids': None, |
|
12
by mbp at sourcefrog
new --timezone option for bzr log |
923 |
'timezone': str, |
1
by mbp at sourcefrog
import from baz patch-364 |
924 |
'verbose': None, |
925 |
'version': None, |
|
286
by Martin Pool
- New bzr whoami --email option |
926 |
'email': None, |
1
by mbp at sourcefrog
import from baz patch-364 |
927 |
}
|
928 |
||
929 |
SHORT_OPTIONS = { |
|
930 |
'm': 'message', |
|
389
by Martin Pool
- new commit --file option! |
931 |
'F': 'file', |
1
by mbp at sourcefrog
import from baz patch-364 |
932 |
'r': 'revision', |
933 |
'v': 'verbose', |
|
934 |
}
|
|
935 |
||
936 |
||
937 |
def parse_args(argv): |
|
938 |
"""Parse command line.
|
|
939 |
|
|
940 |
Arguments and options are parsed at this level before being passed
|
|
941 |
down to specific command handlers. This routine knows, from a
|
|
942 |
lookup table, something about the available options, what optargs
|
|
943 |
they take, and which commands will accept them.
|
|
944 |
||
31
by Martin Pool
fix up parse_args doctest |
945 |
>>> parse_args('--help'.split())
|
1
by mbp at sourcefrog
import from baz patch-364 |
946 |
([], {'help': True})
|
31
by Martin Pool
fix up parse_args doctest |
947 |
>>> parse_args('--version'.split())
|
1
by mbp at sourcefrog
import from baz patch-364 |
948 |
([], {'version': True})
|
31
by Martin Pool
fix up parse_args doctest |
949 |
>>> parse_args('status --all'.split())
|
1
by mbp at sourcefrog
import from baz patch-364 |
950 |
(['status'], {'all': True})
|
31
by Martin Pool
fix up parse_args doctest |
951 |
>>> parse_args('commit --message=biter'.split())
|
17
by mbp at sourcefrog
allow --option=ARG syntax |
952 |
(['commit'], {'message': u'biter'})
|
1
by mbp at sourcefrog
import from baz patch-364 |
953 |
"""
|
954 |
args = [] |
|
955 |
opts = {} |
|
956 |
||
957 |
# TODO: Maybe handle '--' to end options?
|
|
958 |
||
26
by mbp at sourcefrog
fix StopIteration error on python2.3(?) |
959 |
while argv: |
960 |
a = argv.pop(0) |
|
1
by mbp at sourcefrog
import from baz patch-364 |
961 |
if a[0] == '-': |
264
by Martin Pool
parse_args: option names must be ascii |
962 |
# option names must not be unicode
|
963 |
a = str(a) |
|
17
by mbp at sourcefrog
allow --option=ARG syntax |
964 |
optarg = None |
1
by mbp at sourcefrog
import from baz patch-364 |
965 |
if a[1] == '-': |
966 |
mutter(" got option %r" % a) |
|
17
by mbp at sourcefrog
allow --option=ARG syntax |
967 |
if '=' in a: |
968 |
optname, optarg = a[2:].split('=', 1) |
|
969 |
else: |
|
970 |
optname = a[2:] |
|
1
by mbp at sourcefrog
import from baz patch-364 |
971 |
if optname not in OPTIONS: |
972 |
bailout('unknown long option %r' % a) |
|
973 |
else: |
|
974 |
shortopt = a[1:] |
|
975 |
if shortopt not in SHORT_OPTIONS: |
|
976 |
bailout('unknown short option %r' % a) |
|
977 |
optname = SHORT_OPTIONS[shortopt] |
|
978 |
||
979 |
if optname in opts: |
|
980 |
# XXX: Do we ever want to support this, e.g. for -r?
|
|
981 |
bailout('repeated option %r' % a) |
|
17
by mbp at sourcefrog
allow --option=ARG syntax |
982 |
|
1
by mbp at sourcefrog
import from baz patch-364 |
983 |
optargfn = OPTIONS[optname] |
984 |
if optargfn: |
|
17
by mbp at sourcefrog
allow --option=ARG syntax |
985 |
if optarg == None: |
26
by mbp at sourcefrog
fix StopIteration error on python2.3(?) |
986 |
if not argv: |
17
by mbp at sourcefrog
allow --option=ARG syntax |
987 |
bailout('option %r needs an argument' % a) |
988 |
else: |
|
26
by mbp at sourcefrog
fix StopIteration error on python2.3(?) |
989 |
optarg = argv.pop(0) |
17
by mbp at sourcefrog
allow --option=ARG syntax |
990 |
opts[optname] = optargfn(optarg) |
1
by mbp at sourcefrog
import from baz patch-364 |
991 |
else: |
17
by mbp at sourcefrog
allow --option=ARG syntax |
992 |
if optarg != None: |
993 |
bailout('option %r takes no argument' % optname) |
|
1
by mbp at sourcefrog
import from baz patch-364 |
994 |
opts[optname] = True |
995 |
else: |
|
996 |
args.append(a) |
|
997 |
||
998 |
return args, opts |
|
999 |
||
1000 |
||
1001 |
||
1002 |
||
329
by Martin Pool
- refactor command functions into command classes |
1003 |
def _match_argform(cmd, takes_args, args): |
1
by mbp at sourcefrog
import from baz patch-364 |
1004 |
argdict = {} |
26
by mbp at sourcefrog
fix StopIteration error on python2.3(?) |
1005 |
|
329
by Martin Pool
- refactor command functions into command classes |
1006 |
# step through args and takes_args, allowing appropriate 0-many matches
|
1007 |
for ap in takes_args: |
|
1
by mbp at sourcefrog
import from baz patch-364 |
1008 |
argname = ap[:-1] |
1009 |
if ap[-1] == '?': |
|
62
by mbp at sourcefrog
- new find_branch_root function; based on suggestion from aaron |
1010 |
if args: |
1011 |
argdict[argname] = args.pop(0) |
|
196
by mbp at sourcefrog
selected-file diff |
1012 |
elif ap[-1] == '*': # all remaining arguments |
1013 |
if args: |
|
1014 |
argdict[argname + '_list'] = args[:] |
|
1015 |
args = [] |
|
1016 |
else: |
|
1017 |
argdict[argname + '_list'] = None |
|
1
by mbp at sourcefrog
import from baz patch-364 |
1018 |
elif ap[-1] == '+': |
1019 |
if not args: |
|
329
by Martin Pool
- refactor command functions into command classes |
1020 |
raise BzrCommandError("command %r needs one or more %s" |
1
by mbp at sourcefrog
import from baz patch-364 |
1021 |
% (cmd, argname.upper())) |
1022 |
else: |
|
1023 |
argdict[argname + '_list'] = args[:] |
|
1024 |
args = [] |
|
160
by mbp at sourcefrog
- basic support for moving files to different directories - have not done support for renaming them yet, but should be straightforward - some tests, but many cases are not handled yet i think |
1025 |
elif ap[-1] == '$': # all but one |
1026 |
if len(args) < 2: |
|
329
by Martin Pool
- refactor command functions into command classes |
1027 |
raise BzrCommandError("command %r needs one or more %s" |
160
by mbp at sourcefrog
- basic support for moving files to different directories - have not done support for renaming them yet, but should be straightforward - some tests, but many cases are not handled yet i think |
1028 |
% (cmd, argname.upper())) |
1029 |
argdict[argname + '_list'] = args[:-1] |
|
1030 |
args[:-1] = [] |
|
1
by mbp at sourcefrog
import from baz patch-364 |
1031 |
else: |
1032 |
# just a plain arg
|
|
1033 |
argname = ap |
|
1034 |
if not args: |
|
329
by Martin Pool
- refactor command functions into command classes |
1035 |
raise BzrCommandError("command %r requires argument %s" |
1
by mbp at sourcefrog
import from baz patch-364 |
1036 |
% (cmd, argname.upper())) |
1037 |
else: |
|
1038 |
argdict[argname] = args.pop(0) |
|
1039 |
||
1040 |
if args: |
|
329
by Martin Pool
- refactor command functions into command classes |
1041 |
raise BzrCommandError("extra argument to command %s: %s" |
1042 |
% (cmd, args[0])) |
|
1
by mbp at sourcefrog
import from baz patch-364 |
1043 |
|
1044 |
return argdict |
|
1045 |
||
1046 |
||
1047 |
||
1048 |
def run_bzr(argv): |
|
1049 |
"""Execute a command.
|
|
1050 |
||
1051 |
This is similar to main(), but without all the trappings for
|
|
245
by mbp at sourcefrog
- control files always in utf-8-unix format |
1052 |
logging and error handling.
|
1
by mbp at sourcefrog
import from baz patch-364 |
1053 |
"""
|
251
by mbp at sourcefrog
- factor out locale.getpreferredencoding() |
1054 |
argv = [a.decode(bzrlib.user_encoding) for a in argv] |
245
by mbp at sourcefrog
- control files always in utf-8-unix format |
1055 |
|
1
by mbp at sourcefrog
import from baz patch-364 |
1056 |
try: |
26
by mbp at sourcefrog
fix StopIteration error on python2.3(?) |
1057 |
args, opts = parse_args(argv[1:]) |
1
by mbp at sourcefrog
import from baz patch-364 |
1058 |
if 'help' in opts: |
351
by Martin Pool
- Split out help functions into bzrlib.help |
1059 |
import help |
159
by mbp at sourcefrog
bzr commit --help now works |
1060 |
if args: |
351
by Martin Pool
- Split out help functions into bzrlib.help |
1061 |
help.help(args[0]) |
159
by mbp at sourcefrog
bzr commit --help now works |
1062 |
else: |
351
by Martin Pool
- Split out help functions into bzrlib.help |
1063 |
help.help() |
1
by mbp at sourcefrog
import from baz patch-364 |
1064 |
return 0 |
1065 |
elif 'version' in opts: |
|
336
by Martin Pool
- fix up 'bzr --version' |
1066 |
show_version() |
1
by mbp at sourcefrog
import from baz patch-364 |
1067 |
return 0 |
265
by Martin Pool
parse_args: command names must also be ascii |
1068 |
cmd = str(args.pop(0)) |
1
by mbp at sourcefrog
import from baz patch-364 |
1069 |
except IndexError: |
448
by Martin Pool
- bzr with no command now shows help, not just an error |
1070 |
import help |
1071 |
help.help() |
|
1
by mbp at sourcefrog
import from baz patch-364 |
1072 |
return 1 |
448
by Martin Pool
- bzr with no command now shows help, not just an error |
1073 |
|
115
by mbp at sourcefrog
todo |
1074 |
|
351
by Martin Pool
- Split out help functions into bzrlib.help |
1075 |
canonical_cmd, cmd_class = get_cmd_class(cmd) |
1
by mbp at sourcefrog
import from baz patch-364 |
1076 |
|
137
by mbp at sourcefrog
new --profile option |
1077 |
# global option
|
1078 |
if 'profile' in opts: |
|
1079 |
profile = True |
|
1080 |
del opts['profile'] |
|
1081 |
else: |
|
1082 |
profile = False |
|
1
by mbp at sourcefrog
import from baz patch-364 |
1083 |
|
1084 |
# check options are reasonable
|
|
329
by Martin Pool
- refactor command functions into command classes |
1085 |
allowed = cmd_class.takes_options |
1
by mbp at sourcefrog
import from baz patch-364 |
1086 |
for oname in opts: |
1087 |
if oname not in allowed: |
|
381
by Martin Pool
- Better message when a wrong argument is given |
1088 |
raise BzrCommandError("option '--%s' is not allowed for command %r" |
329
by Martin Pool
- refactor command functions into command classes |
1089 |
% (oname, cmd)) |
176
by mbp at sourcefrog
New cat command contributed by janmar. |
1090 |
|
137
by mbp at sourcefrog
new --profile option |
1091 |
# mix arguments and options into one dictionary
|
329
by Martin Pool
- refactor command functions into command classes |
1092 |
cmdargs = _match_argform(cmd, cmd_class.takes_args, args) |
1093 |
cmdopts = {} |
|
136
by mbp at sourcefrog
new --show-ids option for 'deleted' command |
1094 |
for k, v in opts.items(): |
329
by Martin Pool
- refactor command functions into command classes |
1095 |
cmdopts[k.replace('-', '_')] = v |
1
by mbp at sourcefrog
import from baz patch-364 |
1096 |
|
137
by mbp at sourcefrog
new --profile option |
1097 |
if profile: |
338
by Martin Pool
- cleanup of some imports |
1098 |
import hotshot, tempfile |
239
by mbp at sourcefrog
- remove profiler temporary file when done |
1099 |
pffileno, pfname = tempfile.mkstemp() |
1100 |
try: |
|
1101 |
prof = hotshot.Profile(pfname) |
|
329
by Martin Pool
- refactor command functions into command classes |
1102 |
ret = prof.runcall(cmd_class, cmdopts, cmdargs) or 0 |
239
by mbp at sourcefrog
- remove profiler temporary file when done |
1103 |
prof.close() |
1104 |
||
1105 |
import hotshot.stats |
|
1106 |
stats = hotshot.stats.load(pfname) |
|
1107 |
#stats.strip_dirs()
|
|
1108 |
stats.sort_stats('time') |
|
1109 |
## XXX: Might like to write to stderr or the trace file instead but
|
|
1110 |
## print_stats seems hardcoded to stdout
|
|
1111 |
stats.print_stats(20) |
|
1112 |
||
337
by Martin Pool
- Clarify return codes from command objects |
1113 |
return ret.status |
239
by mbp at sourcefrog
- remove profiler temporary file when done |
1114 |
|
1115 |
finally: |
|
1116 |
os.close(pffileno) |
|
1117 |
os.remove(pfname) |
|
137
by mbp at sourcefrog
new --profile option |
1118 |
else: |
337
by Martin Pool
- Clarify return codes from command objects |
1119 |
cmdobj = cmd_class(cmdopts, cmdargs).status |
1
by mbp at sourcefrog
import from baz patch-364 |
1120 |
|
1121 |
||
359
by Martin Pool
- pychecker fixups |
1122 |
def _report_exception(summary, quiet=False): |
267
by Martin Pool
- better reporting of errors |
1123 |
import traceback |
1124 |
log_error('bzr: ' + summary) |
|
359
by Martin Pool
- pychecker fixups |
1125 |
bzrlib.trace.log_exception() |
317
by Martin Pool
- better error message for broken pipe |
1126 |
|
1127 |
if not quiet: |
|
1128 |
tb = sys.exc_info()[2] |
|
1129 |
exinfo = traceback.extract_tb(tb) |
|
1130 |
if exinfo: |
|
1131 |
sys.stderr.write(' at %s:%d in %s()\n' % exinfo[-1][:3]) |
|
1132 |
sys.stderr.write(' see ~/.bzr.log for debug information\n') |
|
267
by Martin Pool
- better reporting of errors |
1133 |
|
1134 |
||
1135 |
||
1
by mbp at sourcefrog
import from baz patch-364 |
1136 |
def main(argv): |
317
by Martin Pool
- better error message for broken pipe |
1137 |
import errno |
1138 |
||
344
by Martin Pool
- It's not an error to use the library without |
1139 |
bzrlib.open_tracefile(argv) |
260
by Martin Pool
- remove atexit() dependency for writing out execution times |
1140 |
|
1
by mbp at sourcefrog
import from baz patch-364 |
1141 |
try: |
260
by Martin Pool
- remove atexit() dependency for writing out execution times |
1142 |
try: |
337
by Martin Pool
- Clarify return codes from command objects |
1143 |
try: |
1144 |
return run_bzr(argv) |
|
1145 |
finally: |
|
1146 |
# do this here inside the exception wrappers to catch EPIPE
|
|
1147 |
sys.stdout.flush() |
|
260
by Martin Pool
- remove atexit() dependency for writing out execution times |
1148 |
except BzrError, e: |
329
by Martin Pool
- refactor command functions into command classes |
1149 |
quiet = isinstance(e, (BzrCommandError)) |
359
by Martin Pool
- pychecker fixups |
1150 |
_report_exception('error: ' + e.args[0], quiet=quiet) |
260
by Martin Pool
- remove atexit() dependency for writing out execution times |
1151 |
if len(e.args) > 1: |
1152 |
for h in e.args[1]: |
|
267
by Martin Pool
- better reporting of errors |
1153 |
# some explanation or hints
|
260
by Martin Pool
- remove atexit() dependency for writing out execution times |
1154 |
log_error(' ' + h) |
1155 |
return 1 |
|
267
by Martin Pool
- better reporting of errors |
1156 |
except AssertionError, e: |
1157 |
msg = 'assertion failed' |
|
1158 |
if str(e): |
|
1159 |
msg += ': ' + str(e) |
|
359
by Martin Pool
- pychecker fixups |
1160 |
_report_exception(msg) |
318
by Martin Pool
- better error message for Ctrl-c |
1161 |
return 2 |
1162 |
except KeyboardInterrupt, e: |
|
359
by Martin Pool
- pychecker fixups |
1163 |
_report_exception('interrupted', quiet=True) |
318
by Martin Pool
- better error message for Ctrl-c |
1164 |
return 2 |
260
by Martin Pool
- remove atexit() dependency for writing out execution times |
1165 |
except Exception, e: |
317
by Martin Pool
- better error message for broken pipe |
1166 |
quiet = False |
419
by Martin Pool
- RemoteBranch.__str__ and repr |
1167 |
if (isinstance(e, IOError) |
1168 |
and hasattr(e, 'errno') |
|
1169 |
and e.errno == errno.EPIPE): |
|
317
by Martin Pool
- better error message for broken pipe |
1170 |
quiet = True |
1171 |
msg = 'broken pipe' |
|
1172 |
else: |
|
1173 |
msg = str(e).rstrip('\n') |
|
359
by Martin Pool
- pychecker fixups |
1174 |
_report_exception(msg, quiet) |
318
by Martin Pool
- better error message for Ctrl-c |
1175 |
return 2 |
260
by Martin Pool
- remove atexit() dependency for writing out execution times |
1176 |
finally: |
1177 |
bzrlib.trace.close_trace() |
|
1
by mbp at sourcefrog
import from baz patch-364 |
1178 |
|
1179 |
||
1180 |
if __name__ == '__main__': |
|
1181 |
sys.exit(main(sys.argv)) |