To get this branch, use:
bzr branch
http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar
« back to all changes in this revision
Viewing changes to bzrlib/builtins.py
- browse files at revision 1658.1.9
- compare with another revision
- download diff
- download tarball
- view history from revision 1658.1.9
- Committer: Martin Pool
- Date: 2006-04-13 05:37:24 UTC
- mto: This revision was merged to the branch mainline in revision 1662.
- Revision ID: mbp@sourcefrog.net-20060413053724-8c0053ac31492637
Give an error for bzr diff on an nonexistent file (Malone #3619)
- files added:
- .bzrignore
- bzrlib
- bzrlib/doc
- bzrlib/doc/api
- bzrlib/export
- bzrlib/plugins
- bzrlib/store
- bzrlib/store/revision
- bzrlib/store/versioned
- bzrlib/tests
- bzrlib/tests/blackbox
- bzrlib/tests/branch_implementations
- bzrlib/tests/bzrdir_implementations
- bzrlib/tests/interrepository_implementations
- bzrlib/tests/interversionedfile_implementations
- bzrlib/tests/repository_implementations
- bzrlib/tests/revisionstore_implementations
- bzrlib/tests/workingtree_implementations
- bzrlib/transport
- bzrlib/transport/http
- bzrlib/ui
- bzrlib/util
- bzrlib/util/configobj
- bzrlib/util/configobj/docs
- bzrlib/util/effbot
- bzrlib/util/effbot/org
- bzrlib/util/elementtree
- bzrlib/util/urlgrabber
- contrib
- contrib/bash
- contrib/emacs
- contrib/zsh
- doc
- notes
- tools
- tools/doc_generate
- files removed:
- .bzrignore
- notes
- tests
added
removed
bzrlib/builtins.py
1
# Copyright (C) 2004, 2005, 2006 by Canonical Ltd
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
"""builtin bzr commands"""
18
19
20
import errno
21
import os
22
from shutil import rmtree
23
import sys
24
25
import bzrlib
26
import bzrlib.branch
27
from bzrlib.branch import Branch
28
import bzrlib.bzrdir as bzrdir
29
from bzrlib.commands import Command, display_command
30
from bzrlib.revision import common_ancestor
31
import bzrlib.errors as errors
32
from bzrlib.errors import (BzrError, BzrCheckError, BzrCommandError,
33
NotBranchError, DivergedBranches, NotConflicted,
34
NoSuchFile, NoWorkingTree, FileInWrongBranch,
35
NotVersionedError)
36
from bzrlib.log import show_one_log
37
from bzrlib.merge import Merge3Merger
38
from bzrlib.option import Option
39
from bzrlib.progress import DummyProgress, ProgressPhase
40
from bzrlib.revisionspec import RevisionSpec
41
import bzrlib.trace
42
from bzrlib.trace import mutter, note, log_error, warning, is_quiet
43
from bzrlib.transport.local import LocalTransport
44
import bzrlib.ui
45
from bzrlib.workingtree import WorkingTree
46
47
48
def tree_files(file_list, default_branch=u'.'):
49
try:
50
return internal_tree_files(file_list, default_branch)
51
except FileInWrongBranch, e:
52
raise BzrCommandError("%s is not in the same branch as %s" %
53
(e.path, file_list[0]))
54
55
56
# XXX: Bad function name; should possibly also be a class method of
57
# WorkingTree rather than a function.
58
def internal_tree_files(file_list, default_branch=u'.'):
59
"""Convert command-line paths to a WorkingTree and relative paths.
60
61
This is typically used for command-line processors that take one or
62
more filenames, and infer the workingtree that contains them.
63
64
The filenames given are not required to exist.
65
66
:param file_list: Filenames to convert.
67
68
:param default_branch: Fallback tree path to use if file_list is empty or None.
69
70
:return: workingtree, [relative_paths]
71
"""
72
if file_list is None or len(file_list) == 0:
73
return WorkingTree.open_containing(default_branch)[0], file_list
74
tree = WorkingTree.open_containing(file_list[0])[0]
75
new_list = []
76
for filename in file_list:
77
try:
78
new_list.append(tree.relpath(filename))
79
except errors.PathNotChild:
80
raise FileInWrongBranch(tree.branch, filename)
81
return tree, new_list
82
83
84
def get_format_type(typestring):
85
"""Parse and return a format specifier."""
86
if typestring == "metadir":
87
return bzrdir.BzrDirMetaFormat1()
88
if typestring == "knit":
89
format = bzrdir.BzrDirMetaFormat1()
90
format.repository_format = bzrlib.repository.RepositoryFormatKnit1()
91
return format
92
msg = "No known bzr-dir format %s. Supported types are: metadir\n" %\
93
(typestring)
94
raise BzrCommandError(msg)
95
96
97
# TODO: Make sure no commands unconditionally use the working directory as a
98
# branch. If a filename argument is used, the first of them should be used to
99
# specify the branch. (Perhaps this can be factored out into some kind of
100
# Argument class, representing a file in a branch, where the first occurrence
101
# opens the branch?)
102
103
class cmd_status(Command):
104
"""Display status summary.
105
106
This reports on versioned and unknown files, reporting them
107
grouped by state. Possible states are:
108
109
added
110
Versioned in the working copy but not in the previous revision.
111
112
removed
113
Versioned in the previous revision but removed or deleted
114
in the working copy.
115
116
renamed
117
Path of this file changed from the previous revision;
118
the text may also have changed. This includes files whose
119
parent directory was renamed.
120
121
modified
122
Text has changed since the previous revision.
123
124
unchanged
125
Nothing about this file has changed since the previous revision.
126
Only shown with --all.
127
128
unknown
129
Not versioned and not matching an ignore pattern.
130
131
To see ignored files use 'bzr ignored'. For details in the
132
changes to file texts, use 'bzr diff'.
133
134
If no arguments are specified, the status of the entire working
135
directory is shown. Otherwise, only the status of the specified
136
files or directories is reported. If a directory is given, status
137
is reported for everything inside that directory.
138
139
If a revision argument is given, the status is calculated against
140
that revision, or between two revisions if two are provided.
141
"""
142
143
# TODO: --no-recurse, --recurse options
144
145
takes_args = ['file*']
146
takes_options = ['all', 'show-ids', 'revision']
147
aliases = ['st', 'stat']
148
149
@display_command
150
def run(self, all=False, show_ids=False, file_list=None, revision=None):
151
tree, file_list = tree_files(file_list)
152
153
from bzrlib.status import show_tree_status
154
show_tree_status(tree, show_unchanged=all, show_ids=show_ids,
155
specific_files=file_list, revision=revision)
156
157
158
class cmd_cat_revision(Command):
159
"""Write out metadata for a revision.
160
161
The revision to print can either be specified by a specific
162
revision identifier, or you can use --revision.
163
"""
164
165
hidden = True
166
takes_args = ['revision_id?']
167
takes_options = ['revision']
168
169
@display_command
170
def run(self, revision_id=None, revision=None):
171
172
if revision_id is not None and revision is not None:
173
raise BzrCommandError('You can only supply one of revision_id or --revision')
174
if revision_id is None and revision is None:
175
raise BzrCommandError('You must supply either --revision or a revision_id')
176
b = WorkingTree.open_containing(u'.')[0].branch
177
if revision_id is not None:
178
sys.stdout.write(b.repository.get_revision_xml(revision_id))
179
elif revision is not None:
180
for rev in revision:
181
if rev is None:
182
raise BzrCommandError('You cannot specify a NULL revision.')
183
revno, rev_id = rev.in_history(b)
184
sys.stdout.write(b.repository.get_revision_xml(rev_id))
185
186
187
class cmd_revno(Command):
188
"""Show current revision number.
189
190
This is equal to the number of revisions on this branch."""
191
takes_args = ['location?']
192
@display_command
193
def run(self, location=u'.'):
194
print Branch.open_containing(location)[0].revno()
195
196
197
class cmd_revision_info(Command):
198
"""Show revision number and revision id for a given revision identifier.
199
"""
200
hidden = True
201
takes_args = ['revision_info*']
202
takes_options = ['revision']
203
@display_command
204
def run(self, revision=None, revision_info_list=[]):
205
206
revs = []
207
if revision is not None:
208
revs.extend(revision)
209
if revision_info_list is not None:
210
for rev in revision_info_list:
211
revs.append(RevisionSpec(rev))
212
if len(revs) == 0:
213
raise BzrCommandError('You must supply a revision identifier')
214
215
b = WorkingTree.open_containing(u'.')[0].branch
216
217
for rev in revs:
218
revinfo = rev.in_history(b)
219
if revinfo.revno is None:
220
print ' %s' % revinfo.rev_id
221
else:
222
print '%4d %s' % (revinfo.revno, revinfo.rev_id)
223
224
225
class cmd_add(Command):
226
"""Add specified files or directories.
227
228
In non-recursive mode, all the named items are added, regardless
229
of whether they were previously ignored. A warning is given if
230
any of the named files are already versioned.
231
232
In recursive mode (the default), files are treated the same way
233
but the behaviour for directories is different. Directories that
234
are already versioned do not give a warning. All directories,
235
whether already versioned or not, are searched for files or
236
subdirectories that are neither versioned or ignored, and these
237
are added. This search proceeds recursively into versioned
238
directories. If no names are given '.' is assumed.
239
240
Therefore simply saying 'bzr add' will version all files that
241
are currently unknown.
242
243
Adding a file whose parent directory is not versioned will
244
implicitly add the parent, and so on up to the root. This means
245
you should never need to explictly add a directory, they'll just
246
get added when you add a file in the directory.
247
248
--dry-run will show which files would be added, but not actually
249
add them.
250
"""
251
takes_args = ['file*']
252
takes_options = ['no-recurse', 'dry-run', 'verbose']
253
254
def run(self, file_list, no_recurse=False, dry_run=False, verbose=False):
255
import bzrlib.add
256
257
if dry_run:
258
if is_quiet():
259
# This is pointless, but I'd rather not raise an error
260
action = bzrlib.add.add_action_null
261
else:
262
action = bzrlib.add.add_action_print
263
elif is_quiet():
264
action = bzrlib.add.add_action_add
265
else:
266
action = bzrlib.add.add_action_add_and_print
267
268
added, ignored = bzrlib.add.smart_add(file_list, not no_recurse,
269
action)
270
if len(ignored) > 0:
271
for glob in sorted(ignored.keys()):
272
match_len = len(ignored[glob])
273
if verbose:
274
for path in ignored[glob]:
275
print "ignored %s matching \"%s\"" % (path, glob)
276
else:
277
print "ignored %d file(s) matching \"%s\"" % (match_len,
278
glob)
279
print "If you wish to add some of these files, please add them"\
280
" by name."
281
282
283
class cmd_mkdir(Command):
284
"""Create a new versioned directory.
285
286
This is equivalent to creating the directory and then adding it.
287
"""
288
takes_args = ['dir+']
289
290
def run(self, dir_list):
291
for d in dir_list:
292
os.mkdir(d)
293
wt, dd = WorkingTree.open_containing(d)
294
wt.add([dd])
295
print 'added', d
296
297
298
class cmd_relpath(Command):
299
"""Show path of a file relative to root"""
300
takes_args = ['filename']
301
hidden = True
302
303
@display_command
304
def run(self, filename):
305
tree, relpath = WorkingTree.open_containing(filename)
306
print relpath
307
308
309
class cmd_inventory(Command):
310
"""Show inventory of the current working copy or a revision.
311
312
It is possible to limit the output to a particular entry
313
type using the --kind option. For example; --kind file.
314
"""
315
takes_options = ['revision', 'show-ids', 'kind']
316
317
@display_command
318
def run(self, revision=None, show_ids=False, kind=None):
319
if kind and kind not in ['file', 'directory', 'symlink']:
320
raise BzrCommandError('invalid kind specified')
321
tree = WorkingTree.open_containing(u'.')[0]
322
if revision is None:
323
inv = tree.read_working_inventory()
324
else:
325
if len(revision) > 1:
326
raise BzrCommandError('bzr inventory --revision takes'
327
' exactly one revision identifier')
328
inv = tree.branch.repository.get_revision_inventory(
329
revision[0].in_history(tree.branch).rev_id)
330
331
for path, entry in inv.entries():
332
if kind and kind != entry.kind:
333
continue
334
if show_ids:
335
print '%-50s %s' % (path, entry.file_id)
336
else:
337
print path
338
339
340
class cmd_mv(Command):
341
"""Move or rename a file.
342
343
usage:
344
bzr mv OLDNAME NEWNAME
345
bzr mv SOURCE... DESTINATION
346
347
If the last argument is a versioned directory, all the other names
348
are moved into it. Otherwise, there must be exactly two arguments
349
and the file is changed to a new name, which must not already exist.
350
351
Files cannot be moved between branches.
352
"""
353
takes_args = ['names*']
354
aliases = ['move', 'rename']
355
356
def run(self, names_list):
357
if len(names_list) < 2:
358
raise BzrCommandError("missing file argument")
359
tree, rel_names = tree_files(names_list)
360
361
if os.path.isdir(names_list[-1]):
362
# move into existing directory
363
for pair in tree.move(rel_names[:-1], rel_names[-1]):
364
print "%s => %s" % pair
365
else:
366
if len(names_list) != 2:
367
raise BzrCommandError('to mv multiple files the destination '
368
'must be a versioned directory')
369
tree.rename_one(rel_names[0], rel_names[1])
370
print "%s => %s" % (rel_names[0], rel_names[1])
371
372
373
class cmd_pull(Command):
374
"""Turn this branch into a mirror of another branch.
375
376
If there is no default location set, the first pull will set it. After
377
that, you can omit the location to use the default. To change the
378
default, use --remember.
379
380
This command only works on branches that have not diverged. Branches are
381
considered diverged if the destination branch's most recent commit is one
382
that has not been merged (directly or indirectly) into the parent.
383
384
If branches have diverged, you can use 'bzr merge' to pull the text changes
385
from one into the other. Once one branch has merged, the other should
386
be able to pull it again.
387
388
If you want to forget your local changes and just update your branch to
389
match the remote one, use --overwrite.
390
"""
391
takes_options = ['remember', 'overwrite', 'revision', 'verbose']
392
takes_args = ['location?']
393
394
def run(self, location=None, remember=False, overwrite=False, revision=None, verbose=False):
395
# FIXME: too much stuff is in the command class
396
try:
397
tree_to = WorkingTree.open_containing(u'.')[0]
398
branch_to = tree_to.branch
399
except NoWorkingTree:
400
tree_to = None
401
branch_to = Branch.open_containing(u'.')[0]
402
stored_loc = branch_to.get_parent()
403
if location is None:
404
if stored_loc is None:
405
raise BzrCommandError("No pull location known or specified.")
406
else:
407
print "Using saved location: %s" % stored_loc
408
location = stored_loc
409
410
br_from = Branch.open(location)
411
412
if revision is None:
413
rev_id = None
414
elif len(revision) == 1:
415
rev_id = revision[0].in_history(br_from).rev_id
416
else:
417
raise BzrCommandError('bzr pull --revision takes one value.')
418
419
old_rh = branch_to.revision_history()
420
if tree_to is not None:
421
count = tree_to.pull(br_from, overwrite, rev_id)
422
else:
423
count = branch_to.pull(br_from, overwrite, rev_id)
424
425
if branch_to.get_parent() is None or remember:
426
branch_to.set_parent(location)
427
note('%d revision(s) pulled.' % (count,))
428
429
if verbose:
430
new_rh = branch_to.revision_history()
431
if old_rh != new_rh:
432
# Something changed
433
from bzrlib.log import show_changed_revisions
434
show_changed_revisions(branch_to, old_rh, new_rh)
435
436
437
class cmd_push(Command):
438
"""Update a mirror of this branch.
439
440
The target branch will not have its working tree populated because this
441
is both expensive, and is not supported on remote file systems.
442
443
Some smart servers or protocols *may* put the working tree in place in
444
the future.
445
446
If there is no default push location set, the first push will set it.
447
After that, you can omit the location to use the default. To change the
448
default, use --remember.
449
450
This command only works on branches that have not diverged. Branches are
451
considered diverged if the destination branch's most recent commit is one
452
that has not been merged (directly or indirectly) by the source branch.
453
454
If branches have diverged, you can use 'bzr push --overwrite' to replace
455
the other branch completely, discarding its unmerged changes.
456
457
If you want to ensure you have the different changes in the other branch,
458
do a merge (see bzr help merge) from the other branch, and commit that.
459
After that you will be able to do a push without '--overwrite'.
460
"""
461
takes_options = ['remember', 'overwrite',
462
Option('create-prefix',
463
help='Create the path leading up to the branch '
464
'if it does not already exist')]
465
takes_args = ['location?']
466
467
def run(self, location=None, remember=False, overwrite=False,
468
create_prefix=False, verbose=False):
469
# FIXME: Way too big! Put this into a function called from the
470
# command.
471
from bzrlib.transport import get_transport
472
473
tree_from = WorkingTree.open_containing(u'.')[0]
474
br_from = tree_from.branch
475
stored_loc = tree_from.branch.get_push_location()
476
if location is None:
477
if stored_loc is None:
478
raise BzrCommandError("No push location known or specified.")
479
else:
480
print "Using saved location: %s" % stored_loc
481
location = stored_loc
482
try:
483
dir_to = bzrlib.bzrdir.BzrDir.open(location)
484
br_to = dir_to.open_branch()
485
except NotBranchError:
486
# create a branch.
487
transport = get_transport(location).clone('..')
488
if not create_prefix:
489
try:
490
transport.mkdir(transport.relpath(location))
491
except NoSuchFile:
492
raise BzrCommandError("Parent directory of %s "
493
"does not exist." % location)
494
else:
495
current = transport.base
496
needed = [(transport, transport.relpath(location))]
497
while needed:
498
try:
499
transport, relpath = needed[-1]
500
transport.mkdir(relpath)
501
needed.pop()
502
except NoSuchFile:
503
new_transport = transport.clone('..')
504
needed.append((new_transport,
505
new_transport.relpath(transport.base)))
506
if new_transport.base == transport.base:
507
raise BzrCommandError("Could not create "
508
"path prefix.")
509
dir_to = br_from.bzrdir.clone(location)
510
br_to = dir_to.open_branch()
511
old_rh = br_to.revision_history()
512
try:
513
try:
514
tree_to = dir_to.open_workingtree()
515
except errors.NotLocalUrl:
516
# TODO: This should be updated for branches which don't have a
517
# working tree, as opposed to ones where we just couldn't
518
# update the tree.
519
warning('This transport does not update the working '
520
'tree of: %s' % (br_to.base,))
521
count = br_to.pull(br_from, overwrite)
522
except NoWorkingTree:
523
count = br_to.pull(br_from, overwrite)
524
else:
525
count = tree_to.pull(br_from, overwrite)
526
except DivergedBranches:
527
raise BzrCommandError("These branches have diverged."
528
" Try a merge then push with overwrite.")
529
if br_from.get_push_location() is None or remember:
530
br_from.set_push_location(location)
531
note('%d revision(s) pushed.' % (count,))
532
533
if verbose:
534
new_rh = br_to.revision_history()
535
if old_rh != new_rh:
536
# Something changed
537
from bzrlib.log import show_changed_revisions
538
show_changed_revisions(br_to, old_rh, new_rh)
539
540
541
class cmd_branch(Command):
542
"""Create a new copy of a branch.
543
544
If the TO_LOCATION is omitted, the last component of the FROM_LOCATION will
545
be used. In other words, "branch ../foo/bar" will attempt to create ./bar.
546
547
To retrieve the branch as of a particular revision, supply the --revision
548
parameter, as in "branch foo/bar -r 5".
549
550
--basis is to speed up branching from remote branches. When specified, it
551
copies all the file-contents, inventory and revision data from the basis
552
branch before copying anything from the remote branch.
553
"""
554
takes_args = ['from_location', 'to_location?']
555
takes_options = ['revision', 'basis']
556
aliases = ['get', 'clone']
557
558
def run(self, from_location, to_location=None, revision=None, basis=None):
559
if revision is None:
560
revision = [None]
561
elif len(revision) > 1:
562
raise BzrCommandError(
563
'bzr branch --revision takes exactly 1 revision value')
564
try:
565
br_from = Branch.open(from_location)
566
except OSError, e:
567
if e.errno == errno.ENOENT:
568
raise BzrCommandError('Source location "%s" does not'
569
' exist.' % to_location)
570
else:
571
raise
572
br_from.lock_read()
573
try:
574
if basis is not None:
575
basis_dir = bzrdir.BzrDir.open_containing(basis)[0]
576
else:
577
basis_dir = None
578
if len(revision) == 1 and revision[0] is not None:
579
revision_id = revision[0].in_history(br_from)[1]
580
else:
581
# FIXME - wt.last_revision, fallback to branch, fall back to
582
# None or perhaps NULL_REVISION to mean copy nothing
583
# RBC 20060209
584
revision_id = br_from.last_revision()
585
if to_location is None:
586
to_location = os.path.basename(from_location.rstrip("/\\"))
587
name = None
588
else:
589
name = os.path.basename(to_location) + '\n'
590
try:
591
os.mkdir(to_location)
592
except OSError, e:
593
if e.errno == errno.EEXIST:
594
raise BzrCommandError('Target directory "%s" already'
595
' exists.' % to_location)
596
if e.errno == errno.ENOENT:
597
raise BzrCommandError('Parent of "%s" does not exist.' %
598
to_location)
599
else:
600
raise
601
try:
602
# preserve whatever source format we have.
603
dir = br_from.bzrdir.sprout(to_location, revision_id, basis_dir)
604
branch = dir.open_branch()
605
except bzrlib.errors.NoSuchRevision:
606
rmtree(to_location)
607
msg = "The branch %s has no revision %s." % (from_location, revision[0])
608
raise BzrCommandError(msg)
609
except bzrlib.errors.UnlistableBranch:
610
rmtree(to_location)
611
msg = "The branch %s cannot be used as a --basis" % (basis,)
612
raise BzrCommandError(msg)
613
if name:
614
branch.control_files.put_utf8('branch-name', name)
615
616
note('Branched %d revision(s).' % branch.revno())
617
finally:
618
br_from.unlock()
619
620
621
class cmd_checkout(Command):
622
"""Create a new checkout of an existing branch.
623
624
If BRANCH_LOCATION is omitted, checkout will reconstitute a working tree for
625
the branch found in '.'. This is useful if you have removed the working tree
626
or if it was never created - i.e. if you pushed the branch to its current
627
location using SFTP.
628
629
If the TO_LOCATION is omitted, the last component of the BRANCH_LOCATION will
630
be used. In other words, "checkout ../foo/bar" will attempt to create ./bar.
631
632
To retrieve the branch as of a particular revision, supply the --revision
633
parameter, as in "checkout foo/bar -r 5". Note that this will be immediately
634
out of date [so you cannot commit] but it may be useful (i.e. to examine old
635
code.)
636
637
--basis is to speed up checking out from remote branches. When specified, it
638
uses the inventory and file contents from the basis branch in preference to the
639
branch being checked out. [Not implemented yet.]
640
"""
641
takes_args = ['branch_location?', 'to_location?']
642
takes_options = ['revision', # , 'basis']
643
Option('lightweight',
644
help="perform a lightweight checkout. Lightweight "
645
"checkouts depend on access to the branch for "
646
"every operation. Normal checkouts can perform "
647
"common operations like diff and status without "
648
"such access, and also support local commits."
649
),
650
]
651
652
def run(self, branch_location=None, to_location=None, revision=None, basis=None,
653
lightweight=False):
654
if revision is None:
655
revision = [None]
656
elif len(revision) > 1:
657
raise BzrCommandError(
658
'bzr checkout --revision takes exactly 1 revision value')
659
if branch_location is None:
660
branch_location = bzrlib.osutils.getcwd()
661
to_location = branch_location
662
source = Branch.open(branch_location)
663
if len(revision) == 1 and revision[0] is not None:
664
revision_id = revision[0].in_history(source)[1]
665
else:
666
revision_id = None
667
if to_location is None:
668
to_location = os.path.basename(branch_location.rstrip("/\\"))
669
# if the source and to_location are the same,
670
# and there is no working tree,
671
# then reconstitute a branch
672
if (bzrlib.osutils.abspath(to_location) ==
673
bzrlib.osutils.abspath(branch_location)):
674
try:
675
source.bzrdir.open_workingtree()
676
except errors.NoWorkingTree:
677
source.bzrdir.create_workingtree()
678
return
679
try:
680
os.mkdir(to_location)
681
except OSError, e:
682
if e.errno == errno.EEXIST:
683
raise BzrCommandError('Target directory "%s" already'
684
' exists.' % to_location)
685
if e.errno == errno.ENOENT:
686
raise BzrCommandError('Parent of "%s" does not exist.' %
687
to_location)
688
else:
689
raise
690
old_format = bzrlib.bzrdir.BzrDirFormat.get_default_format()
691
bzrlib.bzrdir.BzrDirFormat.set_default_format(bzrdir.BzrDirMetaFormat1())
692
try:
693
if lightweight:
694
checkout = bzrdir.BzrDirMetaFormat1().initialize(to_location)
695
bzrlib.branch.BranchReferenceFormat().initialize(checkout, source)
696
else:
697
checkout_branch = bzrlib.bzrdir.BzrDir.create_branch_convenience(
698
to_location, force_new_tree=False)
699
checkout = checkout_branch.bzrdir
700
checkout_branch.bind(source)
701
if revision_id is not None:
702
rh = checkout_branch.revision_history()
703
checkout_branch.set_revision_history(rh[:rh.index(revision_id) + 1])
704
checkout.create_workingtree(revision_id)
705
finally:
706
bzrlib.bzrdir.BzrDirFormat.set_default_format(old_format)
707
708
709
class cmd_renames(Command):
710
"""Show list of renamed files.
711
"""
712
# TODO: Option to show renames between two historical versions.
713
714
# TODO: Only show renames under dir, rather than in the whole branch.
715
takes_args = ['dir?']
716
717
@display_command
718
def run(self, dir=u'.'):
719
tree = WorkingTree.open_containing(dir)[0]
720
old_inv = tree.basis_tree().inventory
721
new_inv = tree.read_working_inventory()
722
723
renames = list(bzrlib.tree.find_renames(old_inv, new_inv))
724
renames.sort()
725
for old_name, new_name in renames:
726
print "%s => %s" % (old_name, new_name)
727
728
729
class cmd_update(Command):
730
"""Update a tree to have the latest code committed to its branch.
731
732
This will perform a merge into the working tree, and may generate
733
conflicts. If you have any local changes, you will still
734
need to commit them after the update for the update to be complete.
735
736
If you want to discard your local changes, you can just do a
737
'bzr revert' instead of 'bzr commit' after the update.
738
"""
739
takes_args = ['dir?']
740
741
def run(self, dir='.'):
742
tree = WorkingTree.open_containing(dir)[0]
743
tree.lock_write()
744
try:
745
if tree.last_revision() == tree.branch.last_revision():
746
# may be up to date, check master too.
747
master = tree.branch.get_master_branch()
748
if master is None or master.last_revision == tree.last_revision():
749
note("Tree is up to date.")
750
return
751
conflicts = tree.update()
752
note('Updated to revision %d.' %
753
(tree.branch.revision_id_to_revno(tree.last_revision()),))
754
if conflicts != 0:
755
return 1
756
else:
757
return 0
758
finally:
759
tree.unlock()
760
761
762
class cmd_info(Command):
763
"""Show statistical information about a branch."""
764
takes_args = ['branch?']
765
takes_options = ['verbose']
766
767
@display_command
768
def run(self, branch=None, verbose=False):
769
import bzrlib.info
770
bzrlib.info.show_bzrdir_info(bzrdir.BzrDir.open_containing(branch)[0],
771
verbose=verbose)
772
773
774
class cmd_remove(Command):
775
"""Make a file unversioned.
776
777
This makes bzr stop tracking changes to a versioned file. It does
778
not delete the working copy.
779
"""
780
takes_args = ['file+']
781
takes_options = ['verbose']
782
aliases = ['rm']
783
784
def run(self, file_list, verbose=False):
785
tree, file_list = tree_files(file_list)
786
tree.remove(file_list, verbose=verbose)
787
788
789
class cmd_file_id(Command):
790
"""Print file_id of a particular file or directory.
791
792
The file_id is assigned when the file is first added and remains the
793
same through all revisions where the file exists, even when it is
794
moved or renamed.
795
"""
796
hidden = True
797
takes_args = ['filename']
798
@display_command
799
def run(self, filename):
800
tree, relpath = WorkingTree.open_containing(filename)
801
i = tree.inventory.path2id(relpath)
802
if i == None:
803
raise BzrError("%r is not a versioned file" % filename)
804
else:
805
print i
806
807
808
class cmd_file_path(Command):
809
"""Print path of file_ids to a file or directory.
810
811
This prints one line for each directory down to the target,
812
starting at the branch root."""
813
hidden = True
814
takes_args = ['filename']
815
@display_command
816
def run(self, filename):
817
tree, relpath = WorkingTree.open_containing(filename)
818
inv = tree.inventory
819
fid = inv.path2id(relpath)
820
if fid == None:
821
raise BzrError("%r is not a versioned file" % filename)
822
for fip in inv.get_idpath(fid):
823
print fip
824
825
826
class cmd_reconcile(Command):
827
"""Reconcile bzr metadata in a branch.
828
829
This can correct data mismatches that may have been caused by
830
previous ghost operations or bzr upgrades. You should only
831
need to run this command if 'bzr check' or a bzr developer
832
advises you to run it.
833
834
If a second branch is provided, cross-branch reconciliation is
835
also attempted, which will check that data like the tree root
836
id which was not present in very early bzr versions is represented
837
correctly in both branches.
838
839
At the same time it is run it may recompress data resulting in
840
a potential saving in disk space or performance gain.
841
842
The branch *MUST* be on a listable system such as local disk or sftp.
843
"""
844
takes_args = ['branch?']
845
846
def run(self, branch="."):
847
from bzrlib.reconcile import reconcile
848
dir = bzrlib.bzrdir.BzrDir.open(branch)
849
reconcile(dir)
850
851
852
class cmd_revision_history(Command):
853
"""Display list of revision ids on this branch."""
854
hidden = True
855
@display_command
856
def run(self):
857
branch = WorkingTree.open_containing(u'.')[0].branch
858
for patchid in branch.revision_history():
859
print patchid
860
861
862
class cmd_ancestry(Command):
863
"""List all revisions merged into this branch."""
864
hidden = True
865
@display_command
866
def run(self):
867
tree = WorkingTree.open_containing(u'.')[0]
868
b = tree.branch
869
# FIXME. should be tree.last_revision
870
for revision_id in b.repository.get_ancestry(b.last_revision()):
871
print revision_id
872
873
874
class cmd_init(Command):
875
"""Make a directory into a versioned branch.
876
877
Use this to create an empty branch, or before importing an
878
existing project.
879
880
Recipe for importing a tree of files:
881
cd ~/project
882
bzr init
883
bzr add .
884
bzr status
885
bzr commit -m 'imported project'
886
"""
887
takes_args = ['location?']
888
takes_options = [
889
Option('format',
890
help='Create a specific format rather than the'
891
' current default format. Currently this '
892
' option only accepts "metadir"',
893
type=get_format_type),
894
]
895
def run(self, location=None, format=None):
896
from bzrlib.branch import Branch
897
if location is None:
898
location = u'.'
899
else:
900
# The path has to exist to initialize a
901
# branch inside of it.
902
# Just using os.mkdir, since I don't
903
# believe that we want to create a bunch of
904
# locations if the user supplies an extended path
905
if not os.path.exists(location):
906
os.mkdir(location)
907
bzrdir.BzrDir.create_branch_convenience(location, format=format)
908
909
910
class cmd_init_repository(Command):
911
"""Create a shared repository to hold branches.
912
913
New branches created under the repository directory will store their revisions
914
in the repository, not in the branch directory, if the branch format supports
915
shared storage.
916
917
example:
918
bzr init-repo repo
919
bzr init --format=metadir repo/trunk
920
cd repo/trunk
921
(add files here)
922
"""
923
takes_args = ["location"]
924
takes_options = [Option('format',
925
help='Use a specific format rather than the'
926
' current default format. Currently this'
927
' option only accepts "metadir" and "knit"'
928
' WARNING: the knit format is currently unstable'
929
' and only for experimental use.',
930
type=get_format_type),
931
Option('trees',
932
help='Allows branches in repository to have'
933
' a working tree')]
934
aliases = ["init-repo"]
935
def run(self, location, format=None, trees=False):
936
from bzrlib.bzrdir import BzrDirMetaFormat1
937
from bzrlib.transport import get_transport
938
if format is None:
939
format = BzrDirMetaFormat1()
940
transport = get_transport(location)
941
if not transport.has('.'):
942
transport.mkdir('')
943
newdir = format.initialize_on_transport(transport)
944
repo = newdir.create_repository(shared=True)
945
repo.set_make_working_trees(trees)
946
947
948
class cmd_diff(Command):
949
"""Show differences in working tree.
950
951
If files are listed, only the changes in those files are listed.
952
Otherwise, all changes for the tree are listed.
953
954
examples:
955
bzr diff
956
bzr diff -r1
957
bzr diff -r1..2
958
"""
959
# TODO: Allow diff across branches.
960
# TODO: Option to use external diff command; could be GNU diff, wdiff,
961
# or a graphical diff.
962
963
# TODO: Python difflib is not exactly the same as unidiff; should
964
# either fix it up or prefer to use an external diff.
965
966
# TODO: If a directory is given, diff everything under that.
967
968
# TODO: Selected-file diff is inefficient and doesn't show you
969
# deleted files.
970
971
# TODO: This probably handles non-Unix newlines poorly.
972
973
takes_args = ['file*']
974
takes_options = ['revision', 'diff-options']
975
aliases = ['di', 'dif']
976
977
@display_command
978
def run(self, revision=None, file_list=None, diff_options=None):
979
from bzrlib.diff import diff_cmd_helper, show_diff_trees
980
try:
981
tree1, file_list = internal_tree_files(file_list)
982
tree2 = None
983
b = None
984
b2 = None
985
except FileInWrongBranch:
986
if len(file_list) != 2:
987
raise BzrCommandError("Files are in different branches")
988
989
tree1, file1 = WorkingTree.open_containing(file_list[0])
990
tree2, file2 = WorkingTree.open_containing(file_list[1])
991
if file1 != "" or file2 != "":
992
# FIXME diff those two files. rbc 20051123
993
raise BzrCommandError("Files are in different branches")
994
file_list = None
995
if revision is not None:
996
if tree2 is not None:
997
raise BzrCommandError("Can't specify -r with two branches")
998
if (len(revision) == 1) or (revision[1].spec is None):
999
return diff_cmd_helper(tree1, file_list, diff_options,
1000
revision[0])
1001
elif len(revision) == 2:
1002
return diff_cmd_helper(tree1, file_list, diff_options,
1003
revision[0], revision[1])
1004
else:
1005
raise BzrCommandError('bzr diff --revision takes exactly one or two revision identifiers')
1006
else:
1007
if tree2 is not None:
1008
return show_diff_trees(tree1, tree2, sys.stdout,
1009
specific_files=file_list,
1010
external_diff_options=diff_options)
1011
else:
1012
return diff_cmd_helper(tree1, file_list, diff_options)
1013
1014
1015
class cmd_deleted(Command):
1016
"""List files deleted in the working tree.
1017
"""
1018
# TODO: Show files deleted since a previous revision, or
1019
# between two revisions.
1020
# TODO: Much more efficient way to do this: read in new
1021
# directories with readdir, rather than stating each one. Same
1022
# level of effort but possibly much less IO. (Or possibly not,
1023
# if the directories are very large...)
1024
@display_command
1025
def run(self, show_ids=False):
1026
tree = WorkingTree.open_containing(u'.')[0]
1027
old = tree.basis_tree()
1028
for path, ie in old.inventory.iter_entries():
1029
if not tree.has_id(ie.file_id):
1030
if show_ids:
1031
print '%-50s %s' % (path, ie.file_id)
1032
else:
1033
print path
1034
1035
1036
class cmd_modified(Command):
1037
"""List files modified in working tree."""
1038
hidden = True
1039
@display_command
1040
def run(self):
1041
from bzrlib.delta import compare_trees
1042
1043
tree = WorkingTree.open_containing(u'.')[0]
1044
td = compare_trees(tree.basis_tree(), tree)
1045
1046
for path, id, kind, text_modified, meta_modified in td.modified:
1047
print path
1048
1049
1050
1051
class cmd_added(Command):
1052
"""List files added in working tree."""
1053
hidden = True
1054
@display_command
1055
def run(self):
1056
wt = WorkingTree.open_containing(u'.')[0]
1057
basis_inv = wt.basis_tree().inventory
1058
inv = wt.inventory
1059
for file_id in inv:
1060
if file_id in basis_inv:
1061
continue
1062
path = inv.id2path(file_id)
1063
if not os.access(bzrlib.osutils.abspath(path), os.F_OK):
1064
continue
1065
print path
1066
1067
1068
1069
class cmd_root(Command):
1070
"""Show the tree root directory.
1071
1072
The root is the nearest enclosing directory with a .bzr control
1073
directory."""
1074
takes_args = ['filename?']
1075
@display_command
1076
def run(self, filename=None):
1077
"""Print the branch root."""
1078
tree = WorkingTree.open_containing(filename)[0]
1079
print tree.basedir
1080
1081
1082
class cmd_log(Command):
1083
"""Show log of a branch, file, or directory.
1084
1085
By default show the log of the branch containing the working directory.
1086
1087
To request a range of logs, you can use the command -r begin..end
1088
-r revision requests a specific revision, -r ..end or -r begin.. are
1089
also valid.
1090
1091
examples:
1092
bzr log
1093
bzr log foo.c
1094
bzr log -r -10.. http://server/branch
1095
"""
1096
1097
# TODO: Make --revision support uuid: and hash: [future tag:] notation.
1098
1099
takes_args = ['location?']
1100
takes_options = [Option('forward',
1101
help='show from oldest to newest'),
1102
'timezone',
1103
Option('verbose',
1104
help='show files changed in each revision'),
1105
'show-ids', 'revision',
1106
'log-format',
1107
'line', 'long',
1108
Option('message',
1109
help='show revisions whose message matches this regexp',
1110
type=str),
1111
'short',
1112
]
1113
@display_command
1114
def run(self, location=None, timezone='original',
1115
verbose=False,
1116
show_ids=False,
1117
forward=False,
1118
revision=None,
1119
log_format=None,
1120
message=None,
1121
long=False,
1122
short=False,
1123
line=False):
1124
from bzrlib.log import log_formatter, show_log
1125
import codecs
1126
assert message is None or isinstance(message, basestring), \
1127
"invalid message argument %r" % message
1128
direction = (forward and 'forward') or 'reverse'
1129
1130
# log everything
1131
file_id = None
1132
if location:
1133
# find the file id to log:
1134
1135
dir, fp = bzrdir.BzrDir.open_containing(location)
1136
b = dir.open_branch()
1137
if fp != '':
1138
try:
1139
# might be a tree:
1140
inv = dir.open_workingtree().inventory
1141
except (errors.NotBranchError, errors.NotLocalUrl):
1142
# either no tree, or is remote.
1143
inv = b.basis_tree().inventory
1144
file_id = inv.path2id(fp)
1145
else:
1146
# local dir only
1147
# FIXME ? log the current subdir only RBC 20060203
1148
dir, relpath = bzrdir.BzrDir.open_containing('.')
1149
b = dir.open_branch()
1150
1151
if revision is None:
1152
rev1 = None
1153
rev2 = None
1154
elif len(revision) == 1:
1155
rev1 = rev2 = revision[0].in_history(b).revno
1156
elif len(revision) == 2:
1157
if revision[0].spec is None:
1158
# missing begin-range means first revision
1159
rev1 = 1
1160
else:
1161
rev1 = revision[0].in_history(b).revno
1162
1163
if revision[1].spec is None:
1164
# missing end-range means last known revision
1165
rev2 = b.revno()
1166
else:
1167
rev2 = revision[1].in_history(b).revno
1168
else:
1169
raise BzrCommandError('bzr log --revision takes one or two values.')
1170
1171
# By this point, the revision numbers are converted to the +ve
1172
# form if they were supplied in the -ve form, so we can do
1173
# this comparison in relative safety
1174
if rev1 > rev2:
1175
(rev2, rev1) = (rev1, rev2)
1176
1177
mutter('encoding log as %r', bzrlib.user_encoding)
1178
1179
# use 'replace' so that we don't abort if trying to write out
1180
# in e.g. the default C locale.
1181
outf = codecs.getwriter(bzrlib.user_encoding)(sys.stdout, errors='replace')
1182
1183
if (log_format == None):
1184
default = bzrlib.config.BranchConfig(b).log_format()
1185
log_format = get_log_format(long=long, short=short, line=line, default=default)
1186
1187
lf = log_formatter(log_format,
1188
show_ids=show_ids,
1189
to_file=outf,
1190
show_timezone=timezone)
1191
1192
show_log(b,
1193
lf,
1194
file_id,
1195
verbose=verbose,
1196
direction=direction,
1197
start_revision=rev1,
1198
end_revision=rev2,
1199
search=message)
1200
1201
1202
def get_log_format(long=False, short=False, line=False, default='long'):
1203
log_format = default
1204
if long:
1205
log_format = 'long'
1206
if short:
1207
log_format = 'short'
1208
if line:
1209
log_format = 'line'
1210
return log_format
1211
1212
1213
class cmd_touching_revisions(Command):
1214
"""Return revision-ids which affected a particular file.
1215
1216
A more user-friendly interface is "bzr log FILE"."""
1217
hidden = True
1218
takes_args = ["filename"]
1219
@display_command
1220
def run(self, filename):
1221
tree, relpath = WorkingTree.open_containing(filename)
1222
b = tree.branch
1223
inv = tree.read_working_inventory()
1224
file_id = inv.path2id(relpath)
1225
for revno, revision_id, what in bzrlib.log.find_touching_revisions(b, file_id):
1226
print "%6d %s" % (revno, what)
1227
1228
1229
class cmd_ls(Command):
1230
"""List files in a tree.
1231
"""
1232
# TODO: Take a revision or remote path and list that tree instead.
1233
hidden = True
1234
takes_options = ['verbose', 'revision',
1235
Option('non-recursive',
1236
help='don\'t recurse into sub-directories'),
1237
Option('from-root',
1238
help='Print all paths from the root of the branch.'),
1239
Option('unknown', help='Print unknown files'),
1240
Option('versioned', help='Print versioned files'),
1241
Option('ignored', help='Print ignored files'),
1242
1243
Option('null', help='Null separate the files'),
1244
]
1245
@display_command
1246
def run(self, revision=None, verbose=False,
1247
non_recursive=False, from_root=False,
1248
unknown=False, versioned=False, ignored=False,
1249
null=False):
1250
1251
if verbose and null:
1252
raise BzrCommandError('Cannot set both --verbose and --null')
1253
all = not (unknown or versioned or ignored)
1254
1255
selection = {'I':ignored, '?':unknown, 'V':versioned}
1256
1257
tree, relpath = WorkingTree.open_containing(u'.')
1258
if from_root:
1259
relpath = u''
1260
elif relpath:
1261
relpath += '/'
1262
if revision is not None:
1263
tree = tree.branch.repository.revision_tree(
1264
revision[0].in_history(tree.branch).rev_id)
1265
for fp, fc, kind, fid, entry in tree.list_files():
1266
if fp.startswith(relpath):
1267
fp = fp[len(relpath):]
1268
if non_recursive and '/' in fp:
1269
continue
1270
if not all and not selection[fc]:
1271
continue
1272
if verbose:
1273
kindch = entry.kind_character()
1274
print '%-8s %s%s' % (fc, fp, kindch)
1275
elif null:
1276
sys.stdout.write(fp)
1277
sys.stdout.write('\0')
1278
sys.stdout.flush()
1279
else:
1280
print fp
1281
1282
1283
class cmd_unknowns(Command):
1284
"""List unknown files."""
1285
@display_command
1286
def run(self):
1287
from bzrlib.osutils import quotefn
1288
for f in WorkingTree.open_containing(u'.')[0].unknowns():
1289
print quotefn(f)
1290
1291
1292
class cmd_ignore(Command):
1293
"""Ignore a command or pattern.
1294
1295
To remove patterns from the ignore list, edit the .bzrignore file.
1296
1297
If the pattern contains a slash, it is compared to the whole path
1298
from the branch root. Otherwise, it is compared to only the last
1299
component of the path. To match a file only in the root directory,
1300
prepend './'.
1301
1302
Ignore patterns are case-insensitive on case-insensitive systems.
1303
1304
Note: wildcards must be quoted from the shell on Unix.
1305
1306
examples:
1307
bzr ignore ./Makefile
1308
bzr ignore '*.class'
1309
"""
1310
# TODO: Complain if the filename is absolute
1311
takes_args = ['name_pattern']
1312
1313
def run(self, name_pattern):
1314
from bzrlib.atomicfile import AtomicFile
1315
import os.path
1316
1317
tree, relpath = WorkingTree.open_containing(u'.')
1318
ifn = tree.abspath('.bzrignore')
1319
1320
if os.path.exists(ifn):
1321
f = open(ifn, 'rt')
1322
try:
1323
igns = f.read().decode('utf-8')
1324
finally:
1325
f.close()
1326
else:
1327
igns = ''
1328
1329
# TODO: If the file already uses crlf-style termination, maybe
1330
# we should use that for the newly added lines?
1331
1332
if igns and igns[-1] != '\n':
1333
igns += '\n'
1334
igns += name_pattern + '\n'
1335
1336
try:
1337
f = AtomicFile(ifn, 'wt')
1338
f.write(igns.encode('utf-8'))
1339
f.commit()
1340
finally:
1341
f.close()
1342
1343
inv = tree.inventory
1344
if inv.path2id('.bzrignore'):
1345
mutter('.bzrignore is already versioned')
1346
else:
1347
mutter('need to make new .bzrignore file versioned')
1348
tree.add(['.bzrignore'])
1349
1350
1351
class cmd_ignored(Command):
1352
"""List ignored files and the patterns that matched them.
1353
1354
See also: bzr ignore"""
1355
@display_command
1356
def run(self):
1357
tree = WorkingTree.open_containing(u'.')[0]
1358
for path, file_class, kind, file_id, entry in tree.list_files():
1359
if file_class != 'I':
1360
continue
1361
## XXX: Slightly inefficient since this was already calculated
1362
pat = tree.is_ignored(path)
1363
print '%-50s %s' % (path, pat)
1364
1365
1366
class cmd_lookup_revision(Command):
1367
"""Lookup the revision-id from a revision-number
1368
1369
example:
1370
bzr lookup-revision 33
1371
"""
1372
hidden = True
1373
takes_args = ['revno']
1374
1375
@display_command
1376
def run(self, revno):
1377
try:
1378
revno = int(revno)
1379
except ValueError:
1380
raise BzrCommandError("not a valid revision-number: %r" % revno)
1381
1382
print WorkingTree.open_containing(u'.')[0].branch.get_rev_id(revno)
1383
1384
1385
class cmd_export(Command):
1386
"""Export past revision to destination directory.
1387
1388
If no revision is specified this exports the last committed revision.
1389
1390
Format may be an "exporter" name, such as tar, tgz, tbz2. If none is
1391
given, try to find the format with the extension. If no extension
1392
is found exports to a directory (equivalent to --format=dir).
1393
1394
Root may be the top directory for tar, tgz and tbz2 formats. If none
1395
is given, the top directory will be the root name of the file.
1396
1397
Note: export of tree with non-ascii filenames to zip is not supported.
1398
1399
Supported formats Autodetected by extension
1400
----------------- -------------------------
1401
dir -
1402
tar .tar
1403
tbz2 .tar.bz2, .tbz2
1404
tgz .tar.gz, .tgz
1405
zip .zip
1406
"""
1407
takes_args = ['dest']
1408
takes_options = ['revision', 'format', 'root']
1409
def run(self, dest, revision=None, format=None, root=None):
1410
import os.path
1411
from bzrlib.export import export
1412
tree = WorkingTree.open_containing(u'.')[0]
1413
b = tree.branch
1414
if revision is None:
1415
# should be tree.last_revision FIXME
1416
rev_id = b.last_revision()
1417
else:
1418
if len(revision) != 1:
1419
raise BzrError('bzr export --revision takes exactly 1 argument')
1420
rev_id = revision[0].in_history(b).rev_id
1421
t = b.repository.revision_tree(rev_id)
1422
try:
1423
export(t, dest, format, root)
1424
except errors.NoSuchExportFormat, e:
1425
raise BzrCommandError('Unsupported export format: %s' % e.format)
1426
1427
1428
class cmd_cat(Command):
1429
"""Write a file's text from a previous revision."""
1430
1431
takes_options = ['revision']
1432
takes_args = ['filename']
1433
1434
@display_command
1435
def run(self, filename, revision=None):
1436
if revision is not None and len(revision) != 1:
1437
raise BzrCommandError("bzr cat --revision takes exactly one number")
1438
tree = None
1439
try:
1440
tree, relpath = WorkingTree.open_containing(filename)
1441
b = tree.branch
1442
except NotBranchError:
1443
pass
1444
1445
if tree is None:
1446
b, relpath = Branch.open_containing(filename)
1447
if revision is None:
1448
revision_id = b.last_revision()
1449
else:
1450
revision_id = revision[0].in_history(b).rev_id
1451
b.print_file(relpath, revision_id)
1452
1453
1454
class cmd_local_time_offset(Command):
1455
"""Show the offset in seconds from GMT to local time."""
1456
hidden = True
1457
@display_command
1458
def run(self):
1459
print bzrlib.osutils.local_time_offset()
1460
1461
1462
1463
class cmd_commit(Command):
1464
"""Commit changes into a new revision.
1465
1466
If no arguments are given, the entire tree is committed.
1467
1468
If selected files are specified, only changes to those files are
1469
committed. If a directory is specified then the directory and everything
1470
within it is committed.
1471
1472
A selected-file commit may fail in some cases where the committed
1473
tree would be invalid, such as trying to commit a file in a
1474
newly-added directory that is not itself committed.
1475
"""
1476
# TODO: Run hooks on tree to-be-committed, and after commit.
1477
1478
# TODO: Strict commit that fails if there are deleted files.
1479
# (what does "deleted files" mean ??)
1480
1481
# TODO: Give better message for -s, --summary, used by tla people
1482
1483
# XXX: verbose currently does nothing
1484
1485
takes_args = ['selected*']
1486
takes_options = ['message', 'verbose',
1487
Option('unchanged',
1488
help='commit even if nothing has changed'),
1489
Option('file', type=str,
1490
argname='msgfile',
1491
help='file containing commit message'),
1492
Option('strict',
1493
help="refuse to commit if there are unknown "
1494
"files in the working tree."),
1495
Option('local',
1496
help="perform a local only commit in a bound "
1497
"branch. Such commits are not pushed to "
1498
"the master branch until a normal commit "
1499
"is performed."
1500
),
1501
]
1502
aliases = ['ci', 'checkin']
1503
1504
def run(self, message=None, file=None, verbose=True, selected_list=None,
1505
unchanged=False, strict=False, local=False):
1506
from bzrlib.commit import (NullCommitReporter, ReportCommitToLog)
1507
from bzrlib.errors import (PointlessCommit, ConflictsInTree,
1508
StrictCommitFailed)
1509
from bzrlib.msgeditor import edit_commit_message, \
1510
make_commit_message_template
1511
from tempfile import TemporaryFile
1512
import codecs
1513
1514
# TODO: Need a blackbox test for invoking the external editor; may be
1515
# slightly problematic to run this cross-platform.
1516
1517
# TODO: do more checks that the commit will succeed before
1518
# spending the user's valuable time typing a commit message.
1519
#
1520
# TODO: if the commit *does* happen to fail, then save the commit
1521
# message to a temporary file where it can be recovered
1522
tree, selected_list = tree_files(selected_list)
1523
if local and not tree.branch.get_bound_location():
1524
raise errors.LocalRequiresBoundBranch()
1525
if message is None and not file:
1526
template = make_commit_message_template(tree, selected_list)
1527
message = edit_commit_message(template)
1528
if message is None:
1529
raise BzrCommandError("please specify a commit message"
1530
" with either --message or --file")
1531
elif message and file:
1532
raise BzrCommandError("please specify either --message or --file")
1533
1534
if file:
1535
import codecs
1536
message = codecs.open(file, 'rt', bzrlib.user_encoding).read()
1537
1538
if message == "":
1539
raise BzrCommandError("empty commit message specified")
1540
1541
if verbose:
1542
reporter = ReportCommitToLog()
1543
else:
1544
reporter = NullCommitReporter()
1545
1546
try:
1547
tree.commit(message, specific_files=selected_list,
1548
allow_pointless=unchanged, strict=strict, local=local,
1549
reporter=reporter)
1550
except PointlessCommit:
1551
# FIXME: This should really happen before the file is read in;
1552
# perhaps prepare the commit; get the message; then actually commit
1553
raise BzrCommandError("no changes to commit",
1554
["use --unchanged to commit anyhow"])
1555
except ConflictsInTree:
1556
raise BzrCommandError("Conflicts detected in working tree. "
1557
'Use "bzr conflicts" to list, "bzr resolve FILE" to resolve.')
1558
except StrictCommitFailed:
1559
raise BzrCommandError("Commit refused because there are unknown "
1560
"files in the working tree.")
1561
except errors.BoundBranchOutOfDate, e:
1562
raise BzrCommandError(str(e)
1563
+ ' Either unbind, update, or'
1564
' pass --local to commit.')
1565
1566
1567
class cmd_check(Command):
1568
"""Validate consistency of branch history.
1569
1570
This command checks various invariants about the branch storage to
1571
detect data corruption or bzr bugs.
1572
"""
1573
takes_args = ['branch?']
1574
takes_options = ['verbose']
1575
1576
def run(self, branch=None, verbose=False):
1577
from bzrlib.check import check
1578
if branch is None:
1579
tree = WorkingTree.open_containing()[0]
1580
branch = tree.branch
1581
else:
1582
branch = Branch.open(branch)
1583
check(branch, verbose)
1584
1585
1586
class cmd_scan_cache(Command):
1587
hidden = True
1588
def run(self):
1589
from bzrlib.hashcache import HashCache
1590
1591
c = HashCache(u'.')
1592
c.read()
1593
c.scan()
1594
1595
print '%6d stats' % c.stat_count
1596
print '%6d in hashcache' % len(c._cache)
1597
print '%6d files removed from cache' % c.removed_count
1598
print '%6d hashes updated' % c.update_count
1599
print '%6d files changed too recently to cache' % c.danger_count
1600
1601
if c.needs_write:
1602
c.write()
1603
1604
1605
class cmd_upgrade(Command):
1606
"""Upgrade branch storage to current format.
1607
1608
The check command or bzr developers may sometimes advise you to run
1609
this command. When the default format has changed you may also be warned
1610
during other operations to upgrade.
1611
"""
1612
takes_args = ['url?']
1613
takes_options = [
1614
Option('format',
1615
help='Upgrade to a specific format rather than the'
1616
' current default format. Currently this'
1617
' option only accepts "metadir" and "knit".'
1618
' WARNING: the knit format is currently'
1619
' unstable and only for experimental use.',
1620
type=get_format_type),
1621
]
1622
1623
1624
def run(self, url='.', format=None):
1625
from bzrlib.upgrade import upgrade
1626
upgrade(url, format)
1627
1628
1629
class cmd_whoami(Command):
1630
"""Show bzr user id."""
1631
takes_options = ['email']
1632
1633
@display_command
1634
def run(self, email=False):
1635
try:
1636
b = WorkingTree.open_containing(u'.')[0].branch
1637
config = bzrlib.config.BranchConfig(b)
1638
except NotBranchError:
1639
config = bzrlib.config.GlobalConfig()
1640
1641
if email:
1642
print config.user_email()
1643
else:
1644
print config.username()
1645
1646
1647
class cmd_nick(Command):
1648
"""Print or set the branch nickname.
1649
1650
If unset, the tree root directory name is used as the nickname
1651
To print the current nickname, execute with no argument.
1652
"""
1653
takes_args = ['nickname?']
1654
def run(self, nickname=None):
1655
branch = Branch.open_containing(u'.')[0]
1656
if nickname is None:
1657
self.printme(branch)
1658
else:
1659
branch.nick = nickname
1660
1661
@display_command
1662
def printme(self, branch):
1663
print branch.nick
1664
1665
1666
class cmd_selftest(Command):
1667
"""Run internal test suite.
1668
1669
This creates temporary test directories in the working directory,
1670
but not existing data is affected. These directories are deleted
1671
if the tests pass, or left behind to help in debugging if they
1672
fail and --keep-output is specified.
1673
1674
If arguments are given, they are regular expressions that say
1675
which tests should run.
1676
1677
If the global option '--no-plugins' is given, plugins are not loaded
1678
before running the selftests. This has two effects: features provided or
1679
modified by plugins will not be tested, and tests provided by plugins will
1680
not be run.
1681
1682
examples:
1683
bzr selftest ignore
1684
bzr --no-plugins selftest -v
1685
"""
1686
# TODO: --list should give a list of all available tests
1687
1688
# NB: this is used from the class without creating an instance, which is
1689
# why it does not have a self parameter.
1690
def get_transport_type(typestring):
1691
"""Parse and return a transport specifier."""
1692
if typestring == "sftp":
1693
from bzrlib.transport.sftp import SFTPAbsoluteServer
1694
return SFTPAbsoluteServer
1695
if typestring == "memory":
1696
from bzrlib.transport.memory import MemoryServer
1697
return MemoryServer
1698
if typestring == "fakenfs":
1699
from bzrlib.transport.fakenfs import FakeNFSServer
1700
return FakeNFSServer
1701
msg = "No known transport type %s. Supported types are: sftp\n" %\
1702
(typestring)
1703
raise BzrCommandError(msg)
1704
1705
hidden = True
1706
takes_args = ['testspecs*']
1707
takes_options = ['verbose',
1708
Option('one', help='stop when one test fails'),
1709
Option('keep-output',
1710
help='keep output directories when tests fail'),
1711
Option('transport',
1712
help='Use a different transport by default '
1713
'throughout the test suite.',
1714
type=get_transport_type),
1715
]
1716
1717
def run(self, testspecs_list=None, verbose=False, one=False,
1718
keep_output=False, transport=None):
1719
import bzrlib.ui
1720
from bzrlib.tests import selftest
1721
# we don't want progress meters from the tests to go to the
1722
# real output; and we don't want log messages cluttering up
1723
# the real logs.
1724
save_ui = bzrlib.ui.ui_factory
1725
bzrlib.trace.info('running tests...')
1726
try:
1727
bzrlib.ui.ui_factory = bzrlib.ui.SilentUIFactory()
1728
if testspecs_list is not None:
1729
pattern = '|'.join(testspecs_list)
1730
else:
1731
pattern = ".*"
1732
result = selftest(verbose=verbose,
1733
pattern=pattern,
1734
stop_on_failure=one,
1735
keep_output=keep_output,
1736
transport=transport)
1737
if result:
1738
bzrlib.trace.info('tests passed')
1739
else:
1740
bzrlib.trace.info('tests failed')
1741
return int(not result)
1742
finally:
1743
bzrlib.ui.ui_factory = save_ui
1744
1745
1746
def _get_bzr_branch():
1747
"""If bzr is run from a branch, return Branch or None"""
1748
import bzrlib.errors
1749
from bzrlib.branch import Branch
1750
from bzrlib.osutils import abspath
1751
from os.path import dirname
1752
1753
try:
1754
branch = Branch.open(dirname(abspath(dirname(__file__))))
1755
return branch
1756
except bzrlib.errors.BzrError:
1757
return None
1758
1759
1760
def show_version():
1761
print "bzr (bazaar-ng) %s" % bzrlib.__version__
1762
# is bzrlib itself in a branch?
1763
branch = _get_bzr_branch()
1764
if branch:
1765
rh = branch.revision_history()
1766
revno = len(rh)
1767
print " bzr checkout, revision %d" % (revno,)
1768
print " nick: %s" % (branch.nick,)
1769
if rh:
1770
print " revid: %s" % (rh[-1],)
1771
print bzrlib.__copyright__
1772
print "http://bazaar-ng.org/"
1773
print
1774
print "bzr comes with ABSOLUTELY NO WARRANTY. bzr is free software, and"
1775
print "you may use, modify and redistribute it under the terms of the GNU"
1776
print "General Public License version 2 or later."
1777
1778
1779
class cmd_version(Command):
1780
"""Show version of bzr."""
1781
@display_command
1782
def run(self):
1783
show_version()
1784
1785
class cmd_rocks(Command):
1786
"""Statement of optimism."""
1787
hidden = True
1788
@display_command
1789
def run(self):
1790
print "it sure does!"
1791
1792
1793
class cmd_find_merge_base(Command):
1794
"""Find and print a base revision for merging two branches.
1795
"""
1796
# TODO: Options to specify revisions on either side, as if
1797
# merging only part of the history.
1798
takes_args = ['branch', 'other']
1799
hidden = True
1800
1801
@display_command
1802
def run(self, branch, other):
1803
from bzrlib.revision import common_ancestor, MultipleRevisionSources
1804
1805
branch1 = Branch.open_containing(branch)[0]
1806
branch2 = Branch.open_containing(other)[0]
1807
1808
history_1 = branch1.revision_history()
1809
history_2 = branch2.revision_history()
1810
1811
last1 = branch1.last_revision()
1812
last2 = branch2.last_revision()
1813
1814
source = MultipleRevisionSources(branch1.repository,
1815
branch2.repository)
1816
1817
base_rev_id = common_ancestor(last1, last2, source)
1818
1819
print 'merge base is revision %s' % base_rev_id
1820
1821
return
1822
1823
if base_revno is None:
1824
raise bzrlib.errors.UnrelatedBranches()
1825
1826
print ' r%-6d in %s' % (base_revno, branch)
1827
1828
other_revno = branch2.revision_id_to_revno(base_revid)
1829
1830
print ' r%-6d in %s' % (other_revno, other)
1831
1832
1833
1834
class cmd_merge(Command):
1835
"""Perform a three-way merge.
1836
1837
The branch is the branch you will merge from. By default, it will
1838
merge the latest revision. If you specify a revision, that
1839
revision will be merged. If you specify two revisions, the first
1840
will be used as a BASE, and the second one as OTHER. Revision
1841
numbers are always relative to the specified branch.
1842
1843
By default, bzr will try to merge in all new work from the other
1844
branch, automatically determining an appropriate base. If this
1845
fails, you may need to give an explicit base.
1846
1847
Merge will do its best to combine the changes in two branches, but there
1848
are some kinds of problems only a human can fix. When it encounters those,
1849
it will mark a conflict. A conflict means that you need to fix something,
1850
before you should commit.
1851
1852
Use bzr resolve when you have fixed a problem. See also bzr conflicts.
1853
1854
Examples:
1855
1856
To merge the latest revision from bzr.dev
1857
bzr merge ../bzr.dev
1858
1859
To merge changes up to and including revision 82 from bzr.dev
1860
bzr merge -r 82 ../bzr.dev
1861
1862
To merge the changes introduced by 82, without previous changes:
1863
bzr merge -r 81..82 ../bzr.dev
1864
1865
merge refuses to run if there are any uncommitted changes, unless
1866
--force is given.
1867
"""
1868
takes_args = ['branch?']
1869
takes_options = ['revision', 'force', 'merge-type', 'reprocess',
1870
Option('show-base', help="Show base revision text in "
1871
"conflicts")]
1872
1873
def run(self, branch=None, revision=None, force=False, merge_type=None,
1874
show_base=False, reprocess=False):
1875
if merge_type is None:
1876
merge_type = Merge3Merger
1877
if branch is None:
1878
branch = WorkingTree.open_containing(u'.')[0].branch.get_parent()
1879
if branch is None:
1880
raise BzrCommandError("No merge location known or specified.")
1881
else:
1882
print "Using saved location: %s" % branch
1883
if revision is None or len(revision) < 1:
1884
base = [None, None]
1885
other = [branch, -1]
1886
other_branch, path = Branch.open_containing(branch)
1887
else:
1888
if len(revision) == 1:
1889
base = [None, None]
1890
other_branch, path = Branch.open_containing(branch)
1891
revno = revision[0].in_history(other_branch).revno
1892
other = [branch, revno]
1893
else:
1894
assert len(revision) == 2
1895
if None in revision:
1896
raise BzrCommandError(
1897
"Merge doesn't permit that revision specifier.")
1898
b, path = Branch.open_containing(branch)
1899
1900
base = [branch, revision[0].in_history(b).revno]
1901
other = [branch, revision[1].in_history(b).revno]
1902
if path != "":
1903
interesting_files = [path]
1904
else:
1905
interesting_files = None
1906
pb = bzrlib.ui.ui_factory.nested_progress_bar()
1907
try:
1908
try:
1909
conflict_count = merge(other, base, check_clean=(not force),
1910
merge_type=merge_type,
1911
reprocess=reprocess,
1912
show_base=show_base,
1913
pb=pb, file_list=interesting_files)
1914
finally:
1915
pb.finished()
1916
if conflict_count != 0:
1917
return 1
1918
else:
1919
return 0
1920
except bzrlib.errors.AmbiguousBase, e:
1921
m = ("sorry, bzr can't determine the right merge base yet\n"
1922
"candidates are:\n "
1923
+ "\n ".join(e.bases)
1924
+ "\n"
1925
"please specify an explicit base with -r,\n"
1926
"and (if you want) report this to the bzr developers\n")
1927
log_error(m)
1928
1929
1930
class cmd_remerge(Command):
1931
"""Redo a merge.
1932
"""
1933
takes_args = ['file*']
1934
takes_options = ['merge-type', 'reprocess',
1935
Option('show-base', help="Show base revision text in "
1936
"conflicts")]
1937
1938
def run(self, file_list=None, merge_type=None, show_base=False,
1939
reprocess=False):
1940
from bzrlib.merge import merge_inner, transform_tree
1941
if merge_type is None:
1942
merge_type = Merge3Merger
1943
tree, file_list = tree_files(file_list)
1944
tree.lock_write()
1945
try:
1946
pending_merges = tree.pending_merges()
1947
if len(pending_merges) != 1:
1948
raise BzrCommandError("Sorry, remerge only works after normal"
1949
+ " merges. Not cherrypicking or"
1950
+ "multi-merges.")
1951
repository = tree.branch.repository
1952
base_revision = common_ancestor(tree.branch.last_revision(),
1953
pending_merges[0], repository)
1954
base_tree = repository.revision_tree(base_revision)
1955
other_tree = repository.revision_tree(pending_merges[0])
1956
interesting_ids = None
1957
if file_list is not None:
1958
interesting_ids = set()
1959
for filename in file_list:
1960
file_id = tree.path2id(filename)
1961
if file_id is None:
1962
raise NotVersionedError(filename)
1963
interesting_ids.add(file_id)
1964
if tree.kind(file_id) != "directory":
1965
continue
1966
1967
for name, ie in tree.inventory.iter_entries(file_id):
1968
interesting_ids.add(ie.file_id)
1969
transform_tree(tree, tree.basis_tree(), interesting_ids)
1970
if file_list is None:
1971
restore_files = list(tree.iter_conflicts())
1972
else:
1973
restore_files = file_list
1974
for filename in restore_files:
1975
try:
1976
restore(tree.abspath(filename))
1977
except NotConflicted:
1978
pass
1979
conflicts = merge_inner(tree.branch, other_tree, base_tree,
1980
this_tree=tree,
1981
interesting_ids = interesting_ids,
1982
other_rev_id=pending_merges[0],
1983
merge_type=merge_type,
1984
show_base=show_base,
1985
reprocess=reprocess)
1986
finally:
1987
tree.unlock()
1988
if conflicts > 0:
1989
return 1
1990
else:
1991
return 0
1992
1993
class cmd_revert(Command):
1994
"""Reverse all changes since the last commit.
1995
1996
Only versioned files are affected. Specify filenames to revert only
1997
those files. By default, any files that are changed will be backed up
1998
first. Backup files have a '~' appended to their name.
1999
"""
2000
takes_options = ['revision', 'no-backup']
2001
takes_args = ['file*']
2002
aliases = ['merge-revert']
2003
2004
def run(self, revision=None, no_backup=False, file_list=None):
2005
from bzrlib.commands import parse_spec
2006
if file_list is not None:
2007
if len(file_list) == 0:
2008
raise BzrCommandError("No files specified")
2009
else:
2010
file_list = []
2011
2012
tree, file_list = tree_files(file_list)
2013
if revision is None:
2014
# FIXME should be tree.last_revision
2015
rev_id = tree.last_revision()
2016
elif len(revision) != 1:
2017
raise BzrCommandError('bzr revert --revision takes exactly 1 argument')
2018
else:
2019
rev_id = revision[0].in_history(tree.branch).rev_id
2020
pb = bzrlib.ui.ui_factory.nested_progress_bar()
2021
try:
2022
tree.revert(file_list,
2023
tree.branch.repository.revision_tree(rev_id),
2024
not no_backup, pb)
2025
finally:
2026
pb.finished()
2027
2028
2029
class cmd_assert_fail(Command):
2030
"""Test reporting of assertion failures"""
2031
hidden = True
2032
def run(self):
2033
assert False, "always fails"
2034
2035
2036
class cmd_help(Command):
2037
"""Show help on a command or other topic.
2038
2039
For a list of all available commands, say 'bzr help commands'."""
2040
takes_options = [Option('long', 'show help on all commands')]
2041
takes_args = ['topic?']
2042
aliases = ['?', '--help', '-?', '-h']
2043
2044
@display_command
2045
def run(self, topic=None, long=False):
2046
import help
2047
if topic is None and long:
2048
topic = "commands"
2049
help.help(topic)
2050
2051
2052
class cmd_shell_complete(Command):
2053
"""Show appropriate completions for context.
2054
2055
For a list of all available commands, say 'bzr shell-complete'."""
2056
takes_args = ['context?']
2057
aliases = ['s-c']
2058
hidden = True
2059
2060
@display_command
2061
def run(self, context=None):
2062
import shellcomplete
2063
shellcomplete.shellcomplete(context)
2064
2065
2066
class cmd_fetch(Command):
2067
"""Copy in history from another branch but don't merge it.
2068
2069
This is an internal method used for pull and merge."""
2070
hidden = True
2071
takes_args = ['from_branch', 'to_branch']
2072
def run(self, from_branch, to_branch):
2073
from bzrlib.fetch import Fetcher
2074
from bzrlib.branch import Branch
2075
from_b = Branch.open(from_branch)
2076
to_b = Branch.open(to_branch)
2077
Fetcher(to_b, from_b)
2078
2079
2080
class cmd_missing(Command):
2081
"""Show unmerged/unpulled revisions between two branches.
2082
2083
OTHER_BRANCH may be local or remote."""
2084
takes_args = ['other_branch?']
2085
takes_options = [Option('reverse', 'Reverse the order of revisions'),
2086
Option('mine-only',
2087
'Display changes in the local branch only'),
2088
Option('theirs-only',
2089
'Display changes in the remote branch only'),
2090
'log-format',
2091
'line',
2092
'long',
2093
'short',
2094
'show-ids',
2095
'verbose'
2096
]
2097
2098
def run(self, other_branch=None, reverse=False, mine_only=False,
2099
theirs_only=False, log_format=None, long=False, short=False, line=False,
2100
show_ids=False, verbose=False):
2101
from bzrlib.missing import find_unmerged, iter_log_data
2102
from bzrlib.log import log_formatter
2103
local_branch = bzrlib.branch.Branch.open_containing(u".")[0]
2104
parent = local_branch.get_parent()
2105
if other_branch is None:
2106
other_branch = parent
2107
if other_branch is None:
2108
raise BzrCommandError("No missing location known or specified.")
2109
print "Using last location: " + local_branch.get_parent()
2110
remote_branch = bzrlib.branch.Branch.open(other_branch)
2111
local_branch.lock_write()
2112
if remote_branch.base == local_branch.base:
2113
remote_branch = local_branch
2114
try:
2115
remote_branch.lock_read()
2116
try:
2117
local_extra, remote_extra = find_unmerged(local_branch, remote_branch)
2118
if (log_format == None):
2119
default = bzrlib.config.BranchConfig(local_branch).log_format()
2120
log_format = get_log_format(long=long, short=short, line=line, default=default)
2121
lf = log_formatter(log_format, sys.stdout,
2122
show_ids=show_ids,
2123
show_timezone='original')
2124
if reverse is False:
2125
local_extra.reverse()
2126
remote_extra.reverse()
2127
if local_extra and not theirs_only:
2128
print "You have %d extra revision(s):" % len(local_extra)
2129
for data in iter_log_data(local_extra, local_branch.repository,
2130
verbose):
2131
lf.show(*data)
2132
printed_local = True
2133
else:
2134
printed_local = False
2135
if remote_extra and not mine_only:
2136
if printed_local is True:
2137
print "\n\n"
2138
print "You are missing %d revision(s):" % len(remote_extra)
2139
for data in iter_log_data(remote_extra, remote_branch.repository,
2140
verbose):
2141
lf.show(*data)
2142
if not remote_extra and not local_extra:
2143
status_code = 0
2144
print "Branches are up to date."
2145
else:
2146
status_code = 1
2147
if parent is None and other_branch is not None:
2148
local_branch.set_parent(other_branch)
2149
return status_code
2150
finally:
2151
local_branch.unlock()
2152
finally:
2153
remote_branch.unlock()
2154
2155
2156
class cmd_plugins(Command):
2157
"""List plugins"""
2158
hidden = True
2159
@display_command
2160
def run(self):
2161
import bzrlib.plugin
2162
from inspect import getdoc
2163
for name, plugin in bzrlib.plugin.all_plugins().items():
2164
if hasattr(plugin, '__path__'):
2165
print plugin.__path__[0]
2166
elif hasattr(plugin, '__file__'):
2167
print plugin.__file__
2168
else:
2169
print `plugin`
2170
2171
d = getdoc(plugin)
2172
if d:
2173
print '\t', d.split('\n')[0]
2174
2175
2176
class cmd_testament(Command):
2177
"""Show testament (signing-form) of a revision."""
2178
takes_options = ['revision', 'long']
2179
takes_args = ['branch?']
2180
@display_command
2181
def run(self, branch=u'.', revision=None, long=False):
2182
from bzrlib.testament import Testament
2183
b = WorkingTree.open_containing(branch)[0].branch
2184
b.lock_read()
2185
try:
2186
if revision is None:
2187
rev_id = b.last_revision()
2188
else:
2189
rev_id = revision[0].in_history(b).rev_id
2190
t = Testament.from_revision(b.repository, rev_id)
2191
if long:
2192
sys.stdout.writelines(t.as_text_lines())
2193
else:
2194
sys.stdout.write(t.as_short_text())
2195
finally:
2196
b.unlock()
2197
2198
2199
class cmd_annotate(Command):
2200
"""Show the origin of each line in a file.
2201
2202
This prints out the given file with an annotation on the left side
2203
indicating which revision, author and date introduced the change.
2204
2205
If the origin is the same for a run of consecutive lines, it is
2206
shown only at the top, unless the --all option is given.
2207
"""
2208
# TODO: annotate directories; showing when each file was last changed
2209
# TODO: annotate a previous version of a file
2210
# TODO: if the working copy is modified, show annotations on that
2211
# with new uncommitted lines marked
2212
aliases = ['blame', 'praise']
2213
takes_args = ['filename']
2214
takes_options = [Option('all', help='show annotations on all lines'),
2215
Option('long', help='show date in annotations'),
2216
]
2217
2218
@display_command
2219
def run(self, filename, all=False, long=False):
2220
from bzrlib.annotate import annotate_file
2221
tree, relpath = WorkingTree.open_containing(filename)
2222
branch = tree.branch
2223
branch.lock_read()
2224
try:
2225
file_id = tree.inventory.path2id(relpath)
2226
tree = branch.repository.revision_tree(branch.last_revision())
2227
file_version = tree.inventory[file_id].revision
2228
annotate_file(branch, file_version, file_id, long, all, sys.stdout)
2229
finally:
2230
branch.unlock()
2231
2232
2233
class cmd_re_sign(Command):
2234
"""Create a digital signature for an existing revision."""
2235
# TODO be able to replace existing ones.
2236
2237
hidden = True # is this right ?
2238
takes_args = ['revision_id*']
2239
takes_options = ['revision']
2240
2241
def run(self, revision_id_list=None, revision=None):
2242
import bzrlib.config as config
2243
import bzrlib.gpg as gpg
2244
if revision_id_list is not None and revision is not None:
2245
raise BzrCommandError('You can only supply one of revision_id or --revision')
2246
if revision_id_list is None and revision is None:
2247
raise BzrCommandError('You must supply either --revision or a revision_id')
2248
b = WorkingTree.open_containing(u'.')[0].branch
2249
gpg_strategy = gpg.GPGStrategy(config.BranchConfig(b))
2250
if revision_id_list is not None:
2251
for revision_id in revision_id_list:
2252
b.repository.sign_revision(revision_id, gpg_strategy)
2253
elif revision is not None:
2254
if len(revision) == 1:
2255
revno, rev_id = revision[0].in_history(b)
2256
b.repository.sign_revision(rev_id, gpg_strategy)
2257
elif len(revision) == 2:
2258
# are they both on rh- if so we can walk between them
2259
# might be nice to have a range helper for arbitrary
2260
# revision paths. hmm.
2261
from_revno, from_revid = revision[0].in_history(b)
2262
to_revno, to_revid = revision[1].in_history(b)
2263
if to_revid is None:
2264
to_revno = b.revno()
2265
if from_revno is None or to_revno is None:
2266
raise BzrCommandError('Cannot sign a range of non-revision-history revisions')
2267
for revno in range(from_revno, to_revno + 1):
2268
b.repository.sign_revision(b.get_rev_id(revno),
2269
gpg_strategy)
2270
else:
2271
raise BzrCommandError('Please supply either one revision, or a range.')
2272
2273
2274
class cmd_bind(Command):
2275
"""Bind the current branch to a master branch.
2276
2277
After binding, commits must succeed on the master branch
2278
before they are executed on the local one.
2279
"""
2280
2281
takes_args = ['location']
2282
takes_options = []
2283
2284
def run(self, location=None):
2285
b, relpath = Branch.open_containing(u'.')
2286
b_other = Branch.open(location)
2287
try:
2288
b.bind(b_other)
2289
except DivergedBranches:
2290
raise BzrCommandError('These branches have diverged.'
2291
' Try merging, and then bind again.')
2292
2293
2294
class cmd_unbind(Command):
2295
"""Bind the current branch to its parent.
2296
2297
After unbinding, the local branch is considered independent.
2298
"""
2299
2300
takes_args = []
2301
takes_options = []
2302
2303
def run(self):
2304
b, relpath = Branch.open_containing(u'.')
2305
if not b.unbind():
2306
raise BzrCommandError('Local branch is not bound')
2307
2308
2309
class cmd_uncommit(bzrlib.commands.Command):
2310
"""Remove the last committed revision.
2311
2312
By supplying the --all flag, it will not only remove the entry
2313
from revision_history, but also remove all of the entries in the
2314
stores.
2315
2316
--verbose will print out what is being removed.
2317
--dry-run will go through all the motions, but not actually
2318
remove anything.
2319
2320
In the future, uncommit will create a changeset, which can then
2321
be re-applied.
2322
"""
2323
2324
# TODO: jam 20060108 Add an option to allow uncommit to remove
2325
# unreferenced information in 'branch-as-repostory' branches.
2326
# TODO: jam 20060108 Add the ability for uncommit to remove unreferenced
2327
# information in shared branches as well.
2328
takes_options = ['verbose', 'revision',
2329
Option('dry-run', help='Don\'t actually make changes'),
2330
Option('force', help='Say yes to all questions.')]
2331
takes_args = ['location?']
2332
aliases = []
2333
2334
def run(self, location=None,
2335
dry_run=False, verbose=False,
2336
revision=None, force=False):
2337
from bzrlib.branch import Branch
2338
from bzrlib.log import log_formatter
2339
import sys
2340
from bzrlib.uncommit import uncommit
2341
2342
if location is None:
2343
location = u'.'
2344
control, relpath = bzrdir.BzrDir.open_containing(location)
2345
try:
2346
tree = control.open_workingtree()
2347
b = tree.branch
2348
except (errors.NoWorkingTree, errors.NotLocalUrl):
2349
tree = None
2350
b = control.open_branch()
2351
2352
if revision is None:
2353
revno = b.revno()
2354
rev_id = b.last_revision()
2355
else:
2356
revno, rev_id = revision[0].in_history(b)
2357
if rev_id is None:
2358
print 'No revisions to uncommit.'
2359
2360
for r in range(revno, b.revno()+1):
2361
rev_id = b.get_rev_id(r)
2362
lf = log_formatter('short', to_file=sys.stdout,show_timezone='original')
2363
lf.show(r, b.repository.get_revision(rev_id), None)
2364
2365
if dry_run:
2366
print 'Dry-run, pretending to remove the above revisions.'
2367
if not force:
2368
val = raw_input('Press <enter> to continue')
2369
else:
2370
print 'The above revision(s) will be removed.'
2371
if not force:
2372
val = raw_input('Are you sure [y/N]? ')
2373
if val.lower() not in ('y', 'yes'):
2374
print 'Canceled'
2375
return 0
2376
2377
uncommit(b, tree=tree, dry_run=dry_run, verbose=verbose,
2378
revno=revno)
2379
2380
2381
class cmd_break_lock(Command):
2382
"""Break a dead lock on a repository, branch or working directory.
2383
2384
CAUTION: Locks should only be broken when you are sure that the process
2385
holding the lock has been stopped.
2386
2387
example:
2388
bzr break-lock .
2389
"""
2390
takes_args = ['location']
2391
takes_options = [Option('show',
2392
help="just show information on the lock, " \
2393
"don't break it"),
2394
]
2395
def run(self, location, show=False):
2396
raise NotImplementedError("sorry, break-lock is not complete yet; "
2397
"you can remove the 'held' directory manually to break the lock")
2398
2399
2400
# command-line interpretation helper for merge-related commands
2401
def merge(other_revision, base_revision,
2402
check_clean=True, ignore_zero=False,
2403
this_dir=None, backup_files=False, merge_type=Merge3Merger,
2404
file_list=None, show_base=False, reprocess=False,
2405
pb=DummyProgress()):
2406
"""Merge changes into a tree.
2407
2408
base_revision
2409
list(path, revno) Base for three-way merge.
2410
If [None, None] then a base will be automatically determined.
2411
other_revision
2412
list(path, revno) Other revision for three-way merge.
2413
this_dir
2414
Directory to merge changes into; '.' by default.
2415
check_clean
2416
If true, this_dir must have no uncommitted changes before the
2417
merge begins.
2418
ignore_zero - If true, suppress the "zero conflicts" message when
2419
there are no conflicts; should be set when doing something we expect
2420
to complete perfectly.
2421
file_list - If supplied, merge only changes to selected files.
2422
2423
All available ancestors of other_revision and base_revision are
2424
automatically pulled into the branch.
2425
2426
The revno may be -1 to indicate the last revision on the branch, which is
2427
the typical case.
2428
2429
This function is intended for use from the command line; programmatic
2430
clients might prefer to call merge.merge_inner(), which has less magic
2431
behavior.
2432
"""
2433
from bzrlib.merge import Merger
2434
if this_dir is None:
2435
this_dir = u'.'
2436
this_tree = WorkingTree.open_containing(this_dir)[0]
2437
if show_base and not merge_type is Merge3Merger:
2438
raise BzrCommandError("Show-base is not supported for this merge"
2439
" type. %s" % merge_type)
2440
if reprocess and not merge_type is Merge3Merger:
2441
raise BzrCommandError("Reprocess is not supported for this merge"
2442
" type. %s" % merge_type)
2443
if reprocess and show_base:
2444
raise BzrCommandError("Cannot reprocess and show base.")
2445
try:
2446
merger = Merger(this_tree.branch, this_tree=this_tree, pb=pb)
2447
merger.pp = ProgressPhase("Merge phase", 5, pb)
2448
merger.pp.next_phase()
2449
merger.check_basis(check_clean)
2450
merger.set_other(other_revision)
2451
merger.pp.next_phase()
2452
merger.set_base(base_revision)
2453
if merger.base_rev_id == merger.other_rev_id:
2454
note('Nothing to do.')
2455
return 0
2456
merger.backup_files = backup_files
2457
merger.merge_type = merge_type
2458
merger.set_interesting_files(file_list)
2459
merger.show_base = show_base
2460
merger.reprocess = reprocess
2461
conflicts = merger.do_merge()
2462
if file_list is None:
2463
merger.set_pending()
2464
finally:
2465
pb.clear()
2466
return conflicts
2467
2468
2469
# these get imported and then picked up by the scan for cmd_*
2470
# TODO: Some more consistent way to split command definitions across files;
2471
# we do need to load at least some information about them to know of
2472
# aliases. ideally we would avoid loading the implementation until the
2473
# details were needed.
2474
from bzrlib.conflicts import cmd_resolve, cmd_conflicts, restore
2475
from bzrlib.sign_my_commits import cmd_sign_my_commits
2476
from bzrlib.weave_commands import cmd_weave_list, cmd_weave_join, \
2477
cmd_weave_plan_merge, cmd_weave_merge_text
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0