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 |
26 |
from bzrlib.tree import RevisionTree, EmptyTree, WorkingTree, Tree |
|
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 |
||
192 |
For each file there is a single line giving its file state and name.
|
|
193 |
The name is that in the current revision unless it is deleted or
|
|
194 |
missing, in which case the old name is shown.
|
|
195 |
"""
|
|
404
by Martin Pool
- bzr status now optionally takes filenames to check |
196 |
takes_args = ['file*'] |
329
by Martin Pool
- refactor command functions into command classes |
197 |
takes_options = ['all'] |
350
by Martin Pool
- refactor command aliases into command classes |
198 |
aliases = ['st', 'stat'] |
329
by Martin Pool
- refactor command functions into command classes |
199 |
|
404
by Martin Pool
- bzr status now optionally takes filenames to check |
200 |
def run(self, all=False, file_list=None): |
406
by Martin Pool
- bzr status only needs a read-lock |
201 |
b = Branch('.', lock_mode='r') |
202 |
b.show_status(show_all=all, file_list=file_list) |
|
329
by Martin Pool
- refactor command functions into command classes |
203 |
|
204 |
||
205 |
class cmd_cat_revision(Command): |
|
206 |
"""Write out metadata for a revision."""
|
|
207 |
||
208 |
hidden = True |
|
209 |
takes_args = ['revision_id'] |
|
210 |
||
211 |
def run(self, revision_id): |
|
212 |
Branch('.').get_revision(revision_id).write_xml(sys.stdout) |
|
213 |
||
214 |
||
215 |
class cmd_revno(Command): |
|
216 |
"""Show current revision number.
|
|
217 |
||
218 |
This is equal to the number of revisions on this branch."""
|
|
219 |
def run(self): |
|
220 |
print Branch('.').revno() |
|
221 |
||
222 |
||
223 |
class cmd_add(Command): |
|
70
by mbp at sourcefrog
Prepare for smart recursive add. |
224 |
"""Add specified files or directories.
|
225 |
||
226 |
In non-recursive mode, all the named items are added, regardless
|
|
227 |
of whether they were previously ignored. A warning is given if
|
|
228 |
any of the named files are already versioned.
|
|
229 |
||
230 |
In recursive mode (the default), files are treated the same way
|
|
231 |
but the behaviour for directories is different. Directories that
|
|
232 |
are already versioned do not give a warning. All directories,
|
|
233 |
whether already versioned or not, are searched for files or
|
|
234 |
subdirectories that are neither versioned or ignored, and these
|
|
235 |
are added. This search proceeds recursively into versioned
|
|
236 |
directories.
|
|
237 |
||
238 |
Therefore simply saying 'bzr add .' will version all files that
|
|
239 |
are currently unknown.
|
|
279
by Martin Pool
todo |
240 |
|
241 |
TODO: Perhaps adding a file whose directly is not versioned should
|
|
242 |
recursively add that parent, rather than giving an error?
|
|
70
by mbp at sourcefrog
Prepare for smart recursive add. |
243 |
"""
|
329
by Martin Pool
- refactor command functions into command classes |
244 |
takes_args = ['file+'] |
245 |
takes_options = ['verbose'] |
|
246 |
||
247 |
def run(self, file_list, verbose=False): |
|
248 |
bzrlib.add.smart_add(file_list, verbose) |
|
249 |
||
250 |
||
386
by Martin Pool
- Typo (reported by uws) |
251 |
class cmd_relpath(Command): |
329
by Martin Pool
- refactor command functions into command classes |
252 |
"""Show path of a file relative to root"""
|
392
by Martin Pool
- fix relpath and add tests |
253 |
takes_args = ['filename'] |
329
by Martin Pool
- refactor command functions into command classes |
254 |
|
392
by Martin Pool
- fix relpath and add tests |
255 |
def run(self, filename): |
256 |
print Branch(filename).relpath(filename) |
|
329
by Martin Pool
- refactor command functions into command classes |
257 |
|
258 |
||
259 |
||
260 |
class cmd_inventory(Command): |
|
261 |
"""Show inventory of the current working copy or a revision."""
|
|
262 |
takes_options = ['revision'] |
|
263 |
||
264 |
def run(self, revision=None): |
|
265 |
b = Branch('.') |
|
266 |
if revision == None: |
|
267 |
inv = b.read_working_inventory() |
|
268 |
else: |
|
269 |
inv = b.get_revision_inventory(b.lookup_revision(revision)) |
|
270 |
||
271 |
for path, entry in inv.iter_entries(): |
|
272 |
print '%-50s %s' % (entry.file_id, path) |
|
273 |
||
274 |
||
275 |
class cmd_move(Command): |
|
276 |
"""Move files to a different directory.
|
|
277 |
||
278 |
examples:
|
|
279 |
bzr move *.txt doc
|
|
280 |
||
281 |
The destination must be a versioned directory in the same branch.
|
|
282 |
"""
|
|
283 |
takes_args = ['source$', 'dest'] |
|
284 |
def run(self, source_list, dest): |
|
285 |
b = Branch('.') |
|
286 |
||
287 |
b.move([b.relpath(s) for s in source_list], b.relpath(dest)) |
|
288 |
||
289 |
||
290 |
class cmd_rename(Command): |
|
168
by mbp at sourcefrog
new "rename" command |
291 |
"""Change the name of an entry.
|
292 |
||
232
by mbp at sourcefrog
Allow docstrings for help to be in PEP0257 format. |
293 |
examples:
|
294 |
bzr rename frob.c frobber.c
|
|
295 |
bzr rename src/frob.c lib/frob.c
|
|
296 |
||
297 |
It is an error if the destination name exists.
|
|
298 |
||
299 |
See also the 'move' command, which moves files into a different
|
|
300 |
directory without changing their name.
|
|
301 |
||
302 |
TODO: Some way to rename multiple files without invoking bzr for each
|
|
303 |
one?"""
|
|
329
by Martin Pool
- refactor command functions into command classes |
304 |
takes_args = ['from_name', 'to_name'] |
168
by mbp at sourcefrog
new "rename" command |
305 |
|
329
by Martin Pool
- refactor command functions into command classes |
306 |
def run(self, from_name, to_name): |
307 |
b = Branch('.') |
|
308 |
b.rename_one(b.relpath(from_name), b.relpath(to_name)) |
|
309 |
||
310 |
||
311 |
||
312 |
class cmd_renames(Command): |
|
164
by mbp at sourcefrog
new 'renames' command |
313 |
"""Show list of renamed files.
|
314 |
||
232
by mbp at sourcefrog
Allow docstrings for help to be in PEP0257 format. |
315 |
TODO: Option to show renames between two historical versions.
|
316 |
||
317 |
TODO: Only show renames under dir, rather than in the whole branch.
|
|
318 |
"""
|
|
329
by Martin Pool
- refactor command functions into command classes |
319 |
takes_args = ['dir?'] |
320 |
||
321 |
def run(self, dir='.'): |
|
322 |
b = Branch(dir) |
|
323 |
old_inv = b.basis_tree().inventory |
|
324 |
new_inv = b.read_working_inventory() |
|
325 |
||
326 |
renames = list(bzrlib.tree.find_renames(old_inv, new_inv)) |
|
327 |
renames.sort() |
|
328 |
for old_name, new_name in renames: |
|
329 |
print "%s => %s" % (old_name, new_name) |
|
330 |
||
331 |
||
332 |
class cmd_info(Command): |
|
333 |
"""Show statistical information for this branch"""
|
|
334 |
def run(self): |
|
335 |
import info |
|
336 |
info.show_info(Branch('.')) |
|
337 |
||
338 |
||
339 |
class cmd_remove(Command): |
|
340 |
"""Make a file unversioned.
|
|
341 |
||
342 |
This makes bzr stop tracking changes to a versioned file. It does
|
|
343 |
not delete the working copy.
|
|
344 |
"""
|
|
345 |
takes_args = ['file+'] |
|
346 |
takes_options = ['verbose'] |
|
347 |
||
348 |
def run(self, file_list, verbose=False): |
|
349 |
b = Branch(file_list[0]) |
|
350 |
b.remove([b.relpath(f) for f in file_list], verbose=verbose) |
|
351 |
||
352 |
||
353 |
class cmd_file_id(Command): |
|
178
by mbp at sourcefrog
- Use a non-null file_id for the branch root directory. At the moment |
354 |
"""Print file_id of a particular file or directory.
|
355 |
||
232
by mbp at sourcefrog
Allow docstrings for help to be in PEP0257 format. |
356 |
The file_id is assigned when the file is first added and remains the
|
357 |
same through all revisions where the file exists, even when it is
|
|
358 |
moved or renamed.
|
|
359 |
"""
|
|
329
by Martin Pool
- refactor command functions into command classes |
360 |
hidden = True |
361 |
takes_args = ['filename'] |
|
362 |
def run(self, filename): |
|
363 |
b = Branch(filename) |
|
364 |
i = b.inventory.path2id(b.relpath(filename)) |
|
365 |
if i == None: |
|
366 |
bailout("%r is not a versioned file" % filename) |
|
367 |
else: |
|
368 |
print i |
|
369 |
||
370 |
||
371 |
class cmd_file_path(Command): |
|
178
by mbp at sourcefrog
- Use a non-null file_id for the branch root directory. At the moment |
372 |
"""Print path of file_ids to a file or directory.
|
373 |
||
232
by mbp at sourcefrog
Allow docstrings for help to be in PEP0257 format. |
374 |
This prints one line for each directory down to the target,
|
375 |
starting at the branch root."""
|
|
329
by Martin Pool
- refactor command functions into command classes |
376 |
hidden = True |
377 |
takes_args = ['filename'] |
|
378 |
def run(self, filename): |
|
379 |
b = Branch(filename) |
|
380 |
inv = b.inventory |
|
381 |
fid = inv.path2id(b.relpath(filename)) |
|
382 |
if fid == None: |
|
383 |
bailout("%r is not a versioned file" % filename) |
|
384 |
for fip in inv.get_idpath(fid): |
|
385 |
print fip |
|
386 |
||
387 |
||
388 |
class cmd_revision_history(Command): |
|
389 |
"""Display list of revision ids on this branch."""
|
|
390 |
def run(self): |
|
391 |
for patchid in Branch('.').revision_history(): |
|
392 |
print patchid |
|
393 |
||
394 |
||
395 |
class cmd_directories(Command): |
|
396 |
"""Display list of versioned directories in this branch."""
|
|
397 |
def run(self): |
|
398 |
for name, ie in Branch('.').read_working_inventory().directories(): |
|
399 |
if name == '': |
|
400 |
print '.' |
|
401 |
else: |
|
402 |
print name |
|
403 |
||
404 |
||
405 |
class cmd_init(Command): |
|
406 |
"""Make a directory into a versioned branch.
|
|
407 |
||
408 |
Use this to create an empty branch, or before importing an
|
|
409 |
existing project.
|
|
410 |
||
411 |
Recipe for importing a tree of files:
|
|
412 |
cd ~/project
|
|
413 |
bzr init
|
|
414 |
bzr add -v .
|
|
415 |
bzr status
|
|
416 |
bzr commit -m 'imported project'
|
|
417 |
"""
|
|
418 |
def run(self): |
|
419 |
Branch('.', init=True) |
|
420 |
||
421 |
||
422 |
class cmd_diff(Command): |
|
423 |
"""Show differences in working tree.
|
|
424 |
|
|
232
by mbp at sourcefrog
Allow docstrings for help to be in PEP0257 format. |
425 |
If files are listed, only the changes in those files are listed.
|
426 |
Otherwise, all changes for the tree are listed.
|
|
427 |
||
428 |
TODO: Given two revision arguments, show the difference between them.
|
|
429 |
||
430 |
TODO: Allow diff across branches.
|
|
431 |
||
432 |
TODO: Option to use external diff command; could be GNU diff, wdiff,
|
|
433 |
or a graphical diff.
|
|
434 |
||
276
by Martin Pool
Doc |
435 |
TODO: Python difflib is not exactly the same as unidiff; should
|
436 |
either fix it up or prefer to use an external diff.
|
|
437 |
||
232
by mbp at sourcefrog
Allow docstrings for help to be in PEP0257 format. |
438 |
TODO: If a directory is given, diff everything under that.
|
439 |
||
276
by Martin Pool
Doc |
440 |
TODO: Selected-file diff is inefficient and doesn't show you
|
441 |
deleted files.
|
|
278
by Martin Pool
- Better workaround for trailing newlines in diffs |
442 |
|
443 |
TODO: This probably handles non-Unix newlines poorly.
|
|
329
by Martin Pool
- refactor command functions into command classes |
444 |
"""
|
445 |
||
446 |
takes_args = ['file*'] |
|
447 |
takes_options = ['revision'] |
|
350
by Martin Pool
- refactor command aliases into command classes |
448 |
aliases = ['di'] |
329
by Martin Pool
- refactor command functions into command classes |
449 |
|
450 |
def run(self, revision=None, file_list=None): |
|
451 |
from bzrlib.diff import show_diff |
|
452 |
||
453 |
show_diff(Branch('.'), revision, file_list) |
|
454 |
||
455 |
||
456 |
class cmd_deleted(Command): |
|
135
by mbp at sourcefrog
Simple new 'deleted' command |
457 |
"""List files deleted in the working tree.
|
458 |
||
232
by mbp at sourcefrog
Allow docstrings for help to be in PEP0257 format. |
459 |
TODO: Show files deleted since a previous revision, or between two revisions.
|
135
by mbp at sourcefrog
Simple new 'deleted' command |
460 |
"""
|
329
by Martin Pool
- refactor command functions into command classes |
461 |
def run(self, show_ids=False): |
462 |
b = Branch('.') |
|
463 |
old = b.basis_tree() |
|
464 |
new = b.working_tree() |
|
465 |
||
466 |
## TODO: Much more efficient way to do this: read in new
|
|
467 |
## directories with readdir, rather than stating each one. Same
|
|
468 |
## level of effort but possibly much less IO. (Or possibly not,
|
|
469 |
## if the directories are very large...)
|
|
470 |
||
471 |
for path, ie in old.inventory.iter_entries(): |
|
472 |
if not new.has_id(ie.file_id): |
|
473 |
if show_ids: |
|
474 |
print '%-50s %s' % (path, ie.file_id) |
|
475 |
else: |
|
476 |
print path |
|
477 |
||
478 |
class cmd_root(Command): |
|
479 |
"""Show the tree root directory.
|
|
480 |
||
481 |
The root is the nearest enclosing directory with a .bzr control
|
|
482 |
directory."""
|
|
483 |
takes_args = ['filename?'] |
|
484 |
def run(self, filename=None): |
|
485 |
"""Print the branch root."""
|
|
416
by Martin Pool
- bzr log and bzr root now accept an http URL |
486 |
from branch import find_branch |
487 |
b = find_branch(filename) |
|
488 |
print getattr(b, 'base', None) or getattr(b, 'baseurl') |
|
329
by Martin Pool
- refactor command functions into command classes |
489 |
|
490 |
||
491 |
class cmd_log(Command): |
|
1
by mbp at sourcefrog
import from baz patch-364 |
492 |
"""Show log of this branch.
|
493 |
||
367
by Martin Pool
- New --show-ids option for bzr log |
494 |
TODO: Option to limit range.
|
495 |
||
496 |
TODO: Perhaps show most-recent first with an option for last.
|
|
1
by mbp at sourcefrog
import from baz patch-364 |
497 |
"""
|
378
by Martin Pool
- New usage bzr log FILENAME |
498 |
takes_args = ['filename?'] |
367
by Martin Pool
- New --show-ids option for bzr log |
499 |
takes_options = ['timezone', 'verbose', 'show-ids'] |
378
by Martin Pool
- New usage bzr log FILENAME |
500 |
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 |
501 |
from branch import find_branch |
502 |
b = find_branch((filename or '.'), lock_mode='r') |
|
378
by Martin Pool
- New usage bzr log FILENAME |
503 |
if filename: |
504 |
filename = b.relpath(filename) |
|
505 |
bzrlib.show_log(b, filename, |
|
371
by Martin Pool
- Fix up bzr log command |
506 |
show_timezone=timezone, |
507 |
verbose=verbose, |
|
508 |
show_ids=show_ids) |
|
329
by Martin Pool
- refactor command functions into command classes |
509 |
|
510 |
||
375
by Martin Pool
- New command touching-revisions and function to trace |
511 |
|
512 |
class cmd_touching_revisions(Command): |
|
513 |
"""Return revision-ids which affected a particular file."""
|
|
514 |
hidden = True |
|
515 |
takes_args = ["filename"] |
|
516 |
def run(self, filename): |
|
517 |
b = Branch(filename, lock_mode='r') |
|
518 |
inv = b.read_working_inventory() |
|
519 |
file_id = inv.path2id(b.relpath(filename)) |
|
520 |
for revno, revision_id, what in bzrlib.log.find_touching_revisions(b, file_id): |
|
521 |
print "%6d %s" % (revno, what) |
|
522 |
||
523 |
||
329
by Martin Pool
- refactor command functions into command classes |
524 |
class cmd_ls(Command): |
1
by mbp at sourcefrog
import from baz patch-364 |
525 |
"""List files in a tree.
|
526 |
||
254
by Martin Pool
- Doc cleanups from Magnus Therning |
527 |
TODO: Take a revision or remote path and list that tree instead.
|
1
by mbp at sourcefrog
import from baz patch-364 |
528 |
"""
|
329
by Martin Pool
- refactor command functions into command classes |
529 |
hidden = True |
530 |
def run(self, revision=None, verbose=False): |
|
531 |
b = Branch('.') |
|
532 |
if revision == None: |
|
533 |
tree = b.working_tree() |
|
534 |
else: |
|
535 |
tree = b.revision_tree(b.lookup_revision(revision)) |
|
536 |
||
537 |
for fp, fc, kind, fid in tree.list_files(): |
|
538 |
if verbose: |
|
539 |
if kind == 'directory': |
|
540 |
kindch = '/' |
|
541 |
elif kind == 'file': |
|
542 |
kindch = '' |
|
543 |
else: |
|
544 |
kindch = '???' |
|
545 |
||
546 |
print '%-8s %s%s' % (fc, fp, kindch) |
|
1
by mbp at sourcefrog
import from baz patch-364 |
547 |
else: |
329
by Martin Pool
- refactor command functions into command classes |
548 |
print fp |
549 |
||
550 |
||
551 |
||
552 |
class cmd_unknowns(Command): |
|
1
by mbp at sourcefrog
import from baz patch-364 |
553 |
"""List unknown files"""
|
329
by Martin Pool
- refactor command functions into command classes |
554 |
def run(self): |
555 |
for f in Branch('.').unknowns(): |
|
556 |
print quotefn(f) |
|
557 |
||
558 |
||
559 |
||
560 |
class cmd_ignore(Command): |
|
420
by Martin Pool
Doc |
561 |
"""Ignore a command or pattern
|
562 |
||
563 |
To remove patterns from the ignore list, edit the .bzrignore file.
|
|
564 |
||
565 |
If the pattern contains a slash, it is compared to the whole path
|
|
566 |
from the branch root. Otherwise, it is comapred to only the last
|
|
567 |
component of the path.
|
|
568 |
||
569 |
Ignore patterns are case-insensitive on case-insensitive systems.
|
|
570 |
||
571 |
Note: wildcards must be quoted from the shell on Unix.
|
|
572 |
||
573 |
examples:
|
|
574 |
bzr ignore ./Makefile
|
|
575 |
bzr ignore '*.class'
|
|
576 |
"""
|
|
329
by Martin Pool
- refactor command functions into command classes |
577 |
takes_args = ['name_pattern'] |
310
by Martin Pool
- new 'bzr ignored' command! |
578 |
|
329
by Martin Pool
- refactor command functions into command classes |
579 |
def run(self, name_pattern): |
409
by Martin Pool
- New AtomicFile class |
580 |
from bzrlib.atomicfile import AtomicFile |
581 |
import codecs |
|
582 |
||
329
by Martin Pool
- refactor command functions into command classes |
583 |
b = Branch('.') |
410
by Martin Pool
- Fix ignore command and add tests |
584 |
ifn = b.abspath('.bzrignore') |
329
by Martin Pool
- refactor command functions into command classes |
585 |
|
409
by Martin Pool
- New AtomicFile class |
586 |
# FIXME: probably doesn't handle non-ascii patterns
|
587 |
||
410
by Martin Pool
- Fix ignore command and add tests |
588 |
if os.path.exists(ifn): |
589 |
f = b.controlfile(ifn, 'rt') |
|
409
by Martin Pool
- New AtomicFile class |
590 |
igns = f.read() |
591 |
f.close() |
|
592 |
else: |
|
593 |
igns = '' |
|
594 |
||
595 |
if igns and igns[-1] != '\n': |
|
596 |
igns += '\n' |
|
597 |
igns += name_pattern + '\n' |
|
598 |
||
410
by Martin Pool
- Fix ignore command and add tests |
599 |
f = AtomicFile(ifn, 'wt') |
409
by Martin Pool
- New AtomicFile class |
600 |
f.write(igns) |
601 |
f.commit() |
|
329
by Martin Pool
- refactor command functions into command classes |
602 |
|
603 |
inv = b.working_tree().inventory |
|
604 |
if inv.path2id('.bzrignore'): |
|
605 |
mutter('.bzrignore is already versioned') |
|
606 |
else: |
|
607 |
mutter('need to make new .bzrignore file versioned') |
|
608 |
b.add(['.bzrignore']) |
|
609 |
||
610 |
||
611 |
||
612 |
class cmd_ignored(Command): |
|
421
by Martin Pool
doc |
613 |
"""List ignored files and the patterns that matched them.
|
614 |
||
615 |
See also: bzr ignore"""
|
|
329
by Martin Pool
- refactor command functions into command classes |
616 |
def run(self): |
617 |
tree = Branch('.').working_tree() |
|
618 |
for path, file_class, kind, file_id in tree.list_files(): |
|
619 |
if file_class != 'I': |
|
620 |
continue
|
|
621 |
## XXX: Slightly inefficient since this was already calculated
|
|
622 |
pat = tree.is_ignored(path) |
|
623 |
print '%-50s %s' % (path, pat) |
|
624 |
||
625 |
||
626 |
class cmd_lookup_revision(Command): |
|
627 |
"""Lookup the revision-id from a revision-number
|
|
628 |
||
629 |
example:
|
|
630 |
bzr lookup-revision 33
|
|
421
by Martin Pool
doc |
631 |
"""
|
329
by Martin Pool
- refactor command functions into command classes |
632 |
hidden = True |
338
by Martin Pool
- cleanup of some imports |
633 |
takes_args = ['revno'] |
634 |
||
329
by Martin Pool
- refactor command functions into command classes |
635 |
def run(self, revno): |
636 |
try: |
|
637 |
revno = int(revno) |
|
638 |
except ValueError: |
|
338
by Martin Pool
- cleanup of some imports |
639 |
raise BzrCommandError("not a valid revision-number: %r" % revno) |
640 |
||
641 |
print Branch('.').lookup_revision(revno) |
|
329
by Martin Pool
- refactor command functions into command classes |
642 |
|
643 |
||
644 |
class cmd_export(Command): |
|
645 |
"""Export past revision to destination directory.
|
|
646 |
||
647 |
If no revision is specified this exports the last committed revision."""
|
|
648 |
takes_args = ['dest'] |
|
649 |
takes_options = ['revision'] |
|
394
by Martin Pool
- Fix argument handling in export command |
650 |
def run(self, dest, revision=None): |
329
by Martin Pool
- refactor command functions into command classes |
651 |
b = Branch('.') |
394
by Martin Pool
- Fix argument handling in export command |
652 |
if revision == None: |
653 |
rh = b.revision_history()[-1] |
|
329
by Martin Pool
- refactor command functions into command classes |
654 |
else: |
394
by Martin Pool
- Fix argument handling in export command |
655 |
rh = b.lookup_revision(int(revision)) |
329
by Martin Pool
- refactor command functions into command classes |
656 |
t = b.revision_tree(rh) |
657 |
t.export(dest) |
|
658 |
||
659 |
||
660 |
class cmd_cat(Command): |
|
661 |
"""Write a file's text from a previous revision."""
|
|
662 |
||
663 |
takes_options = ['revision'] |
|
664 |
takes_args = ['filename'] |
|
665 |
||
666 |
def run(self, filename, revision=None): |
|
667 |
if revision == None: |
|
668 |
raise BzrCommandError("bzr cat requires a revision number") |
|
669 |
b = Branch('.') |
|
670 |
b.print_file(b.relpath(filename), int(revision)) |
|
671 |
||
672 |
||
673 |
class cmd_local_time_offset(Command): |
|
674 |
"""Show the offset in seconds from GMT to local time."""
|
|
675 |
hidden = True |
|
676 |
def run(self): |
|
677 |
print bzrlib.osutils.local_time_offset() |
|
678 |
||
679 |
||
680 |
||
681 |
class cmd_commit(Command): |
|
682 |
"""Commit changes into a new revision.
|
|
232
by mbp at sourcefrog
Allow docstrings for help to be in PEP0257 format. |
683 |
|
684 |
TODO: Commit only selected files.
|
|
685 |
||
686 |
TODO: Run hooks on tree to-be-committed, and after commit.
|
|
687 |
||
688 |
TODO: Strict commit that fails if there are unknown or deleted files.
|
|
689 |
"""
|
|
389
by Martin Pool
- new commit --file option! |
690 |
takes_options = ['message', 'file', 'verbose'] |
350
by Martin Pool
- refactor command aliases into command classes |
691 |
aliases = ['ci', 'checkin'] |
692 |
||
389
by Martin Pool
- new commit --file option! |
693 |
def run(self, message=None, file=None, verbose=False): |
694 |
## Warning: shadows builtin file()
|
|
695 |
if not message and not file: |
|
696 |
raise BzrCommandError("please specify a commit message", |
|
697 |
["use either --message or --file"]) |
|
698 |
elif message and file: |
|
699 |
raise BzrCommandError("please specify either --message or --file") |
|
700 |
||
701 |
if file: |
|
702 |
import codecs |
|
703 |
message = codecs.open(file, 'rt', bzrlib.user_encoding).read() |
|
704 |
||
329
by Martin Pool
- refactor command functions into command classes |
705 |
Branch('.').commit(message, verbose=verbose) |
706 |
||
707 |
||
708 |
class cmd_check(Command): |
|
709 |
"""Validate consistency of branch history.
|
|
232
by mbp at sourcefrog
Allow docstrings for help to be in PEP0257 format. |
710 |
|
711 |
This command checks various invariants about the branch storage to
|
|
712 |
detect data corruption or bzr bugs.
|
|
713 |
"""
|
|
329
by Martin Pool
- refactor command functions into command classes |
714 |
takes_args = ['dir?'] |
715 |
def run(self, dir='.'): |
|
716 |
import bzrlib.check |
|
717 |
bzrlib.check.check(Branch(dir, find_root=False)) |
|
718 |
||
719 |
||
720 |
||
721 |
class cmd_whoami(Command): |
|
722 |
"""Show bzr user id."""
|
|
723 |
takes_options = ['email'] |
|
286
by Martin Pool
- New bzr whoami --email option |
724 |
|
329
by Martin Pool
- refactor command functions into command classes |
725 |
def run(self, email=False): |
726 |
if email: |
|
727 |
print bzrlib.osutils.user_email() |
|
728 |
else: |
|
729 |
print bzrlib.osutils.username() |
|
730 |
||
731 |
||
732 |
class cmd_selftest(Command): |
|
55
by mbp at sourcefrog
bzr selftest shows some counts of tests |
733 |
"""Run internal test suite"""
|
329
by Martin Pool
- refactor command functions into command classes |
734 |
hidden = True |
735 |
def run(self): |
|
736 |
failures, tests = 0, 0 |
|
737 |
||
738 |
import doctest, bzrlib.store, bzrlib.tests |
|
739 |
bzrlib.trace.verbose = False |
|
740 |
||
741 |
for m in bzrlib.store, bzrlib.inventory, bzrlib.branch, bzrlib.osutils, \ |
|
742 |
bzrlib.tree, bzrlib.tests, bzrlib.commands, bzrlib.add: |
|
743 |
mf, mt = doctest.testmod(m) |
|
744 |
failures += mf |
|
745 |
tests += mt |
|
746 |
print '%-40s %3d tests' % (m.__name__, mt), |
|
747 |
if mf: |
|
748 |
print '%3d FAILED!' % mf |
|
749 |
else: |
|
750 |
print
|
|
751 |
||
752 |
print '%-40s %3d tests' % ('total', tests), |
|
753 |
if failures: |
|
754 |
print '%3d FAILED!' % failures |
|
55
by mbp at sourcefrog
bzr selftest shows some counts of tests |
755 |
else: |
756 |
print
|
|
757 |
||
329
by Martin Pool
- refactor command functions into command classes |
758 |
|
759 |
||
760 |
class cmd_version(Command): |
|
761 |
"""Show version of bzr"""
|
|
762 |
def run(self): |
|
763 |
show_version() |
|
764 |
||
765 |
def show_version(): |
|
766 |
print "bzr (bazaar-ng) %s" % bzrlib.__version__ |
|
767 |
print bzrlib.__copyright__ |
|
768 |
print "http://bazaar-ng.org/" |
|
769 |
print
|
|
770 |
print "bzr comes with ABSOLUTELY NO WARRANTY. bzr is free software, and" |
|
771 |
print "you may use, modify and redistribute it under the terms of the GNU" |
|
772 |
print "General Public License version 2 or later." |
|
773 |
||
774 |
||
775 |
class cmd_rocks(Command): |
|
776 |
"""Statement of optimism."""
|
|
777 |
hidden = True |
|
778 |
def run(self): |
|
779 |
print "it sure does!" |
|
780 |
||
781 |
||
782 |
class cmd_assert_fail(Command): |
|
783 |
"""Test reporting of assertion failures"""
|
|
784 |
hidden = True |
|
785 |
def run(self): |
|
786 |
assert False, "always fails" |
|
787 |
||
788 |
||
789 |
class cmd_help(Command): |
|
790 |
"""Show help on a command or other topic.
|
|
791 |
||
792 |
For a list of all available commands, say 'bzr help commands'."""
|
|
793 |
takes_args = ['topic?'] |
|
350
by Martin Pool
- refactor command aliases into command classes |
794 |
aliases = ['?'] |
329
by Martin Pool
- refactor command functions into command classes |
795 |
|
796 |
def run(self, topic=None): |
|
351
by Martin Pool
- Split out help functions into bzrlib.help |
797 |
import help |
798 |
help.help(topic) |
|
799 |
||
1
by mbp at sourcefrog
import from baz patch-364 |
800 |
|
801 |
######################################################################
|
|
802 |
# main routine
|
|
803 |
||
804 |
||
805 |
# list of all available options; the rhs can be either None for an
|
|
806 |
# option that takes no argument, or a constructor function that checks
|
|
807 |
# the type.
|
|
808 |
OPTIONS = { |
|
809 |
'all': None, |
|
810 |
'help': None, |
|
389
by Martin Pool
- new commit --file option! |
811 |
'file': unicode, |
1
by mbp at sourcefrog
import from baz patch-364 |
812 |
'message': unicode, |
137
by mbp at sourcefrog
new --profile option |
813 |
'profile': None, |
1
by mbp at sourcefrog
import from baz patch-364 |
814 |
'revision': int, |
815 |
'show-ids': None, |
|
12
by mbp at sourcefrog
new --timezone option for bzr log |
816 |
'timezone': str, |
1
by mbp at sourcefrog
import from baz patch-364 |
817 |
'verbose': None, |
818 |
'version': None, |
|
286
by Martin Pool
- New bzr whoami --email option |
819 |
'email': None, |
1
by mbp at sourcefrog
import from baz patch-364 |
820 |
}
|
821 |
||
822 |
SHORT_OPTIONS = { |
|
823 |
'm': 'message', |
|
389
by Martin Pool
- new commit --file option! |
824 |
'F': 'file', |
1
by mbp at sourcefrog
import from baz patch-364 |
825 |
'r': 'revision', |
826 |
'v': 'verbose', |
|
827 |
}
|
|
828 |
||
829 |
||
830 |
def parse_args(argv): |
|
831 |
"""Parse command line.
|
|
832 |
|
|
833 |
Arguments and options are parsed at this level before being passed
|
|
834 |
down to specific command handlers. This routine knows, from a
|
|
835 |
lookup table, something about the available options, what optargs
|
|
836 |
they take, and which commands will accept them.
|
|
837 |
||
31
by Martin Pool
fix up parse_args doctest |
838 |
>>> parse_args('--help'.split())
|
1
by mbp at sourcefrog
import from baz patch-364 |
839 |
([], {'help': True})
|
31
by Martin Pool
fix up parse_args doctest |
840 |
>>> parse_args('--version'.split())
|
1
by mbp at sourcefrog
import from baz patch-364 |
841 |
([], {'version': True})
|
31
by Martin Pool
fix up parse_args doctest |
842 |
>>> parse_args('status --all'.split())
|
1
by mbp at sourcefrog
import from baz patch-364 |
843 |
(['status'], {'all': True})
|
31
by Martin Pool
fix up parse_args doctest |
844 |
>>> parse_args('commit --message=biter'.split())
|
17
by mbp at sourcefrog
allow --option=ARG syntax |
845 |
(['commit'], {'message': u'biter'})
|
1
by mbp at sourcefrog
import from baz patch-364 |
846 |
"""
|
847 |
args = [] |
|
848 |
opts = {} |
|
849 |
||
850 |
# TODO: Maybe handle '--' to end options?
|
|
851 |
||
26
by mbp at sourcefrog
fix StopIteration error on python2.3(?) |
852 |
while argv: |
853 |
a = argv.pop(0) |
|
1
by mbp at sourcefrog
import from baz patch-364 |
854 |
if a[0] == '-': |
264
by Martin Pool
parse_args: option names must be ascii |
855 |
# option names must not be unicode
|
856 |
a = str(a) |
|
17
by mbp at sourcefrog
allow --option=ARG syntax |
857 |
optarg = None |
1
by mbp at sourcefrog
import from baz patch-364 |
858 |
if a[1] == '-': |
859 |
mutter(" got option %r" % a) |
|
17
by mbp at sourcefrog
allow --option=ARG syntax |
860 |
if '=' in a: |
861 |
optname, optarg = a[2:].split('=', 1) |
|
862 |
else: |
|
863 |
optname = a[2:] |
|
1
by mbp at sourcefrog
import from baz patch-364 |
864 |
if optname not in OPTIONS: |
865 |
bailout('unknown long option %r' % a) |
|
866 |
else: |
|
867 |
shortopt = a[1:] |
|
868 |
if shortopt not in SHORT_OPTIONS: |
|
869 |
bailout('unknown short option %r' % a) |
|
870 |
optname = SHORT_OPTIONS[shortopt] |
|
871 |
||
872 |
if optname in opts: |
|
873 |
# XXX: Do we ever want to support this, e.g. for -r?
|
|
874 |
bailout('repeated option %r' % a) |
|
17
by mbp at sourcefrog
allow --option=ARG syntax |
875 |
|
1
by mbp at sourcefrog
import from baz patch-364 |
876 |
optargfn = OPTIONS[optname] |
877 |
if optargfn: |
|
17
by mbp at sourcefrog
allow --option=ARG syntax |
878 |
if optarg == None: |
26
by mbp at sourcefrog
fix StopIteration error on python2.3(?) |
879 |
if not argv: |
17
by mbp at sourcefrog
allow --option=ARG syntax |
880 |
bailout('option %r needs an argument' % a) |
881 |
else: |
|
26
by mbp at sourcefrog
fix StopIteration error on python2.3(?) |
882 |
optarg = argv.pop(0) |
17
by mbp at sourcefrog
allow --option=ARG syntax |
883 |
opts[optname] = optargfn(optarg) |
1
by mbp at sourcefrog
import from baz patch-364 |
884 |
else: |
17
by mbp at sourcefrog
allow --option=ARG syntax |
885 |
if optarg != None: |
886 |
bailout('option %r takes no argument' % optname) |
|
1
by mbp at sourcefrog
import from baz patch-364 |
887 |
opts[optname] = True |
888 |
else: |
|
889 |
args.append(a) |
|
890 |
||
891 |
return args, opts |
|
892 |
||
893 |
||
894 |
||
895 |
||
329
by Martin Pool
- refactor command functions into command classes |
896 |
def _match_argform(cmd, takes_args, args): |
1
by mbp at sourcefrog
import from baz patch-364 |
897 |
argdict = {} |
26
by mbp at sourcefrog
fix StopIteration error on python2.3(?) |
898 |
|
329
by Martin Pool
- refactor command functions into command classes |
899 |
# step through args and takes_args, allowing appropriate 0-many matches
|
900 |
for ap in takes_args: |
|
1
by mbp at sourcefrog
import from baz patch-364 |
901 |
argname = ap[:-1] |
902 |
if ap[-1] == '?': |
|
62
by mbp at sourcefrog
- new find_branch_root function; based on suggestion from aaron |
903 |
if args: |
904 |
argdict[argname] = args.pop(0) |
|
196
by mbp at sourcefrog
selected-file diff |
905 |
elif ap[-1] == '*': # all remaining arguments |
906 |
if args: |
|
907 |
argdict[argname + '_list'] = args[:] |
|
908 |
args = [] |
|
909 |
else: |
|
910 |
argdict[argname + '_list'] = None |
|
1
by mbp at sourcefrog
import from baz patch-364 |
911 |
elif ap[-1] == '+': |
912 |
if not args: |
|
329
by Martin Pool
- refactor command functions into command classes |
913 |
raise BzrCommandError("command %r needs one or more %s" |
1
by mbp at sourcefrog
import from baz patch-364 |
914 |
% (cmd, argname.upper())) |
915 |
else: |
|
916 |
argdict[argname + '_list'] = args[:] |
|
917 |
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 |
918 |
elif ap[-1] == '$': # all but one |
919 |
if len(args) < 2: |
|
329
by Martin Pool
- refactor command functions into command classes |
920 |
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 |
921 |
% (cmd, argname.upper())) |
922 |
argdict[argname + '_list'] = args[:-1] |
|
923 |
args[:-1] = [] |
|
1
by mbp at sourcefrog
import from baz patch-364 |
924 |
else: |
925 |
# just a plain arg
|
|
926 |
argname = ap |
|
927 |
if not args: |
|
329
by Martin Pool
- refactor command functions into command classes |
928 |
raise BzrCommandError("command %r requires argument %s" |
1
by mbp at sourcefrog
import from baz patch-364 |
929 |
% (cmd, argname.upper())) |
930 |
else: |
|
931 |
argdict[argname] = args.pop(0) |
|
932 |
||
933 |
if args: |
|
329
by Martin Pool
- refactor command functions into command classes |
934 |
raise BzrCommandError("extra argument to command %s: %s" |
935 |
% (cmd, args[0])) |
|
1
by mbp at sourcefrog
import from baz patch-364 |
936 |
|
937 |
return argdict |
|
938 |
||
939 |
||
940 |
||
941 |
def run_bzr(argv): |
|
942 |
"""Execute a command.
|
|
943 |
||
944 |
This is similar to main(), but without all the trappings for
|
|
245
by mbp at sourcefrog
- control files always in utf-8-unix format |
945 |
logging and error handling.
|
1
by mbp at sourcefrog
import from baz patch-364 |
946 |
"""
|
251
by mbp at sourcefrog
- factor out locale.getpreferredencoding() |
947 |
argv = [a.decode(bzrlib.user_encoding) for a in argv] |
245
by mbp at sourcefrog
- control files always in utf-8-unix format |
948 |
|
1
by mbp at sourcefrog
import from baz patch-364 |
949 |
try: |
26
by mbp at sourcefrog
fix StopIteration error on python2.3(?) |
950 |
args, opts = parse_args(argv[1:]) |
1
by mbp at sourcefrog
import from baz patch-364 |
951 |
if 'help' in opts: |
351
by Martin Pool
- Split out help functions into bzrlib.help |
952 |
import help |
159
by mbp at sourcefrog
bzr commit --help now works |
953 |
if args: |
351
by Martin Pool
- Split out help functions into bzrlib.help |
954 |
help.help(args[0]) |
159
by mbp at sourcefrog
bzr commit --help now works |
955 |
else: |
351
by Martin Pool
- Split out help functions into bzrlib.help |
956 |
help.help() |
1
by mbp at sourcefrog
import from baz patch-364 |
957 |
return 0 |
958 |
elif 'version' in opts: |
|
336
by Martin Pool
- fix up 'bzr --version' |
959 |
show_version() |
1
by mbp at sourcefrog
import from baz patch-364 |
960 |
return 0 |
265
by Martin Pool
parse_args: command names must also be ascii |
961 |
cmd = str(args.pop(0)) |
1
by mbp at sourcefrog
import from baz patch-364 |
962 |
except IndexError: |
257
by Martin Pool
- Write less startup junk to .bzr.log |
963 |
log_error('usage: bzr COMMAND') |
964 |
log_error(' try "bzr help"') |
|
1
by mbp at sourcefrog
import from baz patch-364 |
965 |
return 1 |
115
by mbp at sourcefrog
todo |
966 |
|
351
by Martin Pool
- Split out help functions into bzrlib.help |
967 |
canonical_cmd, cmd_class = get_cmd_class(cmd) |
1
by mbp at sourcefrog
import from baz patch-364 |
968 |
|
137
by mbp at sourcefrog
new --profile option |
969 |
# global option
|
970 |
if 'profile' in opts: |
|
971 |
profile = True |
|
972 |
del opts['profile'] |
|
973 |
else: |
|
974 |
profile = False |
|
1
by mbp at sourcefrog
import from baz patch-364 |
975 |
|
976 |
# check options are reasonable
|
|
329
by Martin Pool
- refactor command functions into command classes |
977 |
allowed = cmd_class.takes_options |
1
by mbp at sourcefrog
import from baz patch-364 |
978 |
for oname in opts: |
979 |
if oname not in allowed: |
|
381
by Martin Pool
- Better message when a wrong argument is given |
980 |
raise BzrCommandError("option '--%s' is not allowed for command %r" |
329
by Martin Pool
- refactor command functions into command classes |
981 |
% (oname, cmd)) |
176
by mbp at sourcefrog
New cat command contributed by janmar. |
982 |
|
137
by mbp at sourcefrog
new --profile option |
983 |
# mix arguments and options into one dictionary
|
329
by Martin Pool
- refactor command functions into command classes |
984 |
cmdargs = _match_argform(cmd, cmd_class.takes_args, args) |
985 |
cmdopts = {} |
|
136
by mbp at sourcefrog
new --show-ids option for 'deleted' command |
986 |
for k, v in opts.items(): |
329
by Martin Pool
- refactor command functions into command classes |
987 |
cmdopts[k.replace('-', '_')] = v |
1
by mbp at sourcefrog
import from baz patch-364 |
988 |
|
137
by mbp at sourcefrog
new --profile option |
989 |
if profile: |
338
by Martin Pool
- cleanup of some imports |
990 |
import hotshot, tempfile |
239
by mbp at sourcefrog
- remove profiler temporary file when done |
991 |
pffileno, pfname = tempfile.mkstemp() |
992 |
try: |
|
993 |
prof = hotshot.Profile(pfname) |
|
329
by Martin Pool
- refactor command functions into command classes |
994 |
ret = prof.runcall(cmd_class, cmdopts, cmdargs) or 0 |
239
by mbp at sourcefrog
- remove profiler temporary file when done |
995 |
prof.close() |
996 |
||
997 |
import hotshot.stats |
|
998 |
stats = hotshot.stats.load(pfname) |
|
999 |
#stats.strip_dirs()
|
|
1000 |
stats.sort_stats('time') |
|
1001 |
## XXX: Might like to write to stderr or the trace file instead but
|
|
1002 |
## print_stats seems hardcoded to stdout
|
|
1003 |
stats.print_stats(20) |
|
1004 |
||
337
by Martin Pool
- Clarify return codes from command objects |
1005 |
return ret.status |
239
by mbp at sourcefrog
- remove profiler temporary file when done |
1006 |
|
1007 |
finally: |
|
1008 |
os.close(pffileno) |
|
1009 |
os.remove(pfname) |
|
137
by mbp at sourcefrog
new --profile option |
1010 |
else: |
337
by Martin Pool
- Clarify return codes from command objects |
1011 |
cmdobj = cmd_class(cmdopts, cmdargs).status |
1
by mbp at sourcefrog
import from baz patch-364 |
1012 |
|
1013 |
||
359
by Martin Pool
- pychecker fixups |
1014 |
def _report_exception(summary, quiet=False): |
267
by Martin Pool
- better reporting of errors |
1015 |
import traceback |
1016 |
log_error('bzr: ' + summary) |
|
359
by Martin Pool
- pychecker fixups |
1017 |
bzrlib.trace.log_exception() |
317
by Martin Pool
- better error message for broken pipe |
1018 |
|
1019 |
if not quiet: |
|
1020 |
tb = sys.exc_info()[2] |
|
1021 |
exinfo = traceback.extract_tb(tb) |
|
1022 |
if exinfo: |
|
1023 |
sys.stderr.write(' at %s:%d in %s()\n' % exinfo[-1][:3]) |
|
1024 |
sys.stderr.write(' see ~/.bzr.log for debug information\n') |
|
267
by Martin Pool
- better reporting of errors |
1025 |
|
1026 |
||
1027 |
||
1
by mbp at sourcefrog
import from baz patch-364 |
1028 |
def main(argv): |
317
by Martin Pool
- better error message for broken pipe |
1029 |
import errno |
1030 |
||
344
by Martin Pool
- It's not an error to use the library without |
1031 |
bzrlib.open_tracefile(argv) |
260
by Martin Pool
- remove atexit() dependency for writing out execution times |
1032 |
|
1
by mbp at sourcefrog
import from baz patch-364 |
1033 |
try: |
260
by Martin Pool
- remove atexit() dependency for writing out execution times |
1034 |
try: |
337
by Martin Pool
- Clarify return codes from command objects |
1035 |
try: |
1036 |
return run_bzr(argv) |
|
1037 |
finally: |
|
1038 |
# do this here inside the exception wrappers to catch EPIPE
|
|
1039 |
sys.stdout.flush() |
|
260
by Martin Pool
- remove atexit() dependency for writing out execution times |
1040 |
except BzrError, e: |
329
by Martin Pool
- refactor command functions into command classes |
1041 |
quiet = isinstance(e, (BzrCommandError)) |
359
by Martin Pool
- pychecker fixups |
1042 |
_report_exception('error: ' + e.args[0], quiet=quiet) |
260
by Martin Pool
- remove atexit() dependency for writing out execution times |
1043 |
if len(e.args) > 1: |
1044 |
for h in e.args[1]: |
|
267
by Martin Pool
- better reporting of errors |
1045 |
# some explanation or hints
|
260
by Martin Pool
- remove atexit() dependency for writing out execution times |
1046 |
log_error(' ' + h) |
1047 |
return 1 |
|
267
by Martin Pool
- better reporting of errors |
1048 |
except AssertionError, e: |
1049 |
msg = 'assertion failed' |
|
1050 |
if str(e): |
|
1051 |
msg += ': ' + str(e) |
|
359
by Martin Pool
- pychecker fixups |
1052 |
_report_exception(msg) |
318
by Martin Pool
- better error message for Ctrl-c |
1053 |
return 2 |
1054 |
except KeyboardInterrupt, e: |
|
359
by Martin Pool
- pychecker fixups |
1055 |
_report_exception('interrupted', quiet=True) |
318
by Martin Pool
- better error message for Ctrl-c |
1056 |
return 2 |
260
by Martin Pool
- remove atexit() dependency for writing out execution times |
1057 |
except Exception, e: |
317
by Martin Pool
- better error message for broken pipe |
1058 |
quiet = False |
419
by Martin Pool
- RemoteBranch.__str__ and repr |
1059 |
if (isinstance(e, IOError) |
1060 |
and hasattr(e, 'errno') |
|
1061 |
and e.errno == errno.EPIPE): |
|
317
by Martin Pool
- better error message for broken pipe |
1062 |
quiet = True |
1063 |
msg = 'broken pipe' |
|
1064 |
else: |
|
1065 |
msg = str(e).rstrip('\n') |
|
359
by Martin Pool
- pychecker fixups |
1066 |
_report_exception(msg, quiet) |
318
by Martin Pool
- better error message for Ctrl-c |
1067 |
return 2 |
260
by Martin Pool
- remove atexit() dependency for writing out execution times |
1068 |
finally: |
1069 |
bzrlib.trace.close_trace() |
|
1
by mbp at sourcefrog
import from baz patch-364 |
1070 |
|
1071 |
||
1072 |
if __name__ == '__main__': |
|
1073 |
sys.exit(main(sys.argv)) |