~bzr-pqm/bzr/bzr.dev

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
572 by Martin Pool
- trim imports
19
import sys, os
1 by mbp at sourcefrog
import from baz patch-364
20
21
import bzrlib
22
from bzrlib.trace import mutter, note, log_error
694 by Martin Pool
- weed out all remaining calls to bailout() and remove the function
23
from bzrlib.errors import BzrError, BzrCheckError, BzrCommandError
592 by Martin Pool
- trim imports more
24
from bzrlib.osutils import quotefn
25
from bzrlib import Branch, Inventory, InventoryEntry, BZRDIR, \
1 by mbp at sourcefrog
import from baz patch-364
26
     format_date
27
28
731 by Martin Pool
- merge plugin patch from john
29
plugin_cmds = {}
30
31
759 by Martin Pool
- fix up register_command() names
32
def register_command(cmd):
731 by Martin Pool
- merge plugin patch from john
33
    "Utility function to help register a command"
34
    global plugin_cmds
35
    k = cmd.__name__
36
    if k.startswith("cmd_"):
37
        k_unsquished = _unsquish_command_name(k)
38
    else:
39
        k_unsquished = k
40
    if not plugin_cmds.has_key(k_unsquished):
41
        plugin_cmds[k_unsquished] = cmd
42
    else:
43
        log_error('Two plugins defined the same command: %r' % k)
44
        log_error('Not loading the one in %r' % sys.modules[cmd.__module__])
45
46
350 by Martin Pool
- refactor command aliases into command classes
47
def _squish_command_name(cmd):
48
    return 'cmd_' + cmd.replace('-', '_')
49
50
51
def _unsquish_command_name(cmd):
52
    assert cmd.startswith("cmd_")
53
    return cmd[4:].replace('_','-')
54
567 by Martin Pool
- New form 'bzr log -r FROM:TO'
55
def _parse_revision_str(revstr):
56
    """This handles a revision string -> revno. 
57
58
    There are several possibilities:
59
60
        '234'       -> 234
61
        '234:345'   -> [234, 345]
62
        ':234'      -> [None, 234]
63
        '234:'      -> [234, None]
64
65
    In the future we will also support:
66
        'uuid:blah-blah-blah'   -> ?
67
        'hash:blahblahblah'     -> ?
68
        potentially:
69
        'tag:mytag'             -> ?
70
    """
71
    if revstr.find(':') != -1:
72
        revs = revstr.split(':')
73
        if len(revs) > 2:
74
            raise ValueError('More than 2 pieces not supported for --revision: %r' % revstr)
75
76
        if not revs[0]:
77
            revs[0] = None
78
        else:
79
            revs[0] = int(revs[0])
80
81
        if not revs[1]:
82
            revs[1] = None
83
        else:
84
            revs[1] = int(revs[1])
85
    else:
86
        revs = int(revstr)
87
    return revs
88
731 by Martin Pool
- merge plugin patch from john
89
90
91
def _get_cmd_dict(plugins_override=True):
641 by Martin Pool
- improved external-command patch from john
92
    d = {}
350 by Martin Pool
- refactor command aliases into command classes
93
    for k, v in globals().iteritems():
94
        if k.startswith("cmd_"):
641 by Martin Pool
- improved external-command patch from john
95
            d[_unsquish_command_name(k)] = v
731 by Martin Pool
- merge plugin patch from john
96
    # If we didn't load plugins, the plugin_cmds dict will be empty
97
    if plugins_override:
98
        d.update(plugin_cmds)
99
    else:
100
        d2 = plugin_cmds.copy()
101
        d2.update(d)
102
        d = d2
641 by Martin Pool
- improved external-command patch from john
103
    return d
731 by Martin Pool
- merge plugin patch from john
104
641 by Martin Pool
- improved external-command patch from john
105
    
731 by Martin Pool
- merge plugin patch from john
106
def get_all_cmds(plugins_override=True):
641 by Martin Pool
- improved external-command patch from john
107
    """Return canonical name and class for all registered commands."""
731 by Martin Pool
- merge plugin patch from john
108
    for k, v in _get_cmd_dict(plugins_override=plugins_override).iteritems():
641 by Martin Pool
- improved external-command patch from john
109
        yield k,v
110
111
731 by Martin Pool
- merge plugin patch from john
112
def get_cmd_class(cmd, plugins_override=True):
350 by Martin Pool
- refactor command aliases into command classes
113
    """Return the canonical name and command class for a command.
114
    """
115
    cmd = str(cmd)                      # not unicode
116
117
    # first look up this command under the specified name
731 by Martin Pool
- merge plugin patch from john
118
    cmds = _get_cmd_dict(plugins_override=plugins_override)
272 by Martin Pool
- Add command aliases
119
    try:
641 by Martin Pool
- improved external-command patch from john
120
        return cmd, cmds[cmd]
272 by Martin Pool
- Add command aliases
121
    except KeyError:
350 by Martin Pool
- refactor command aliases into command classes
122
        pass
123
124
    # look for any command which claims this as an alias
641 by Martin Pool
- improved external-command patch from john
125
    for cmdname, cmdclass in cmds.iteritems():
350 by Martin Pool
- refactor command aliases into command classes
126
        if cmd in cmdclass.aliases:
127
            return cmdname, cmdclass
422 by Martin Pool
- External-command patch from mpe
128
129
    cmdclass = ExternalCommand.find_command(cmd)
130
    if cmdclass:
131
        return cmd, cmdclass
132
133
    raise BzrCommandError("unknown command %r" % cmd)
272 by Martin Pool
- Add command aliases
134
329 by Martin Pool
- refactor command functions into command classes
135
558 by Martin Pool
- All top-level classes inherit from object
136
class Command(object):
329 by Martin Pool
- refactor command functions into command classes
137
    """Base class for commands.
138
139
    The docstring for an actual command should give a single-line
140
    summary, then a complete description of the command.  A grammar
141
    description will be inserted.
142
143
    takes_args
144
        List of argument forms, marked with whether they are optional,
145
        repeated, etc.
146
147
    takes_options
148
        List of options that may be given for this command.
149
150
    hidden
151
        If true, this command isn't advertised.
152
    """
153
    aliases = []
154
    
155
    takes_args = []
156
    takes_options = []
157
158
    hidden = False
159
    
160
    def __init__(self, options, arguments):
161
        """Construct and run the command.
162
163
        Sets self.status to the return value of run()."""
164
        assert isinstance(options, dict)
165
        assert isinstance(arguments, dict)
166
        cmdargs = options.copy()
167
        cmdargs.update(arguments)
168
        assert self.__doc__ != Command.__doc__, \
169
               ("No help message set for %r" % self)
170
        self.status = self.run(**cmdargs)
171
172
    
173
    def run(self):
174
        """Override this in sub-classes.
175
176
        This is invoked with the options and arguments bound to
177
        keyword parameters.
178
337 by Martin Pool
- Clarify return codes from command objects
179
        Return 0 or None if the command was successful, or a shell
180
        error code if not.
329 by Martin Pool
- refactor command functions into command classes
181
        """
337 by Martin Pool
- Clarify return codes from command objects
182
        return 0
329 by Martin Pool
- refactor command functions into command classes
183
184
422 by Martin Pool
- External-command patch from mpe
185
class ExternalCommand(Command):
186
    """Class to wrap external commands.
187
188
    We cheat a little here, when get_cmd_class() calls us we actually give it back
189
    an object we construct that has the appropriate path, help, options etc for the
190
    specified command.
191
192
    When run_bzr() tries to instantiate that 'class' it gets caught by the __call__
193
    method, which we override to call the Command.__init__ method. That then calls
194
    our run method which is pretty straight forward.
195
196
    The only wrinkle is that we have to map bzr's dictionary of options and arguments
197
    back into command line options and arguments for the script.
198
    """
199
200
    def find_command(cls, cmd):
572 by Martin Pool
- trim imports
201
        import os.path
422 by Martin Pool
- External-command patch from mpe
202
        bzrpath = os.environ.get('BZRPATH', '')
203
641 by Martin Pool
- improved external-command patch from john
204
        for dir in bzrpath.split(os.pathsep):
422 by Martin Pool
- External-command patch from mpe
205
            path = os.path.join(dir, cmd)
206
            if os.path.isfile(path):
207
                return ExternalCommand(path)
208
209
        return None
210
211
    find_command = classmethod(find_command)
212
213
    def __init__(self, path):
214
        self.path = path
215
216
        pipe = os.popen('%s --bzr-usage' % path, 'r')
217
        self.takes_options = pipe.readline().split()
687 by Martin Pool
- trap more errors from external commands
218
219
        for opt in self.takes_options:
220
            if not opt in OPTIONS:
694 by Martin Pool
- weed out all remaining calls to bailout() and remove the function
221
                raise BzrError("Unknown option '%s' returned by external command %s"
222
                               % (opt, path))
687 by Martin Pool
- trap more errors from external commands
223
224
        # TODO: Is there any way to check takes_args is valid here?
422 by Martin Pool
- External-command patch from mpe
225
        self.takes_args = pipe.readline().split()
687 by Martin Pool
- trap more errors from external commands
226
227
        if pipe.close() is not None:
694 by Martin Pool
- weed out all remaining calls to bailout() and remove the function
228
            raise BzrError("Failed funning '%s --bzr-usage'" % path)
422 by Martin Pool
- External-command patch from mpe
229
230
        pipe = os.popen('%s --bzr-help' % path, 'r')
231
        self.__doc__ = pipe.read()
687 by Martin Pool
- trap more errors from external commands
232
        if pipe.close() is not None:
694 by Martin Pool
- weed out all remaining calls to bailout() and remove the function
233
            raise BzrError("Failed funning '%s --bzr-help'" % path)
422 by Martin Pool
- External-command patch from mpe
234
235
    def __call__(self, options, arguments):
236
        Command.__init__(self, options, arguments)
237
        return self
238
239
    def run(self, **kargs):
240
        opts = []
241
        args = []
242
243
        keys = kargs.keys()
244
        keys.sort()
245
        for name in keys:
689 by Martin Pool
- make options with - work with external commands
246
            optname = name.replace('_','-')
422 by Martin Pool
- External-command patch from mpe
247
            value = kargs[name]
689 by Martin Pool
- make options with - work with external commands
248
            if OPTIONS.has_key(optname):
422 by Martin Pool
- External-command patch from mpe
249
                # it's an option
689 by Martin Pool
- make options with - work with external commands
250
                opts.append('--%s' % optname)
422 by Martin Pool
- External-command patch from mpe
251
                if value is not None and value is not True:
252
                    opts.append(str(value))
253
            else:
254
                # it's an arg, or arg list
255
                if type(value) is not list:
256
                    value = [value]
257
                for v in value:
258
                    if v is not None:
259
                        args.append(str(v))
260
261
        self.status = os.spawnv(os.P_WAIT, self.path, [self.path] + opts + args)
262
        return self.status
263
329 by Martin Pool
- refactor command functions into command classes
264
265
class cmd_status(Command):
1 by mbp at sourcefrog
import from baz patch-364
266
    """Display status summary.
267
466 by Martin Pool
- doc for status command
268
    This reports on versioned and unknown files, reporting them
269
    grouped by state.  Possible states are:
270
271
    added
272
        Versioned in the working copy but not in the previous revision.
273
274
    removed
467 by Martin Pool
- doc for status command
275
        Versioned in the previous revision but removed or deleted
466 by Martin Pool
- doc for status command
276
        in the working copy.
277
278
    renamed
279
        Path of this file changed from the previous revision;
280
        the text may also have changed.  This includes files whose
467 by Martin Pool
- doc for status command
281
        parent directory was renamed.
466 by Martin Pool
- doc for status command
282
283
    modified
284
        Text has changed since the previous revision.
285
286
    unchanged
467 by Martin Pool
- doc for status command
287
        Nothing about this file has changed since the previous revision.
288
        Only shown with --all.
466 by Martin Pool
- doc for status command
289
290
    unknown
291
        Not versioned and not matching an ignore pattern.
292
293
    To see ignored files use 'bzr ignored'.  For details in the
294
    changes to file texts, use 'bzr diff'.
468 by Martin Pool
- Interpret arguments to bzr status
295
296
    If no arguments are specified, the status of the entire working
297
    directory is shown.  Otherwise, only the status of the specified
298
    files or directories is reported.  If a directory is given, status
299
    is reported for everything inside that directory.
1 by mbp at sourcefrog
import from baz patch-364
300
    """
404 by Martin Pool
- bzr status now optionally takes filenames to check
301
    takes_args = ['file*']
465 by Martin Pool
- Move show_status() out of Branch into a new function in
302
    takes_options = ['all', 'show-ids']
350 by Martin Pool
- refactor command aliases into command classes
303
    aliases = ['st', 'stat']
329 by Martin Pool
- refactor command functions into command classes
304
    
465 by Martin Pool
- Move show_status() out of Branch into a new function in
305
    def run(self, all=False, show_ids=False, file_list=None):
468 by Martin Pool
- Interpret arguments to bzr status
306
        if file_list:
580 by Martin Pool
- Use explicit lock methods on a branch, rather than doing it
307
            b = Branch(file_list[0])
468 by Martin Pool
- Interpret arguments to bzr status
308
            file_list = [b.relpath(x) for x in file_list]
309
            # special case: only one path was given and it's the root
310
            # of the branch
311
            if file_list == ['']:
312
                file_list = None
313
        else:
580 by Martin Pool
- Use explicit lock methods on a branch, rather than doing it
314
            b = Branch('.')
465 by Martin Pool
- Move show_status() out of Branch into a new function in
315
        import status
316
        status.show_status(b, show_unchanged=all, show_ids=show_ids,
483 by Martin Pool
- change 'file_list' to more explanatory 'specific_files'
317
                           specific_files=file_list)
329 by Martin Pool
- refactor command functions into command classes
318
319
320
class cmd_cat_revision(Command):
321
    """Write out metadata for a revision."""
322
323
    hidden = True
324
    takes_args = ['revision_id']
325
    
326
    def run(self, revision_id):
327
        Branch('.').get_revision(revision_id).write_xml(sys.stdout)
328
329
330
class cmd_revno(Command):
331
    """Show current revision number.
332
333
    This is equal to the number of revisions on this branch."""
334
    def run(self):
335
        print Branch('.').revno()
336
337
    
338
class cmd_add(Command):
70 by mbp at sourcefrog
Prepare for smart recursive add.
339
    """Add specified files or directories.
340
341
    In non-recursive mode, all the named items are added, regardless
342
    of whether they were previously ignored.  A warning is given if
343
    any of the named files are already versioned.
344
345
    In recursive mode (the default), files are treated the same way
346
    but the behaviour for directories is different.  Directories that
347
    are already versioned do not give a warning.  All directories,
348
    whether already versioned or not, are searched for files or
349
    subdirectories that are neither versioned or ignored, and these
350
    are added.  This search proceeds recursively into versioned
351
    directories.
352
353
    Therefore simply saying 'bzr add .' will version all files that
354
    are currently unknown.
279 by Martin Pool
todo
355
356
    TODO: Perhaps adding a file whose directly is not versioned should
357
    recursively add that parent, rather than giving an error?
70 by mbp at sourcefrog
Prepare for smart recursive add.
358
    """
329 by Martin Pool
- refactor command functions into command classes
359
    takes_args = ['file+']
594 by Martin Pool
- add --no-recurse option for add command
360
    takes_options = ['verbose', 'no-recurse']
329 by Martin Pool
- refactor command functions into command classes
361
    
594 by Martin Pool
- add --no-recurse option for add command
362
    def run(self, file_list, verbose=False, no_recurse=False):
363
        bzrlib.add.smart_add(file_list, verbose, not no_recurse)
329 by Martin Pool
- refactor command functions into command classes
364
365
742 by Martin Pool
- new mkdir command
366
367
class cmd_mkdir(Command):
368
    """Create a new versioned directory.
369
370
    This is equivalent to creating the directory and then adding it.
371
    """
372
    takes_args = ['dir+']
373
374
    def run(self, dir_list):
375
        import os
376
        import bzrlib.branch
377
        
378
        b = None
379
        
380
        for d in dir_list:
381
            os.mkdir(d)
382
            if not b:
383
                b = bzrlib.branch.Branch(d)
384
            b.add([d], verbose=True)
385
386
386 by Martin Pool
- Typo (reported by uws)
387
class cmd_relpath(Command):
329 by Martin Pool
- refactor command functions into command classes
388
    """Show path of a file relative to root"""
392 by Martin Pool
- fix relpath and add tests
389
    takes_args = ['filename']
584 by Martin Pool
- make relpath and revision-history hidden commands
390
    hidden = True
329 by Martin Pool
- refactor command functions into command classes
391
    
392 by Martin Pool
- fix relpath and add tests
392
    def run(self, filename):
393
        print Branch(filename).relpath(filename)
329 by Martin Pool
- refactor command functions into command classes
394
395
396
397
class cmd_inventory(Command):
398
    """Show inventory of the current working copy or a revision."""
588 by Martin Pool
- change inventory command to not show ids by default
399
    takes_options = ['revision', 'show-ids']
329 by Martin Pool
- refactor command functions into command classes
400
    
588 by Martin Pool
- change inventory command to not show ids by default
401
    def run(self, revision=None, show_ids=False):
329 by Martin Pool
- refactor command functions into command classes
402
        b = Branch('.')
403
        if revision == None:
404
            inv = b.read_working_inventory()
405
        else:
406
            inv = b.get_revision_inventory(b.lookup_revision(revision))
407
556 by Martin Pool
- fix up Inventory.entries()
408
        for path, entry in inv.entries():
588 by Martin Pool
- change inventory command to not show ids by default
409
            if show_ids:
410
                print '%-50s %s' % (path, entry.file_id)
411
            else:
412
                print path
329 by Martin Pool
- refactor command functions into command classes
413
414
415
class cmd_move(Command):
416
    """Move files to a different directory.
417
418
    examples:
419
        bzr move *.txt doc
420
421
    The destination must be a versioned directory in the same branch.
422
    """
423
    takes_args = ['source$', 'dest']
424
    def run(self, source_list, dest):
425
        b = Branch('.')
426
427
        b.move([b.relpath(s) for s in source_list], b.relpath(dest))
428
429
430
class cmd_rename(Command):
168 by mbp at sourcefrog
new "rename" command
431
    """Change the name of an entry.
432
232 by mbp at sourcefrog
Allow docstrings for help to be in PEP0257 format.
433
    examples:
434
      bzr rename frob.c frobber.c
435
      bzr rename src/frob.c lib/frob.c
436
437
    It is an error if the destination name exists.
438
439
    See also the 'move' command, which moves files into a different
440
    directory without changing their name.
441
442
    TODO: Some way to rename multiple files without invoking bzr for each
443
    one?"""
329 by Martin Pool
- refactor command functions into command classes
444
    takes_args = ['from_name', 'to_name']
168 by mbp at sourcefrog
new "rename" command
445
    
329 by Martin Pool
- refactor command functions into command classes
446
    def run(self, from_name, to_name):
447
        b = Branch('.')
448
        b.rename_one(b.relpath(from_name), b.relpath(to_name))
449
450
451
628 by Martin Pool
- merge aaron's updated merge/pull code
452
453
454
class cmd_pull(Command):
455
    """Pull any changes from another branch into the current one.
456
457
    If the location is omitted, the last-used location will be used.
458
    Both the revision history and the working directory will be
459
    updated.
460
461
    This command only works on branches that have not diverged.  Branches are
462
    considered diverged if both branches have had commits without first
463
    pulling from the other.
464
465
    If branches have diverged, you can use 'bzr merge' to pull the text changes
466
    from one into the other.
467
    """
468
    takes_args = ['location?']
469
470
    def run(self, location=None):
471
        from bzrlib.merge import merge
472
        import errno
473
        
474
        br_to = Branch('.')
475
        stored_loc = None
476
        try:
477
            stored_loc = br_to.controlfile("x-pull", "rb").read().rstrip('\n')
478
        except IOError, e:
479
            if errno == errno.ENOENT:
480
                raise
481
        if location is None:
729 by Martin Pool
- pull shows location being used
482
            if stored_loc is None:
483
                raise BzrCommandError("No pull location known or specified.")
484
            else:
485
                print "Using last location: %s" % stored_loc
486
                location = stored_loc
628 by Martin Pool
- merge aaron's updated merge/pull code
487
        from branch import find_branch, DivergedBranches
488
        br_from = find_branch(location)
489
        location = pull_loc(br_from)
490
        old_revno = br_to.revno()
491
        try:
492
            br_to.update_revisions(br_from)
493
        except DivergedBranches:
494
            raise BzrCommandError("These branches have diverged.  Try merge.")
495
            
640 by Martin Pool
- bzr pull should not check that the tree is clean
496
        merge(('.', -1), ('.', old_revno), check_clean=False)
628 by Martin Pool
- merge aaron's updated merge/pull code
497
        if location != stored_loc:
498
            br_to.controlfile("x-pull", "wb").write(location + "\n")
499
500
501
502
class cmd_branch(Command):
503
    """Create a new copy of a branch.
504
685 by Martin Pool
- add -r option to the branch command
505
    If the TO_LOCATION is omitted, the last component of the FROM_LOCATION will
506
    be used.  In other words, "branch ../foo/bar" will attempt to create ./bar.
507
508
    To retrieve the branch as of a particular revision, supply the --revision
509
    parameter, as in "branch foo/bar -r 5".
628 by Martin Pool
- merge aaron's updated merge/pull code
510
    """
511
    takes_args = ['from_location', 'to_location?']
685 by Martin Pool
- add -r option to the branch command
512
    takes_options = ['revision']
628 by Martin Pool
- merge aaron's updated merge/pull code
513
685 by Martin Pool
- add -r option to the branch command
514
    def run(self, from_location, to_location=None, revision=None):
628 by Martin Pool
- merge aaron's updated merge/pull code
515
        import errno
516
        from bzrlib.merge import merge
685 by Martin Pool
- add -r option to the branch command
517
        from branch import find_branch, DivergedBranches, NoSuchRevision
518
        from shutil import rmtree
671 by Martin Pool
- Don't create an empty destination directory when
519
        try:
520
            br_from = find_branch(from_location)
521
        except OSError, e:
522
            if e.errno == errno.ENOENT:
523
                raise BzrCommandError('Source location "%s" does not exist.' %
524
                                      to_location)
525
            else:
526
                raise
527
628 by Martin Pool
- merge aaron's updated merge/pull code
528
        if to_location is None:
684 by Martin Pool
- Strip any number of trailing slashes and backslashes from the path name
529
            to_location = os.path.basename(from_location.rstrip("/\\"))
628 by Martin Pool
- merge aaron's updated merge/pull code
530
531
        try:
532
            os.mkdir(to_location)
533
        except OSError, e:
534
            if e.errno == errno.EEXIST:
535
                raise BzrCommandError('Target directory "%s" already exists.' %
536
                                      to_location)
537
            if e.errno == errno.ENOENT:
538
                raise BzrCommandError('Parent of "%s" does not exist.' %
539
                                      to_location)
540
            else:
541
                raise
542
        br_to = Branch(to_location, init=True)
543
685 by Martin Pool
- add -r option to the branch command
544
        try:
545
            br_to.update_revisions(br_from, stop_revision=revision)
546
        except NoSuchRevision:
547
            rmtree(to_location)
548
            msg = "The branch %s has no revision %d." % (from_location,
549
                                                         revision)
550
            raise BzrCommandError(msg)
628 by Martin Pool
- merge aaron's updated merge/pull code
551
        merge((to_location, -1), (to_location, 0), this_dir=to_location,
698 by Martin Pool
- bzr branch shouldn't say "0 conflicts"
552
              check_clean=False, ignore_zero=True)
685 by Martin Pool
- add -r option to the branch command
553
        from_location = pull_loc(br_from)
628 by Martin Pool
- merge aaron's updated merge/pull code
554
        br_to.controlfile("x-pull", "wb").write(from_location + "\n")
555
556
557
def pull_loc(branch):
558
    # TODO: Should perhaps just make attribute be 'base' in
559
    # RemoteBranch and Branch?
560
    if hasattr(branch, "baseurl"):
561
        return branch.baseurl
562
    else:
563
        return branch.base
564
565
566
329 by Martin Pool
- refactor command functions into command classes
567
class cmd_renames(Command):
164 by mbp at sourcefrog
new 'renames' command
568
    """Show list of renamed files.
569
232 by mbp at sourcefrog
Allow docstrings for help to be in PEP0257 format.
570
    TODO: Option to show renames between two historical versions.
571
572
    TODO: Only show renames under dir, rather than in the whole branch.
573
    """
329 by Martin Pool
- refactor command functions into command classes
574
    takes_args = ['dir?']
575
576
    def run(self, dir='.'):
577
        b = Branch(dir)
578
        old_inv = b.basis_tree().inventory
579
        new_inv = b.read_working_inventory()
580
581
        renames = list(bzrlib.tree.find_renames(old_inv, new_inv))
582
        renames.sort()
583
        for old_name, new_name in renames:
584
            print "%s => %s" % (old_name, new_name)        
585
586
587
class cmd_info(Command):
472 by Martin Pool
- Optional branch parameter to info command
588
    """Show statistical information about a branch."""
589
    takes_args = ['branch?']
590
    
591
    def run(self, branch=None):
329 by Martin Pool
- refactor command functions into command classes
592
        import info
472 by Martin Pool
- Optional branch parameter to info command
593
594
        from branch import find_branch
595
        b = find_branch(branch)
596
        info.show_info(b)
329 by Martin Pool
- refactor command functions into command classes
597
598
599
class cmd_remove(Command):
600
    """Make a file unversioned.
601
602
    This makes bzr stop tracking changes to a versioned file.  It does
603
    not delete the working copy.
604
    """
605
    takes_args = ['file+']
606
    takes_options = ['verbose']
607
    
608
    def run(self, file_list, verbose=False):
609
        b = Branch(file_list[0])
610
        b.remove([b.relpath(f) for f in file_list], verbose=verbose)
611
612
613
class cmd_file_id(Command):
178 by mbp at sourcefrog
- Use a non-null file_id for the branch root directory. At the moment
614
    """Print file_id of a particular file or directory.
615
232 by mbp at sourcefrog
Allow docstrings for help to be in PEP0257 format.
616
    The file_id is assigned when the file is first added and remains the
617
    same through all revisions where the file exists, even when it is
618
    moved or renamed.
619
    """
329 by Martin Pool
- refactor command functions into command classes
620
    hidden = True
621
    takes_args = ['filename']
622
    def run(self, filename):
623
        b = Branch(filename)
624
        i = b.inventory.path2id(b.relpath(filename))
625
        if i == None:
694 by Martin Pool
- weed out all remaining calls to bailout() and remove the function
626
            raise BzrError("%r is not a versioned file" % filename)
329 by Martin Pool
- refactor command functions into command classes
627
        else:
628
            print i
629
630
631
class cmd_file_path(Command):
178 by mbp at sourcefrog
- Use a non-null file_id for the branch root directory. At the moment
632
    """Print path of file_ids to a file or directory.
633
232 by mbp at sourcefrog
Allow docstrings for help to be in PEP0257 format.
634
    This prints one line for each directory down to the target,
635
    starting at the branch root."""
329 by Martin Pool
- refactor command functions into command classes
636
    hidden = True
637
    takes_args = ['filename']
638
    def run(self, filename):
639
        b = Branch(filename)
640
        inv = b.inventory
641
        fid = inv.path2id(b.relpath(filename))
642
        if fid == None:
694 by Martin Pool
- weed out all remaining calls to bailout() and remove the function
643
            raise BzrError("%r is not a versioned file" % filename)
329 by Martin Pool
- refactor command functions into command classes
644
        for fip in inv.get_idpath(fid):
645
            print fip
646
647
648
class cmd_revision_history(Command):
649
    """Display list of revision ids on this branch."""
584 by Martin Pool
- make relpath and revision-history hidden commands
650
    hidden = True
329 by Martin Pool
- refactor command functions into command classes
651
    def run(self):
652
        for patchid in Branch('.').revision_history():
653
            print patchid
654
655
656
class cmd_directories(Command):
657
    """Display list of versioned directories in this branch."""
658
    def run(self):
659
        for name, ie in Branch('.').read_working_inventory().directories():
660
            if name == '':
661
                print '.'
662
            else:
663
                print name
664
665
666
class cmd_init(Command):
667
    """Make a directory into a versioned branch.
668
669
    Use this to create an empty branch, or before importing an
670
    existing project.
671
672
    Recipe for importing a tree of files:
673
        cd ~/project
674
        bzr init
675
        bzr add -v .
676
        bzr status
677
        bzr commit -m 'imported project'
678
    """
679
    def run(self):
680
        Branch('.', init=True)
681
682
683
class cmd_diff(Command):
684
    """Show differences in working tree.
685
    
232 by mbp at sourcefrog
Allow docstrings for help to be in PEP0257 format.
686
    If files are listed, only the changes in those files are listed.
687
    Otherwise, all changes for the tree are listed.
688
689
    TODO: Given two revision arguments, show the difference between them.
690
691
    TODO: Allow diff across branches.
692
693
    TODO: Option to use external diff command; could be GNU diff, wdiff,
694
          or a graphical diff.
695
276 by Martin Pool
Doc
696
    TODO: Python difflib is not exactly the same as unidiff; should
697
          either fix it up or prefer to use an external diff.
698
232 by mbp at sourcefrog
Allow docstrings for help to be in PEP0257 format.
699
    TODO: If a directory is given, diff everything under that.
700
276 by Martin Pool
Doc
701
    TODO: Selected-file diff is inefficient and doesn't show you
702
          deleted files.
278 by Martin Pool
- Better workaround for trailing newlines in diffs
703
704
    TODO: This probably handles non-Unix newlines poorly.
329 by Martin Pool
- refactor command functions into command classes
705
    """
706
    
707
    takes_args = ['file*']
571 by Martin Pool
- new --diff-options to pass options through to external
708
    takes_options = ['revision', 'diff-options']
638 by Martin Pool
- add 'dif' as alias for 'diff' command
709
    aliases = ['di', 'dif']
329 by Martin Pool
- refactor command functions into command classes
710
571 by Martin Pool
- new --diff-options to pass options through to external
711
    def run(self, revision=None, file_list=None, diff_options=None):
329 by Martin Pool
- refactor command functions into command classes
712
        from bzrlib.diff import show_diff
547 by Martin Pool
- bzr diff finds a branch from the first parameter,
713
        from bzrlib import find_branch
714
715
        if file_list:
580 by Martin Pool
- Use explicit lock methods on a branch, rather than doing it
716
            b = find_branch(file_list[0])
547 by Martin Pool
- bzr diff finds a branch from the first parameter,
717
            file_list = [b.relpath(f) for f in file_list]
718
            if file_list == ['']:
719
                # just pointing to top-of-tree
720
                file_list = None
721
        else:
580 by Martin Pool
- Use explicit lock methods on a branch, rather than doing it
722
            b = Branch('.')
329 by Martin Pool
- refactor command functions into command classes
723
    
571 by Martin Pool
- new --diff-options to pass options through to external
724
        show_diff(b, revision, specific_files=file_list,
725
                  external_diff_options=diff_options)
329 by Martin Pool
- refactor command functions into command classes
726
727
437 by Martin Pool
- new command 'bzr modified' to exercise the statcache
728
        
729
730
329 by Martin Pool
- refactor command functions into command classes
731
class cmd_deleted(Command):
135 by mbp at sourcefrog
Simple new 'deleted' command
732
    """List files deleted in the working tree.
733
232 by mbp at sourcefrog
Allow docstrings for help to be in PEP0257 format.
734
    TODO: Show files deleted since a previous revision, or between two revisions.
135 by mbp at sourcefrog
Simple new 'deleted' command
735
    """
329 by Martin Pool
- refactor command functions into command classes
736
    def run(self, show_ids=False):
737
        b = Branch('.')
738
        old = b.basis_tree()
739
        new = b.working_tree()
740
741
        ## TODO: Much more efficient way to do this: read in new
742
        ## directories with readdir, rather than stating each one.  Same
743
        ## level of effort but possibly much less IO.  (Or possibly not,
744
        ## if the directories are very large...)
745
746
        for path, ie in old.inventory.iter_entries():
747
            if not new.has_id(ie.file_id):
748
                if show_ids:
749
                    print '%-50s %s' % (path, ie.file_id)
750
                else:
751
                    print path
752
437 by Martin Pool
- new command 'bzr modified' to exercise the statcache
753
754
class cmd_modified(Command):
755
    """List files modified in working tree."""
756
    hidden = True
757
    def run(self):
758
        import statcache
759
        b = Branch('.')
438 by Martin Pool
- Avoid calling Inventory.iter_entries() when finding modified
760
        inv = b.read_working_inventory()
761
        sc = statcache.update_cache(b, inv)
437 by Martin Pool
- new command 'bzr modified' to exercise the statcache
762
        basis = b.basis_tree()
763
        basis_inv = basis.inventory
438 by Martin Pool
- Avoid calling Inventory.iter_entries() when finding modified
764
        
765
        # We used to do this through iter_entries(), but that's slow
766
        # when most of the files are unmodified, as is usually the
767
        # case.  So instead we iterate by inventory entry, and only
768
        # calculate paths as necessary.
769
770
        for file_id in basis_inv:
771
            cacheentry = sc.get(file_id)
772
            if not cacheentry:                 # deleted
773
                continue
774
            ie = basis_inv[file_id]
437 by Martin Pool
- new command 'bzr modified' to exercise the statcache
775
            if cacheentry[statcache.SC_SHA1] != ie.text_sha1:
438 by Martin Pool
- Avoid calling Inventory.iter_entries() when finding modified
776
                path = inv.id2path(file_id)
437 by Martin Pool
- new command 'bzr modified' to exercise the statcache
777
                print path
439 by Martin Pool
- new command 'bzr added'
778
779
780
781
class cmd_added(Command):
782
    """List files added in working tree."""
783
    hidden = True
784
    def run(self):
785
        b = Branch('.')
786
        wt = b.working_tree()
787
        basis_inv = b.basis_tree().inventory
788
        inv = wt.inventory
789
        for file_id in inv:
790
            if file_id in basis_inv:
791
                continue
792
            path = inv.id2path(file_id)
793
            if not os.access(b.abspath(path), os.F_OK):
794
                continue
795
            print path
437 by Martin Pool
- new command 'bzr modified' to exercise the statcache
796
                
797
        
798
329 by Martin Pool
- refactor command functions into command classes
799
class cmd_root(Command):
800
    """Show the tree root directory.
801
802
    The root is the nearest enclosing directory with a .bzr control
803
    directory."""
804
    takes_args = ['filename?']
805
    def run(self, filename=None):
806
        """Print the branch root."""
416 by Martin Pool
- bzr log and bzr root now accept an http URL
807
        from branch import find_branch
808
        b = find_branch(filename)
809
        print getattr(b, 'base', None) or getattr(b, 'baseurl')
329 by Martin Pool
- refactor command functions into command classes
810
811
812
class cmd_log(Command):
1 by mbp at sourcefrog
import from baz patch-364
813
    """Show log of this branch.
814
567 by Martin Pool
- New form 'bzr log -r FROM:TO'
815
    To request a range of logs, you can use the command -r begin:end
816
    -r revision requests a specific revision, -r :end or -r begin: are
817
    also valid.
818
819
    TODO: Make --revision support uuid: and hash: [future tag:] notation.
820
  
545 by Martin Pool
- --forward option for log
821
    """
367 by Martin Pool
- New --show-ids option for bzr log
822
378 by Martin Pool
- New usage bzr log FILENAME
823
    takes_args = ['filename?']
567 by Martin Pool
- New form 'bzr log -r FROM:TO'
824
    takes_options = ['forward', 'timezone', 'verbose', 'show-ids', 'revision']
545 by Martin Pool
- --forward option for log
825
    
826
    def run(self, filename=None, timezone='original',
827
            verbose=False,
828
            show_ids=False,
567 by Martin Pool
- New form 'bzr log -r FROM:TO'
829
            forward=False,
830
            revision=None):
527 by Martin Pool
- refactor log command
831
        from bzrlib import show_log, find_branch
562 by Martin Pool
- bug fix for printing logs containing unicode
832
        import codecs
545 by Martin Pool
- --forward option for log
833
834
        direction = (forward and 'forward') or 'reverse'
527 by Martin Pool
- refactor log command
835
        
378 by Martin Pool
- New usage bzr log FILENAME
836
        if filename:
580 by Martin Pool
- Use explicit lock methods on a branch, rather than doing it
837
            b = find_branch(filename)
527 by Martin Pool
- refactor log command
838
            fp = b.relpath(filename)
533 by Martin Pool
- fix up asking for the log for the root of a remote branch
839
            if fp:
840
                file_id = b.read_working_inventory().path2id(fp)
841
            else:
842
                file_id = None  # points to branch root
527 by Martin Pool
- refactor log command
843
        else:
580 by Martin Pool
- Use explicit lock methods on a branch, rather than doing it
844
            b = find_branch('.')
527 by Martin Pool
- refactor log command
845
            file_id = None
846
567 by Martin Pool
- New form 'bzr log -r FROM:TO'
847
        if revision == None:
848
            revision = [None, None]
849
        elif isinstance(revision, int):
850
            revision = [revision, revision]
851
        else:
852
            # pair of revisions?
853
            pass
854
            
855
        assert len(revision) == 2
856
562 by Martin Pool
- bug fix for printing logs containing unicode
857
        mutter('encoding log as %r' % bzrlib.user_encoding)
610 by Martin Pool
- replace Branch.lock(mode) with separate lock_read and lock_write
858
859
        # use 'replace' so that we don't abort if trying to write out
860
        # in e.g. the default C locale.
861
        outf = codecs.getwriter(bzrlib.user_encoding)(sys.stdout, errors='replace')
562 by Martin Pool
- bug fix for printing logs containing unicode
862
527 by Martin Pool
- refactor log command
863
        show_log(b, file_id,
864
                 show_timezone=timezone,
865
                 verbose=verbose,
866
                 show_ids=show_ids,
562 by Martin Pool
- bug fix for printing logs containing unicode
867
                 to_file=outf,
567 by Martin Pool
- New form 'bzr log -r FROM:TO'
868
                 direction=direction,
869
                 start_revision=revision[0],
870
                 end_revision=revision[1])
329 by Martin Pool
- refactor command functions into command classes
871
872
375 by Martin Pool
- New command touching-revisions and function to trace
873
874
class cmd_touching_revisions(Command):
523 by Martin Pool
doc
875
    """Return revision-ids which affected a particular file.
876
877
    A more user-friendly interface is "bzr log FILE"."""
375 by Martin Pool
- New command touching-revisions and function to trace
878
    hidden = True
879
    takes_args = ["filename"]
880
    def run(self, filename):
580 by Martin Pool
- Use explicit lock methods on a branch, rather than doing it
881
        b = Branch(filename)
375 by Martin Pool
- New command touching-revisions and function to trace
882
        inv = b.read_working_inventory()
883
        file_id = inv.path2id(b.relpath(filename))
884
        for revno, revision_id, what in bzrlib.log.find_touching_revisions(b, file_id):
885
            print "%6d %s" % (revno, what)
886
887
329 by Martin Pool
- refactor command functions into command classes
888
class cmd_ls(Command):
1 by mbp at sourcefrog
import from baz patch-364
889
    """List files in a tree.
890
254 by Martin Pool
- Doc cleanups from Magnus Therning
891
    TODO: Take a revision or remote path and list that tree instead.
1 by mbp at sourcefrog
import from baz patch-364
892
    """
329 by Martin Pool
- refactor command functions into command classes
893
    hidden = True
894
    def run(self, revision=None, verbose=False):
895
        b = Branch('.')
896
        if revision == None:
897
            tree = b.working_tree()
898
        else:
899
            tree = b.revision_tree(b.lookup_revision(revision))
900
901
        for fp, fc, kind, fid in tree.list_files():
902
            if verbose:
903
                if kind == 'directory':
904
                    kindch = '/'
905
                elif kind == 'file':
906
                    kindch = ''
907
                else:
908
                    kindch = '???'
909
910
                print '%-8s %s%s' % (fc, fp, kindch)
1 by mbp at sourcefrog
import from baz patch-364
911
            else:
329 by Martin Pool
- refactor command functions into command classes
912
                print fp
913
914
915
916
class cmd_unknowns(Command):
634 by Martin Pool
- Tidy help messages
917
    """List unknown files."""
329 by Martin Pool
- refactor command functions into command classes
918
    def run(self):
919
        for f in Branch('.').unknowns():
920
            print quotefn(f)
921
922
923
924
class cmd_ignore(Command):
634 by Martin Pool
- Tidy help messages
925
    """Ignore a command or pattern.
420 by Martin Pool
Doc
926
927
    To remove patterns from the ignore list, edit the .bzrignore file.
928
929
    If the pattern contains a slash, it is compared to the whole path
930
    from the branch root.  Otherwise, it is comapred to only the last
931
    component of the path.
932
933
    Ignore patterns are case-insensitive on case-insensitive systems.
934
935
    Note: wildcards must be quoted from the shell on Unix.
936
937
    examples:
938
        bzr ignore ./Makefile
939
        bzr ignore '*.class'
940
    """
329 by Martin Pool
- refactor command functions into command classes
941
    takes_args = ['name_pattern']
310 by Martin Pool
- new 'bzr ignored' command!
942
    
329 by Martin Pool
- refactor command functions into command classes
943
    def run(self, name_pattern):
409 by Martin Pool
- New AtomicFile class
944
        from bzrlib.atomicfile import AtomicFile
575 by Martin Pool
- cleanup imports
945
        import os.path
409 by Martin Pool
- New AtomicFile class
946
329 by Martin Pool
- refactor command functions into command classes
947
        b = Branch('.')
410 by Martin Pool
- Fix ignore command and add tests
948
        ifn = b.abspath('.bzrignore')
329 by Martin Pool
- refactor command functions into command classes
949
410 by Martin Pool
- Fix ignore command and add tests
950
        if os.path.exists(ifn):
498 by Martin Pool
bugfix for bzr ignore reported by ddaa:
951
            f = open(ifn, 'rt')
952
            try:
953
                igns = f.read().decode('utf-8')
954
            finally:
955
                f.close()
409 by Martin Pool
- New AtomicFile class
956
        else:
957
            igns = ''
958
575 by Martin Pool
- cleanup imports
959
        # TODO: If the file already uses crlf-style termination, maybe
960
        # we should use that for the newly added lines?
961
409 by Martin Pool
- New AtomicFile class
962
        if igns and igns[-1] != '\n':
963
            igns += '\n'
964
        igns += name_pattern + '\n'
965
498 by Martin Pool
bugfix for bzr ignore reported by ddaa:
966
        try:
967
            f = AtomicFile(ifn, 'wt')
968
            f.write(igns.encode('utf-8'))
969
            f.commit()
970
        finally:
971
            f.close()
329 by Martin Pool
- refactor command functions into command classes
972
973
        inv = b.working_tree().inventory
974
        if inv.path2id('.bzrignore'):
975
            mutter('.bzrignore is already versioned')
976
        else:
977
            mutter('need to make new .bzrignore file versioned')
978
            b.add(['.bzrignore'])
979
980
981
982
class cmd_ignored(Command):
421 by Martin Pool
doc
983
    """List ignored files and the patterns that matched them.
984
985
    See also: bzr ignore"""
329 by Martin Pool
- refactor command functions into command classes
986
    def run(self):
987
        tree = Branch('.').working_tree()
988
        for path, file_class, kind, file_id in tree.list_files():
989
            if file_class != 'I':
990
                continue
991
            ## XXX: Slightly inefficient since this was already calculated
992
            pat = tree.is_ignored(path)
993
            print '%-50s %s' % (path, pat)
994
995
996
class cmd_lookup_revision(Command):
997
    """Lookup the revision-id from a revision-number
998
999
    example:
1000
        bzr lookup-revision 33
421 by Martin Pool
doc
1001
    """
329 by Martin Pool
- refactor command functions into command classes
1002
    hidden = True
338 by Martin Pool
- cleanup of some imports
1003
    takes_args = ['revno']
1004
    
329 by Martin Pool
- refactor command functions into command classes
1005
    def run(self, revno):
1006
        try:
1007
            revno = int(revno)
1008
        except ValueError:
338 by Martin Pool
- cleanup of some imports
1009
            raise BzrCommandError("not a valid revision-number: %r" % revno)
1010
1011
        print Branch('.').lookup_revision(revno)
329 by Martin Pool
- refactor command functions into command classes
1012
1013
1014
class cmd_export(Command):
1015
    """Export past revision to destination directory.
1016
678 by Martin Pool
- export to tarballs
1017
    If no revision is specified this exports the last committed revision.
1018
1019
    Format may be an "exporter" name, such as tar, tgz, tbz2.  If none is
1020
    given, exports to a directory (equivalent to --format=dir)."""
1021
    # TODO: list known exporters
329 by Martin Pool
- refactor command functions into command classes
1022
    takes_args = ['dest']
678 by Martin Pool
- export to tarballs
1023
    takes_options = ['revision', 'format']
1024
    def run(self, dest, revision=None, format='dir'):
329 by Martin Pool
- refactor command functions into command classes
1025
        b = Branch('.')
394 by Martin Pool
- Fix argument handling in export command
1026
        if revision == None:
1027
            rh = b.revision_history()[-1]
329 by Martin Pool
- refactor command functions into command classes
1028
        else:
394 by Martin Pool
- Fix argument handling in export command
1029
            rh = b.lookup_revision(int(revision))
329 by Martin Pool
- refactor command functions into command classes
1030
        t = b.revision_tree(rh)
678 by Martin Pool
- export to tarballs
1031
        t.export(dest, format)
329 by Martin Pool
- refactor command functions into command classes
1032
1033
1034
class cmd_cat(Command):
1035
    """Write a file's text from a previous revision."""
1036
1037
    takes_options = ['revision']
1038
    takes_args = ['filename']
1039
1040
    def run(self, filename, revision=None):
1041
        if revision == None:
1042
            raise BzrCommandError("bzr cat requires a revision number")
1043
        b = Branch('.')
1044
        b.print_file(b.relpath(filename), int(revision))
1045
1046
1047
class cmd_local_time_offset(Command):
1048
    """Show the offset in seconds from GMT to local time."""
1049
    hidden = True    
1050
    def run(self):
1051
        print bzrlib.osutils.local_time_offset()
1052
1053
1054
1055
class cmd_commit(Command):
1056
    """Commit changes into a new revision.
232 by mbp at sourcefrog
Allow docstrings for help to be in PEP0257 format.
1057
491 by Martin Pool
- Selective commit!
1058
    If selected files are specified, only changes to those files are
1059
    committed.  If a directory is specified then its contents are also
1060
    committed.
1061
1062
    A selected-file commit may fail in some cases where the committed
1063
    tree would be invalid, such as trying to commit a file in a
1064
    newly-added directory that is not itself committed.
232 by mbp at sourcefrog
Allow docstrings for help to be in PEP0257 format.
1065
1066
    TODO: Run hooks on tree to-be-committed, and after commit.
1067
1068
    TODO: Strict commit that fails if there are unknown or deleted files.
1069
    """
491 by Martin Pool
- Selective commit!
1070
    takes_args = ['selected*']
389 by Martin Pool
- new commit --file option!
1071
    takes_options = ['message', 'file', 'verbose']
350 by Martin Pool
- refactor command aliases into command classes
1072
    aliases = ['ci', 'checkin']
1073
505 by Martin Pool
- commit is verbose by default
1074
    def run(self, message=None, file=None, verbose=True, selected_list=None):
485 by Martin Pool
- move commit code into its own module
1075
        from bzrlib.commit import commit
1076
389 by Martin Pool
- new commit --file option!
1077
        ## Warning: shadows builtin file()
1078
        if not message and not file:
1079
            raise BzrCommandError("please specify a commit message",
1080
                                  ["use either --message or --file"])
1081
        elif message and file:
1082
            raise BzrCommandError("please specify either --message or --file")
1083
        
1084
        if file:
1085
            import codecs
1086
            message = codecs.open(file, 'rt', bzrlib.user_encoding).read()
1087
485 by Martin Pool
- move commit code into its own module
1088
        b = Branch('.')
491 by Martin Pool
- Selective commit!
1089
        commit(b, message, verbose=verbose, specific_files=selected_list)
329 by Martin Pool
- refactor command functions into command classes
1090
1091
1092
class cmd_check(Command):
1093
    """Validate consistency of branch history.
232 by mbp at sourcefrog
Allow docstrings for help to be in PEP0257 format.
1094
1095
    This command checks various invariants about the branch storage to
1096
    detect data corruption or bzr bugs.
674 by Martin Pool
- check command now also checks new inventory_sha1 and
1097
1098
    If given the --update flag, it will update some optional fields
1099
    to help ensure data consistency.
232 by mbp at sourcefrog
Allow docstrings for help to be in PEP0257 format.
1100
    """
329 by Martin Pool
- refactor command functions into command classes
1101
    takes_args = ['dir?']
674 by Martin Pool
- check command now also checks new inventory_sha1 and
1102
703 by Martin Pool
- split out a new 'bzr upgrade' command separate from
1103
    def run(self, dir='.'):
329 by Martin Pool
- refactor command functions into command classes
1104
        import bzrlib.check
703 by Martin Pool
- split out a new 'bzr upgrade' command separate from
1105
        bzrlib.check.check(Branch(dir))
1106
1107
1108
1109
class cmd_upgrade(Command):
1110
    """Upgrade branch storage to current format.
1111
1112
    This should normally be used only after the check command tells
1113
    you to run it.
1114
    """
1115
    takes_args = ['dir?']
1116
1117
    def run(self, dir='.'):
1118
        from bzrlib.upgrade import upgrade
1119
        upgrade(Branch(dir))
329 by Martin Pool
- refactor command functions into command classes
1120
1121
1122
1123
class cmd_whoami(Command):
1124
    """Show bzr user id."""
1125
    takes_options = ['email']
286 by Martin Pool
- New bzr whoami --email option
1126
    
329 by Martin Pool
- refactor command functions into command classes
1127
    def run(self, email=False):
1128
        if email:
1129
            print bzrlib.osutils.user_email()
1130
        else:
1131
            print bzrlib.osutils.username()
1132
1133
1134
class cmd_selftest(Command):
55 by mbp at sourcefrog
bzr selftest shows some counts of tests
1135
    """Run internal test suite"""
329 by Martin Pool
- refactor command functions into command classes
1136
    hidden = True
1137
    def run(self):
608 by Martin Pool
- Split selftests out into a new module and start changing them
1138
        from bzrlib.selftest import selftest
723 by Martin Pool
- move whitebox/blackbox modules into bzrlib.selftest subdirectory
1139
        return int(not selftest())
329 by Martin Pool
- refactor command functions into command classes
1140
1141
1142
class cmd_version(Command):
634 by Martin Pool
- Tidy help messages
1143
    """Show version of bzr."""
329 by Martin Pool
- refactor command functions into command classes
1144
    def run(self):
1145
        show_version()
1146
1147
def show_version():
1148
    print "bzr (bazaar-ng) %s" % bzrlib.__version__
605 by Martin Pool
- patch from Lalo Martins to show version of bzr itself
1149
    # is bzrlib itself in a branch?
606 by Martin Pool
- new bzrlib.get_bzr_revision() tells about the history of
1150
    bzrrev = bzrlib.get_bzr_revision()
1151
    if bzrrev:
1152
        print "  (bzr checkout, revision %d {%s})" % bzrrev
329 by Martin Pool
- refactor command functions into command classes
1153
    print bzrlib.__copyright__
1154
    print "http://bazaar-ng.org/"
1155
    print
1156
    print "bzr comes with ABSOLUTELY NO WARRANTY.  bzr is free software, and"
1157
    print "you may use, modify and redistribute it under the terms of the GNU"
1158
    print "General Public License version 2 or later."
1159
1160
1161
class cmd_rocks(Command):
1162
    """Statement of optimism."""
1163
    hidden = True
1164
    def run(self):
1165
        print "it sure does!"
1166
493 by Martin Pool
- Merge aaron's merge command
1167
def parse_spec(spec):
622 by Martin Pool
Updated merge patch from Aaron
1168
    """
1169
    >>> parse_spec(None)
1170
    [None, None]
1171
    >>> parse_spec("./")
1172
    ['./', None]
1173
    >>> parse_spec("../@")
1174
    ['..', -1]
1175
    >>> parse_spec("../f/@35")
1176
    ['../f', 35]
1177
    """
1178
    if spec is None:
1179
        return [None, None]
493 by Martin Pool
- Merge aaron's merge command
1180
    if '/@' in spec:
1181
        parsed = spec.split('/@')
1182
        assert len(parsed) == 2
1183
        if parsed[1] == "":
1184
            parsed[1] = -1
1185
        else:
1186
            parsed[1] = int(parsed[1])
1187
            assert parsed[1] >=0
1188
    else:
1189
        parsed = [spec, None]
1190
    return parsed
1191
628 by Martin Pool
- merge aaron's updated merge/pull code
1192
1193
493 by Martin Pool
- Merge aaron's merge command
1194
class cmd_merge(Command):
622 by Martin Pool
Updated merge patch from Aaron
1195
    """Perform a three-way merge of trees.
1196
    
1197
    The SPEC parameters are working tree or revision specifiers.  Working trees
1198
    are specified using standard paths or urls.  No component of a directory
1199
    path may begin with '@'.
1200
    
1201
    Working tree examples: '.', '..', 'foo@', but NOT 'foo/@bar'
1202
1203
    Revisions are specified using a dirname/@revno pair, where dirname is the
1204
    branch directory and revno is the revision within that branch.  If no revno
1205
    is specified, the latest revision is used.
1206
1207
    Revision examples: './@127', 'foo/@', '../@1'
1208
1209
    The OTHER_SPEC parameter is required.  If the BASE_SPEC parameter is
1210
    not supplied, the common ancestor of OTHER_SPEC the current branch is used
1211
    as the BASE.
628 by Martin Pool
- merge aaron's updated merge/pull code
1212
1213
    merge refuses to run if there are any uncommitted changes, unless
1214
    --force is given.
622 by Martin Pool
Updated merge patch from Aaron
1215
    """
1216
    takes_args = ['other_spec', 'base_spec?']
628 by Martin Pool
- merge aaron's updated merge/pull code
1217
    takes_options = ['force']
622 by Martin Pool
Updated merge patch from Aaron
1218
628 by Martin Pool
- merge aaron's updated merge/pull code
1219
    def run(self, other_spec, base_spec=None, force=False):
591 by Martin Pool
- trim imports
1220
        from bzrlib.merge import merge
628 by Martin Pool
- merge aaron's updated merge/pull code
1221
        merge(parse_spec(other_spec), parse_spec(base_spec),
1222
              check_clean=(not force))
329 by Martin Pool
- refactor command functions into command classes
1223
622 by Martin Pool
Updated merge patch from Aaron
1224
1225
class cmd_revert(Command):
628 by Martin Pool
- merge aaron's updated merge/pull code
1226
    """Reverse all changes since the last commit.
1227
1228
    Only versioned files are affected.
1229
1230
    TODO: Store backups of any files that will be reverted, so
1231
          that the revert can be undone.          
622 by Martin Pool
Updated merge patch from Aaron
1232
    """
1233
    takes_options = ['revision']
1234
1235
    def run(self, revision=-1):
636 by Martin Pool
- fix missing import in revert
1236
        from bzrlib.merge import merge
628 by Martin Pool
- merge aaron's updated merge/pull code
1237
        merge(('.', revision), parse_spec('.'),
1238
              check_clean=False,
1239
              ignore_zero=True)
622 by Martin Pool
Updated merge patch from Aaron
1240
1241
329 by Martin Pool
- refactor command functions into command classes
1242
class cmd_assert_fail(Command):
1243
    """Test reporting of assertion failures"""
1244
    hidden = True
1245
    def run(self):
1246
        assert False, "always fails"
1247
1248
1249
class cmd_help(Command):
1250
    """Show help on a command or other topic.
1251
1252
    For a list of all available commands, say 'bzr help commands'."""
1253
    takes_args = ['topic?']
350 by Martin Pool
- refactor command aliases into command classes
1254
    aliases = ['?']
329 by Martin Pool
- refactor command functions into command classes
1255
    
1256
    def run(self, topic=None):
351 by Martin Pool
- Split out help functions into bzrlib.help
1257
        import help
1258
        help.help(topic)
1259
1 by mbp at sourcefrog
import from baz patch-364
1260
429 by Martin Pool
- New command update-stat-cache for testing
1261
class cmd_update_stat_cache(Command):
1262
    """Update stat-cache mapping inodes to SHA-1 hashes.
1263
1264
    For testing only."""
1265
    hidden = True
1266
    def run(self):
1267
        import statcache
1268
        b = Branch('.')
454 by Martin Pool
- fix update-stat-cache command
1269
        statcache.update_cache(b.base, b.read_working_inventory())
429 by Martin Pool
- New command update-stat-cache for testing
1270
1271
1 by mbp at sourcefrog
import from baz patch-364
1272
755 by Martin Pool
- new 'plugins' command
1273
class cmd_plugins(Command):
1274
    """List plugins"""
1275
    hidden = True
1276
    def run(self):
1277
        import bzrlib.plugin
756 by Martin Pool
- plugins documentation; better error reporting when failing to
1278
        from pprint import pprint
1279
        pprint(bzrlib.plugin.all_plugins)
755 by Martin Pool
- new 'plugins' command
1280
1281
1282
1 by mbp at sourcefrog
import from baz patch-364
1283
# list of all available options; the rhs can be either None for an
1284
# option that takes no argument, or a constructor function that checks
1285
# the type.
1286
OPTIONS = {
1287
    'all':                    None,
571 by Martin Pool
- new --diff-options to pass options through to external
1288
    'diff-options':           str,
1 by mbp at sourcefrog
import from baz patch-364
1289
    'help':                   None,
389 by Martin Pool
- new commit --file option!
1290
    'file':                   unicode,
628 by Martin Pool
- merge aaron's updated merge/pull code
1291
    'force':                  None,
678 by Martin Pool
- export to tarballs
1292
    'format':                 unicode,
545 by Martin Pool
- --forward option for log
1293
    'forward':                None,
1 by mbp at sourcefrog
import from baz patch-364
1294
    'message':                unicode,
594 by Martin Pool
- add --no-recurse option for add command
1295
    'no-recurse':             None,
137 by mbp at sourcefrog
new --profile option
1296
    'profile':                None,
567 by Martin Pool
- New form 'bzr log -r FROM:TO'
1297
    'revision':               _parse_revision_str,
1 by mbp at sourcefrog
import from baz patch-364
1298
    'show-ids':               None,
12 by mbp at sourcefrog
new --timezone option for bzr log
1299
    'timezone':               str,
1 by mbp at sourcefrog
import from baz patch-364
1300
    'verbose':                None,
1301
    'version':                None,
286 by Martin Pool
- New bzr whoami --email option
1302
    'email':                  None,
674 by Martin Pool
- check command now also checks new inventory_sha1 and
1303
    'update':                 None,
1 by mbp at sourcefrog
import from baz patch-364
1304
    }
1305
1306
SHORT_OPTIONS = {
583 by Martin Pool
- add -h as short name for --help
1307
    'F':                      'file', 
1308
    'h':                      'help',
1 by mbp at sourcefrog
import from baz patch-364
1309
    'm':                      'message',
1310
    'r':                      'revision',
1311
    'v':                      'verbose',
1312
}
1313
1314
1315
def parse_args(argv):
1316
    """Parse command line.
1317
    
1318
    Arguments and options are parsed at this level before being passed
1319
    down to specific command handlers.  This routine knows, from a
1320
    lookup table, something about the available options, what optargs
1321
    they take, and which commands will accept them.
1322
31 by Martin Pool
fix up parse_args doctest
1323
    >>> parse_args('--help'.split())
1 by mbp at sourcefrog
import from baz patch-364
1324
    ([], {'help': True})
31 by Martin Pool
fix up parse_args doctest
1325
    >>> parse_args('--version'.split())
1 by mbp at sourcefrog
import from baz patch-364
1326
    ([], {'version': True})
31 by Martin Pool
fix up parse_args doctest
1327
    >>> parse_args('status --all'.split())
1 by mbp at sourcefrog
import from baz patch-364
1328
    (['status'], {'all': True})
31 by Martin Pool
fix up parse_args doctest
1329
    >>> parse_args('commit --message=biter'.split())
17 by mbp at sourcefrog
allow --option=ARG syntax
1330
    (['commit'], {'message': u'biter'})
683 by Martin Pool
- short option stacking patch from John A Meinel
1331
    >>> parse_args('log -r 500'.split())
1332
    (['log'], {'revision': 500})
1333
    >>> parse_args('log -r500:600'.split())
1334
    (['log'], {'revision': [500, 600]})
1335
    >>> parse_args('log -vr500:600'.split())
1336
    (['log'], {'verbose': True, 'revision': [500, 600]})
1337
    >>> parse_args('log -rv500:600'.split()) #the r takes an argument
1338
    Traceback (most recent call last):
1339
    ...
1340
    ValueError: invalid literal for int(): v500
1 by mbp at sourcefrog
import from baz patch-364
1341
    """
1342
    args = []
1343
    opts = {}
1344
1345
    # TODO: Maybe handle '--' to end options?
1346
26 by mbp at sourcefrog
fix StopIteration error on python2.3(?)
1347
    while argv:
1348
        a = argv.pop(0)
1 by mbp at sourcefrog
import from baz patch-364
1349
        if a[0] == '-':
264 by Martin Pool
parse_args: option names must be ascii
1350
            # option names must not be unicode
1351
            a = str(a)
17 by mbp at sourcefrog
allow --option=ARG syntax
1352
            optarg = None
1 by mbp at sourcefrog
import from baz patch-364
1353
            if a[1] == '-':
1354
                mutter("  got option %r" % a)
17 by mbp at sourcefrog
allow --option=ARG syntax
1355
                if '=' in a:
1356
                    optname, optarg = a[2:].split('=', 1)
1357
                else:
1358
                    optname = a[2:]
1 by mbp at sourcefrog
import from baz patch-364
1359
                if optname not in OPTIONS:
694 by Martin Pool
- weed out all remaining calls to bailout() and remove the function
1360
                    raise BzrError('unknown long option %r' % a)
1 by mbp at sourcefrog
import from baz patch-364
1361
            else:
1362
                shortopt = a[1:]
683 by Martin Pool
- short option stacking patch from John A Meinel
1363
                if shortopt in SHORT_OPTIONS:
1364
                    # Multi-character options must have a space to delimit
1365
                    # their value
1366
                    optname = SHORT_OPTIONS[shortopt]
1367
                else:
1368
                    # Single character short options, can be chained,
1369
                    # and have their value appended to their name
1370
                    shortopt = a[1:2]
1371
                    if shortopt not in SHORT_OPTIONS:
1372
                        # We didn't find the multi-character name, and we
1373
                        # didn't find the single char name
694 by Martin Pool
- weed out all remaining calls to bailout() and remove the function
1374
                        raise BzrError('unknown short option %r' % a)
683 by Martin Pool
- short option stacking patch from John A Meinel
1375
                    optname = SHORT_OPTIONS[shortopt]
1376
1377
                    if a[2:]:
1378
                        # There are extra things on this option
1379
                        # see if it is the value, or if it is another
1380
                        # short option
1381
                        optargfn = OPTIONS[optname]
1382
                        if optargfn is None:
1383
                            # This option does not take an argument, so the
1384
                            # next entry is another short option, pack it back
1385
                            # into the list
1386
                            argv.insert(0, '-' + a[2:])
1387
                        else:
1388
                            # This option takes an argument, so pack it
1389
                            # into the array
1390
                            optarg = a[2:]
1 by mbp at sourcefrog
import from baz patch-364
1391
            
1392
            if optname in opts:
1393
                # XXX: Do we ever want to support this, e.g. for -r?
694 by Martin Pool
- weed out all remaining calls to bailout() and remove the function
1394
                raise BzrError('repeated option %r' % a)
17 by mbp at sourcefrog
allow --option=ARG syntax
1395
                
1 by mbp at sourcefrog
import from baz patch-364
1396
            optargfn = OPTIONS[optname]
1397
            if optargfn:
17 by mbp at sourcefrog
allow --option=ARG syntax
1398
                if optarg == None:
26 by mbp at sourcefrog
fix StopIteration error on python2.3(?)
1399
                    if not argv:
694 by Martin Pool
- weed out all remaining calls to bailout() and remove the function
1400
                        raise BzrError('option %r needs an argument' % a)
17 by mbp at sourcefrog
allow --option=ARG syntax
1401
                    else:
26 by mbp at sourcefrog
fix StopIteration error on python2.3(?)
1402
                        optarg = argv.pop(0)
17 by mbp at sourcefrog
allow --option=ARG syntax
1403
                opts[optname] = optargfn(optarg)
1 by mbp at sourcefrog
import from baz patch-364
1404
            else:
17 by mbp at sourcefrog
allow --option=ARG syntax
1405
                if optarg != None:
694 by Martin Pool
- weed out all remaining calls to bailout() and remove the function
1406
                    raise BzrError('option %r takes no argument' % optname)
1 by mbp at sourcefrog
import from baz patch-364
1407
                opts[optname] = True
1408
        else:
1409
            args.append(a)
1410
1411
    return args, opts
1412
1413
1414
1415
329 by Martin Pool
- refactor command functions into command classes
1416
def _match_argform(cmd, takes_args, args):
1 by mbp at sourcefrog
import from baz patch-364
1417
    argdict = {}
26 by mbp at sourcefrog
fix StopIteration error on python2.3(?)
1418
329 by Martin Pool
- refactor command functions into command classes
1419
    # step through args and takes_args, allowing appropriate 0-many matches
1420
    for ap in takes_args:
1 by mbp at sourcefrog
import from baz patch-364
1421
        argname = ap[:-1]
1422
        if ap[-1] == '?':
62 by mbp at sourcefrog
- new find_branch_root function; based on suggestion from aaron
1423
            if args:
1424
                argdict[argname] = args.pop(0)
196 by mbp at sourcefrog
selected-file diff
1425
        elif ap[-1] == '*': # all remaining arguments
1426
            if args:
1427
                argdict[argname + '_list'] = args[:]
1428
                args = []
1429
            else:
1430
                argdict[argname + '_list'] = None
1 by mbp at sourcefrog
import from baz patch-364
1431
        elif ap[-1] == '+':
1432
            if not args:
329 by Martin Pool
- refactor command functions into command classes
1433
                raise BzrCommandError("command %r needs one or more %s"
1 by mbp at sourcefrog
import from baz patch-364
1434
                        % (cmd, argname.upper()))
1435
            else:
1436
                argdict[argname + '_list'] = args[:]
1437
                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
1438
        elif ap[-1] == '$': # all but one
1439
            if len(args) < 2:
329 by Martin Pool
- refactor command functions into command classes
1440
                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
1441
                        % (cmd, argname.upper()))
1442
            argdict[argname + '_list'] = args[:-1]
1443
            args[:-1] = []                
1 by mbp at sourcefrog
import from baz patch-364
1444
        else:
1445
            # just a plain arg
1446
            argname = ap
1447
            if not args:
329 by Martin Pool
- refactor command functions into command classes
1448
                raise BzrCommandError("command %r requires argument %s"
1 by mbp at sourcefrog
import from baz patch-364
1449
                        % (cmd, argname.upper()))
1450
            else:
1451
                argdict[argname] = args.pop(0)
1452
            
1453
    if args:
329 by Martin Pool
- refactor command functions into command classes
1454
        raise BzrCommandError("extra argument to command %s: %s"
1455
                              % (cmd, args[0]))
1 by mbp at sourcefrog
import from baz patch-364
1456
1457
    return argdict
1458
1459
731 by Martin Pool
- merge plugin patch from john
1460
def _parse_master_args(argv):
1461
    """Parse the arguments that always go with the original command.
1462
    These are things like bzr --no-plugins, etc.
1463
1464
    There are now 2 types of option flags. Ones that come *before* the command,
1465
    and ones that come *after* the command.
1466
    Ones coming *before* the command are applied against all possible commands.
1467
    And are generally applied before plugins are loaded.
1468
1469
    The current list are:
1470
        --builtin   Allow plugins to load, but don't let them override builtin commands,
1471
                    they will still be allowed if they do not override a builtin.
1472
        --no-plugins    Don't load any plugins. This lets you get back to official source
1473
                        behavior.
1474
        --profile   Enable the hotspot profile before running the command.
1475
                    For backwards compatibility, this is also a non-master option.
1476
        --version   Spit out the version of bzr that is running and exit.
1477
                    This is also a non-master option.
1478
        --help      Run help and exit, also a non-master option (I think that should stay, though)
1479
1480
    >>> argv, opts = _parse_master_args(['bzr', '--test'])
1481
    Traceback (most recent call last):
1482
    ...
1483
    BzrCommandError: Invalid master option: 'test'
1484
    >>> argv, opts = _parse_master_args(['bzr', '--version', 'command'])
1485
    >>> print argv
1486
    ['command']
1487
    >>> print opts['version']
1488
    True
1489
    >>> argv, opts = _parse_master_args(['bzr', '--profile', 'command', '--more-options'])
1490
    >>> print argv
1491
    ['command', '--more-options']
1492
    >>> print opts['profile']
1493
    True
1494
    >>> argv, opts = _parse_master_args(['bzr', '--no-plugins', 'command'])
1495
    >>> print argv
1496
    ['command']
1497
    >>> print opts['no-plugins']
1498
    True
1499
    >>> print opts['profile']
1500
    False
1501
    >>> argv, opts = _parse_master_args(['bzr', 'command', '--profile'])
1502
    >>> print argv
1503
    ['command', '--profile']
1504
    >>> print opts['profile']
1505
    False
1506
    """
1507
    master_opts = {'builtin':False,
1508
        'no-plugins':False,
1509
        'version':False,
1510
        'profile':False,
1511
        'help':False
1512
    }
1513
1514
    # This is the point where we could hook into argv[0] to determine
1515
    # what front-end is supposed to be run
1516
    # For now, we are just ignoring it.
1517
    cmd_name = argv.pop(0)
1518
    for arg in argv[:]:
1519
        if arg[:2] != '--': # at the first non-option, we return the rest
1520
            break
1521
        arg = arg[2:] # Remove '--'
1522
        if arg not in master_opts:
1523
            # We could say that this is not an error, that we should
1524
            # just let it be handled by the main section instead
1525
            raise BzrCommandError('Invalid master option: %r' % arg)
1526
        argv.pop(0) # We are consuming this entry
1527
        master_opts[arg] = True
1528
    return argv, master_opts
1529
1530
1 by mbp at sourcefrog
import from baz patch-364
1531
1532
def run_bzr(argv):
1533
    """Execute a command.
1534
1535
    This is similar to main(), but without all the trappings for
245 by mbp at sourcefrog
- control files always in utf-8-unix format
1536
    logging and error handling.  
1 by mbp at sourcefrog
import from baz patch-364
1537
    """
251 by mbp at sourcefrog
- factor out locale.getpreferredencoding()
1538
    argv = [a.decode(bzrlib.user_encoding) for a in argv]
245 by mbp at sourcefrog
- control files always in utf-8-unix format
1539
    
1 by mbp at sourcefrog
import from baz patch-364
1540
    try:
731 by Martin Pool
- merge plugin patch from john
1541
        # some options like --builtin and --no-plugins have special effects
1542
        argv, master_opts = _parse_master_args(argv)
755 by Martin Pool
- new 'plugins' command
1543
        if not master_opts['no-plugins']:
731 by Martin Pool
- merge plugin patch from john
1544
            bzrlib.load_plugins()
1545
1546
        args, opts = parse_args(argv)
1547
1548
        if master_opts['help']:
1549
            from bzrlib.help import help
1550
            if argv:
1551
                help(argv[0])
1552
            else:
1553
                help()
1554
            return 0            
1555
            
1 by mbp at sourcefrog
import from baz patch-364
1556
        if 'help' in opts:
731 by Martin Pool
- merge plugin patch from john
1557
            from bzrlib.help import help
159 by mbp at sourcefrog
bzr commit --help now works
1558
            if args:
731 by Martin Pool
- merge plugin patch from john
1559
                help(args[0])
159 by mbp at sourcefrog
bzr commit --help now works
1560
            else:
731 by Martin Pool
- merge plugin patch from john
1561
                help()
1 by mbp at sourcefrog
import from baz patch-364
1562
            return 0
1563
        elif 'version' in opts:
336 by Martin Pool
- fix up 'bzr --version'
1564
            show_version()
1 by mbp at sourcefrog
import from baz patch-364
1565
            return 0
641 by Martin Pool
- improved external-command patch from john
1566
        elif args and args[0] == 'builtin':
1567
            include_plugins=False
1568
            args = args[1:]
265 by Martin Pool
parse_args: command names must also be ascii
1569
        cmd = str(args.pop(0))
1 by mbp at sourcefrog
import from baz patch-364
1570
    except IndexError:
448 by Martin Pool
- bzr with no command now shows help, not just an error
1571
        import help
1572
        help.help()
1 by mbp at sourcefrog
import from baz patch-364
1573
        return 1
448 by Martin Pool
- bzr with no command now shows help, not just an error
1574
          
115 by mbp at sourcefrog
todo
1575
731 by Martin Pool
- merge plugin patch from john
1576
    plugins_override = not (master_opts['builtin'])
1577
    canonical_cmd, cmd_class = get_cmd_class(cmd, plugins_override=plugins_override)
1 by mbp at sourcefrog
import from baz patch-364
1578
731 by Martin Pool
- merge plugin patch from john
1579
    profile = master_opts['profile']
1580
    # For backwards compatibility, I would rather stick with --profile being a
1581
    # master/global option
137 by mbp at sourcefrog
new --profile option
1582
    if 'profile' in opts:
1583
        profile = True
1584
        del opts['profile']
1 by mbp at sourcefrog
import from baz patch-364
1585
1586
    # check options are reasonable
329 by Martin Pool
- refactor command functions into command classes
1587
    allowed = cmd_class.takes_options
1 by mbp at sourcefrog
import from baz patch-364
1588
    for oname in opts:
1589
        if oname not in allowed:
381 by Martin Pool
- Better message when a wrong argument is given
1590
            raise BzrCommandError("option '--%s' is not allowed for command %r"
329 by Martin Pool
- refactor command functions into command classes
1591
                                  % (oname, cmd))
176 by mbp at sourcefrog
New cat command contributed by janmar.
1592
137 by mbp at sourcefrog
new --profile option
1593
    # mix arguments and options into one dictionary
329 by Martin Pool
- refactor command functions into command classes
1594
    cmdargs = _match_argform(cmd, cmd_class.takes_args, args)
1595
    cmdopts = {}
136 by mbp at sourcefrog
new --show-ids option for 'deleted' command
1596
    for k, v in opts.items():
329 by Martin Pool
- refactor command functions into command classes
1597
        cmdopts[k.replace('-', '_')] = v
1 by mbp at sourcefrog
import from baz patch-364
1598
137 by mbp at sourcefrog
new --profile option
1599
    if profile:
338 by Martin Pool
- cleanup of some imports
1600
        import hotshot, tempfile
239 by mbp at sourcefrog
- remove profiler temporary file when done
1601
        pffileno, pfname = tempfile.mkstemp()
1602
        try:
1603
            prof = hotshot.Profile(pfname)
329 by Martin Pool
- refactor command functions into command classes
1604
            ret = prof.runcall(cmd_class, cmdopts, cmdargs) or 0
239 by mbp at sourcefrog
- remove profiler temporary file when done
1605
            prof.close()
1606
1607
            import hotshot.stats
1608
            stats = hotshot.stats.load(pfname)
1609
            #stats.strip_dirs()
1610
            stats.sort_stats('time')
1611
            ## XXX: Might like to write to stderr or the trace file instead but
1612
            ## print_stats seems hardcoded to stdout
1613
            stats.print_stats(20)
1614
            
337 by Martin Pool
- Clarify return codes from command objects
1615
            return ret.status
239 by mbp at sourcefrog
- remove profiler temporary file when done
1616
1617
        finally:
1618
            os.close(pffileno)
1619
            os.remove(pfname)
137 by mbp at sourcefrog
new --profile option
1620
    else:
500 by Martin Pool
- fix return value from run_bzr
1621
        return cmd_class(cmdopts, cmdargs).status 
1 by mbp at sourcefrog
import from baz patch-364
1622
1623
359 by Martin Pool
- pychecker fixups
1624
def _report_exception(summary, quiet=False):
267 by Martin Pool
- better reporting of errors
1625
    import traceback
1626
    log_error('bzr: ' + summary)
359 by Martin Pool
- pychecker fixups
1627
    bzrlib.trace.log_exception()
317 by Martin Pool
- better error message for broken pipe
1628
1629
    if not quiet:
1630
        tb = sys.exc_info()[2]
1631
        exinfo = traceback.extract_tb(tb)
1632
        if exinfo:
1633
            sys.stderr.write('  at %s:%d in %s()\n' % exinfo[-1][:3])
1634
        sys.stderr.write('  see ~/.bzr.log for debug information\n')
267 by Martin Pool
- better reporting of errors
1635
1636
1637
1 by mbp at sourcefrog
import from baz patch-364
1638
def main(argv):
317 by Martin Pool
- better error message for broken pipe
1639
    import errno
1640
    
344 by Martin Pool
- It's not an error to use the library without
1641
    bzrlib.open_tracefile(argv)
260 by Martin Pool
- remove atexit() dependency for writing out execution times
1642
1 by mbp at sourcefrog
import from baz patch-364
1643
    try:
260 by Martin Pool
- remove atexit() dependency for writing out execution times
1644
        try:
337 by Martin Pool
- Clarify return codes from command objects
1645
            try:
1646
                return run_bzr(argv)
1647
            finally:
1648
                # do this here inside the exception wrappers to catch EPIPE
1649
                sys.stdout.flush()
260 by Martin Pool
- remove atexit() dependency for writing out execution times
1650
        except BzrError, e:
329 by Martin Pool
- refactor command functions into command classes
1651
            quiet = isinstance(e, (BzrCommandError))
359 by Martin Pool
- pychecker fixups
1652
            _report_exception('error: ' + e.args[0], quiet=quiet)
260 by Martin Pool
- remove atexit() dependency for writing out execution times
1653
            if len(e.args) > 1:
1654
                for h in e.args[1]:
267 by Martin Pool
- better reporting of errors
1655
                    # some explanation or hints
260 by Martin Pool
- remove atexit() dependency for writing out execution times
1656
                    log_error('  ' + h)
1657
            return 1
267 by Martin Pool
- better reporting of errors
1658
        except AssertionError, e:
1659
            msg = 'assertion failed'
1660
            if str(e):
1661
                msg += ': ' + str(e)
359 by Martin Pool
- pychecker fixups
1662
            _report_exception(msg)
318 by Martin Pool
- better error message for Ctrl-c
1663
            return 2
1664
        except KeyboardInterrupt, e:
359 by Martin Pool
- pychecker fixups
1665
            _report_exception('interrupted', quiet=True)
318 by Martin Pool
- better error message for Ctrl-c
1666
            return 2
260 by Martin Pool
- remove atexit() dependency for writing out execution times
1667
        except Exception, e:
317 by Martin Pool
- better error message for broken pipe
1668
            quiet = False
419 by Martin Pool
- RemoteBranch.__str__ and repr
1669
            if (isinstance(e, IOError) 
1670
                and hasattr(e, 'errno')
1671
                and e.errno == errno.EPIPE):
317 by Martin Pool
- better error message for broken pipe
1672
                quiet = True
1673
                msg = 'broken pipe'
1674
            else:
1675
                msg = str(e).rstrip('\n')
359 by Martin Pool
- pychecker fixups
1676
            _report_exception(msg, quiet)
318 by Martin Pool
- better error message for Ctrl-c
1677
            return 2
260 by Martin Pool
- remove atexit() dependency for writing out execution times
1678
    finally:
1679
        bzrlib.trace.close_trace()
1 by mbp at sourcefrog
import from baz patch-364
1680
1681
1682
if __name__ == '__main__':
1683
    sys.exit(main(sys.argv))