« back to all changes in this revision
Viewing changes to bzrlib/builtins.py
- browse files at revision 1092.1.27
- compare with another revision
- download diff
- download tarball
- view history from revision 1092.1.27
- Committer: Robert Collins
- Date: 2005-08-25 01:13:32 UTC
- mto: (974.1.50) (1185.1.10) (1092.3.1)
- mto: This revision was merged to the branch mainline in revision 1139.
- Revision ID: robertc@robertcollins.net-20050825011331-6d549d5de7edcec1
two bugfixes to smart_add - do not add paths from nested trees to the parent tree, and do not mutate the user supplied file list
- files added:
- bzrlib/mdiff.py
- files removed:
- BRANCH.TODO
- bzrlib/export
- bzrlib/store
- bzrlib/tests/blackbox
- bzrlib/transport
- bzrlib/ui
- bzrlib/util/configobj
- bzrlib/util/configobj/docs
- files renamed:
- bzr_man.py => bzr-man.py
- contrib/newinventory.py => bzrlib/newinventory.py
- bzrlib/tests/ => bzrlib/selftest/
- bzrlib/tests/blackbox/test_too_much.py => bzrlib/selftest/blackbox.py
- bzrlib/tests/test_plugins.py => bzrlib/selftest/plugins.py
- bzrlib/tests/test_branch.py => bzrlib/selftest/testbranch.py
- bzrlib/tests/test_diff.py => bzrlib/selftest/testdiff.py
- bzrlib/tests/test_hashcache.py => bzrlib/selftest/testhashcache.py
- bzrlib/tests/test_inv.py => bzrlib/selftest/testinv.py
- bzrlib/tests/test_log.py => bzrlib/selftest/testlog.py
- bzrlib/tests/test_merge3.py => bzrlib/selftest/testmerge3.py
- bzrlib/tests/test_revision.py => bzrlib/selftest/testrevision.py
- bzrlib/tests/test_revisionnamespaces.py => bzrlib/selftest/testrevisionnamespaces.py
- bzrlib/tests/test_status.py => bzrlib/selftest/teststatus.py
- bzrlib/tests/blackbox/test_versioning.py => bzrlib/selftest/versioning.py
- bzrlib/tests/test_whitebox.py => bzrlib/selftest/whitebox.py
- bzrlib/store/__init__.py => bzrlib/store.py
- bzrlib/ui/__init__.py => bzrlib/ui.py
- bzrlib/upgrade.py => tools/history2weaves.py
- bzrlib/tests/test_weave.py => tools/testweave.py
- files modified:
- .bzrignore
- bzr *
- setup.py *
added
removed
bzrlib/builtins.py
1
# Copyright (C) 2004, 2005 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
# DO NOT change this to cStringIO - it results in control files
20
# written as UCS4
21
# FIXIT! (Only deal with byte streams OR unicode at any one layer.)
22
# RBC 20051018
23
24
from StringIO import StringIO
25
import sys
26
import os
27
28
import bzrlib
29
from bzrlib import BZRDIR
30
from bzrlib.commands import Command, display_command
31
from bzrlib.branch import Branch
32
from bzrlib.revision import common_ancestor
33
import bzrlib.errors as errors
34
from bzrlib.errors import (BzrError, BzrCheckError, BzrCommandError,
35
NotBranchError, DivergedBranches, NotConflicted,
36
NoSuchFile, NoWorkingTree, FileInWrongBranch)
37
from bzrlib.option import Option
38
from bzrlib.revisionspec import RevisionSpec
39
import bzrlib.trace
40
from bzrlib.trace import mutter, note, log_error, warning, is_quiet
41
from bzrlib.workingtree import WorkingTree
42
from bzrlib.log import show_one_log
43
44
45
def tree_files(file_list, default_branch=u'.'):
46
try:
47
return internal_tree_files(file_list, default_branch)
48
except FileInWrongBranch, e:
49
raise BzrCommandError("%s is not in the same branch as %s" %
50
(e.path, file_list[0]))
51
52
def internal_tree_files(file_list, default_branch=u'.'):
53
"""\
54
Return a branch and list of branch-relative paths.
55
If supplied file_list is empty or None, the branch default will be used,
56
and returned file_list will match the original.
57
"""
58
if file_list is None or len(file_list) == 0:
59
return WorkingTree.open_containing(default_branch)[0], file_list
60
tree = WorkingTree.open_containing(file_list[0])[0]
61
new_list = []
62
for filename in file_list:
63
try:
64
new_list.append(tree.relpath(filename))
65
except errors.PathNotChild:
66
raise FileInWrongBranch(tree.branch, filename)
67
return tree, new_list
68
69
70
# TODO: Make sure no commands unconditionally use the working directory as a
71
# branch. If a filename argument is used, the first of them should be used to
72
# specify the branch. (Perhaps this can be factored out into some kind of
73
# Argument class, representing a file in a branch, where the first occurrence
74
# opens the branch?)
75
76
class cmd_status(Command):
77
"""Display status summary.
78
79
This reports on versioned and unknown files, reporting them
80
grouped by state. Possible states are:
81
82
added
83
Versioned in the working copy but not in the previous revision.
84
85
removed
86
Versioned in the previous revision but removed or deleted
87
in the working copy.
88
89
renamed
90
Path of this file changed from the previous revision;
91
the text may also have changed. This includes files whose
92
parent directory was renamed.
93
94
modified
95
Text has changed since the previous revision.
96
97
unchanged
98
Nothing about this file has changed since the previous revision.
99
Only shown with --all.
100
101
unknown
102
Not versioned and not matching an ignore pattern.
103
104
To see ignored files use 'bzr ignored'. For details in the
105
changes to file texts, use 'bzr diff'.
106
107
If no arguments are specified, the status of the entire working
108
directory is shown. Otherwise, only the status of the specified
109
files or directories is reported. If a directory is given, status
110
is reported for everything inside that directory.
111
112
If a revision argument is given, the status is calculated against
113
that revision, or between two revisions if two are provided.
114
"""
115
116
# TODO: --no-recurse, --recurse options
117
118
takes_args = ['file*']
119
takes_options = ['all', 'show-ids', 'revision']
120
aliases = ['st', 'stat']
121
122
@display_command
123
def run(self, all=False, show_ids=False, file_list=None, revision=None):
124
tree, file_list = tree_files(file_list)
125
126
from bzrlib.status import show_status
127
show_status(tree.branch, show_unchanged=all, show_ids=show_ids,
128
specific_files=file_list, revision=revision)
129
130
131
class cmd_cat_revision(Command):
132
"""Write out metadata for a revision.
133
134
The revision to print can either be specified by a specific
135
revision identifier, or you can use --revision.
136
"""
137
138
hidden = True
139
takes_args = ['revision_id?']
140
takes_options = ['revision']
141
142
@display_command
143
def run(self, revision_id=None, revision=None):
144
145
if revision_id is not None and revision is not None:
146
raise BzrCommandError('You can only supply one of revision_id or --revision')
147
if revision_id is None and revision is None:
148
raise BzrCommandError('You must supply either --revision or a revision_id')
149
b = WorkingTree.open_containing(u'.')[0].branch
150
if revision_id is not None:
151
sys.stdout.write(b.repository.get_revision_xml(revision_id))
152
elif revision is not None:
153
for rev in revision:
154
if rev is None:
155
raise BzrCommandError('You cannot specify a NULL revision.')
156
revno, rev_id = rev.in_history(b)
157
sys.stdout.write(b.repository.get_revision_xml(rev_id))
158
159
160
class cmd_revno(Command):
161
"""Show current revision number.
162
163
This is equal to the number of revisions on this branch."""
164
takes_args = ['location?']
165
@display_command
166
def run(self, location=u'.'):
167
print Branch.open_containing(location)[0].revno()
168
169
170
class cmd_revision_info(Command):
171
"""Show revision number and revision id for a given revision identifier.
172
"""
173
hidden = True
174
takes_args = ['revision_info*']
175
takes_options = ['revision']
176
@display_command
177
def run(self, revision=None, revision_info_list=[]):
178
179
revs = []
180
if revision is not None:
181
revs.extend(revision)
182
if revision_info_list is not None:
183
for rev in revision_info_list:
184
revs.append(RevisionSpec(rev))
185
if len(revs) == 0:
186
raise BzrCommandError('You must supply a revision identifier')
187
188
b = WorkingTree.open_containing(u'.')[0].branch
189
190
for rev in revs:
191
revinfo = rev.in_history(b)
192
if revinfo.revno is None:
193
print ' %s' % revinfo.rev_id
194
else:
195
print '%4d %s' % (revinfo.revno, revinfo.rev_id)
196
197
198
class cmd_add(Command):
199
"""Add specified files or directories.
200
201
In non-recursive mode, all the named items are added, regardless
202
of whether they were previously ignored. A warning is given if
203
any of the named files are already versioned.
204
205
In recursive mode (the default), files are treated the same way
206
but the behaviour for directories is different. Directories that
207
are already versioned do not give a warning. All directories,
208
whether already versioned or not, are searched for files or
209
subdirectories that are neither versioned or ignored, and these
210
are added. This search proceeds recursively into versioned
211
directories. If no names are given '.' is assumed.
212
213
Therefore simply saying 'bzr add' will version all files that
214
are currently unknown.
215
216
Adding a file whose parent directory is not versioned will
217
implicitly add the parent, and so on up to the root. This means
218
you should never need to explictly add a directory, they'll just
219
get added when you add a file in the directory.
220
221
--dry-run will show which files would be added, but not actually
222
add them.
223
"""
224
takes_args = ['file*']
225
takes_options = ['no-recurse', 'dry-run', 'verbose']
226
227
def run(self, file_list, no_recurse=False, dry_run=False, verbose=False):
228
import bzrlib.add
229
230
if dry_run:
231
if is_quiet():
232
# This is pointless, but I'd rather not raise an error
233
action = bzrlib.add.add_action_null
234
else:
235
action = bzrlib.add.add_action_print
236
elif is_quiet():
237
action = bzrlib.add.add_action_add
238
else:
239
action = bzrlib.add.add_action_add_and_print
240
241
added, ignored = bzrlib.add.smart_add(file_list, not no_recurse,
242
action)
243
if len(ignored) > 0:
244
for glob in sorted(ignored.keys()):
245
match_len = len(ignored[glob])
246
if verbose:
247
for path in ignored[glob]:
248
print "ignored %s matching \"%s\"" % (path, glob)
249
else:
250
print "ignored %d file(s) matching \"%s\"" % (match_len,
251
glob)
252
print "If you wish to add some of these files, please add them"\
253
" by name."
254
255
256
class cmd_mkdir(Command):
257
"""Create a new versioned directory.
258
259
This is equivalent to creating the directory and then adding it.
260
"""
261
takes_args = ['dir+']
262
263
def run(self, dir_list):
264
for d in dir_list:
265
os.mkdir(d)
266
wt, dd = WorkingTree.open_containing(d)
267
wt.add([dd])
268
print 'added', d
269
270
271
class cmd_relpath(Command):
272
"""Show path of a file relative to root"""
273
takes_args = ['filename']
274
hidden = True
275
276
@display_command
277
def run(self, filename):
278
tree, relpath = WorkingTree.open_containing(filename)
279
print relpath
280
281
282
class cmd_inventory(Command):
283
"""Show inventory of the current working copy or a revision.
284
285
It is possible to limit the output to a particular entry
286
type using the --kind option. For example; --kind file.
287
"""
288
takes_options = ['revision', 'show-ids', 'kind']
289
290
@display_command
291
def run(self, revision=None, show_ids=False, kind=None):
292
if kind and kind not in ['file', 'directory', 'symlink']:
293
raise BzrCommandError('invalid kind specified')
294
tree = WorkingTree.open_containing(u'.')[0]
295
if revision is None:
296
inv = tree.read_working_inventory()
297
else:
298
if len(revision) > 1:
299
raise BzrCommandError('bzr inventory --revision takes'
300
' exactly one revision identifier')
301
inv = tree.branch.repository.get_revision_inventory(
302
revision[0].in_history(tree.branch).rev_id)
303
304
for path, entry in inv.entries():
305
if kind and kind != entry.kind:
306
continue
307
if show_ids:
308
print '%-50s %s' % (path, entry.file_id)
309
else:
310
print path
311
312
313
class cmd_move(Command):
314
"""Move files to a different directory.
315
316
examples:
317
bzr move *.txt doc
318
319
The destination must be a versioned directory in the same branch.
320
"""
321
takes_args = ['source$', 'dest']
322
def run(self, source_list, dest):
323
tree, source_list = tree_files(source_list)
324
# TODO: glob expansion on windows?
325
tree.move(source_list, tree.relpath(dest))
326
327
328
class cmd_rename(Command):
329
"""Change the name of an entry.
330
331
examples:
332
bzr rename frob.c frobber.c
333
bzr rename src/frob.c lib/frob.c
334
335
It is an error if the destination name exists.
336
337
See also the 'move' command, which moves files into a different
338
directory without changing their name.
339
"""
340
# TODO: Some way to rename multiple files without invoking
341
# bzr for each one?"""
342
takes_args = ['from_name', 'to_name']
343
344
def run(self, from_name, to_name):
345
tree, (from_name, to_name) = tree_files((from_name, to_name))
346
tree.rename_one(from_name, to_name)
347
348
349
class cmd_mv(Command):
350
"""Move or rename a file.
351
352
usage:
353
bzr mv OLDNAME NEWNAME
354
bzr mv SOURCE... DESTINATION
355
356
If the last argument is a versioned directory, all the other names
357
are moved into it. Otherwise, there must be exactly two arguments
358
and the file is changed to a new name, which must not already exist.
359
360
Files cannot be moved between branches.
361
"""
362
takes_args = ['names*']
363
def run(self, names_list):
364
if len(names_list) < 2:
365
raise BzrCommandError("missing file argument")
366
tree, rel_names = tree_files(names_list)
367
368
if os.path.isdir(names_list[-1]):
369
# move into existing directory
370
for pair in tree.move(rel_names[:-1], rel_names[-1]):
371
print "%s => %s" % pair
372
else:
373
if len(names_list) != 2:
374
raise BzrCommandError('to mv multiple files the destination '
375
'must be a versioned directory')
376
tree.rename_one(rel_names[0], rel_names[1])
377
print "%s => %s" % (rel_names[0], rel_names[1])
378
379
380
class cmd_pull(Command):
381
"""Pull any changes from another branch into the current one.
382
383
If there is no default location set, the first pull will set it. After
384
that, you can omit the location to use the default. To change the
385
default, use --remember.
386
387
This command only works on branches that have not diverged. Branches are
388
considered diverged if both branches have had commits without first
389
pulling from the other.
390
391
If branches have diverged, you can use 'bzr merge' to pull the text changes
392
from one into the other. Once one branch has merged, the other should
393
be able to pull it again.
394
395
If you want to forget your local changes and just update your branch to
396
match the remote one, use --overwrite.
397
"""
398
takes_options = ['remember', 'overwrite', 'verbose']
399
takes_args = ['location?']
400
401
def run(self, location=None, remember=False, overwrite=False, verbose=False):
402
from bzrlib.merge import merge
403
from shutil import rmtree
404
import errno
405
# FIXME: too much stuff is in the command class
406
tree_to = WorkingTree.open_containing(u'.')[0]
407
stored_loc = tree_to.branch.get_parent()
408
if location is None:
409
if stored_loc is None:
410
raise BzrCommandError("No pull location known or specified.")
411
else:
412
print "Using saved location: %s" % stored_loc
413
location = stored_loc
414
415
br_from = Branch.open(location)
416
br_to = tree_to.branch
417
418
old_rh = br_to.revision_history()
419
count = tree_to.pull(br_from, overwrite)
420
421
if br_to.get_parent() is None or remember:
422
br_to.set_parent(location)
423
note('%d revision(s) pulled.' % (count,))
424
425
if verbose:
426
new_rh = tree_to.branch.revision_history()
427
if old_rh != new_rh:
428
# Something changed
429
from bzrlib.log import show_changed_revisions
430
show_changed_revisions(tree_to.branch, old_rh, new_rh)
431
432
433
class cmd_push(Command):
434
"""Push this branch into another branch.
435
436
The remote branch will not have its working tree populated because this
437
is both expensive, and may not be supported on the remote file system.
438
439
Some smart servers or protocols *may* put the working tree in place.
440
441
If there is no default push location set, the first push will set it.
442
After that, you can omit the location to use the default. To change the
443
default, use --remember.
444
445
This command only works on branches that have not diverged. Branches are
446
considered diverged if the branch being pushed to is not an older version
447
of this branch.
448
449
If branches have diverged, you can use 'bzr push --overwrite' to replace
450
the other branch completely.
451
452
If you want to ensure you have the different changes in the other branch,
453
do a merge (see bzr help merge) from the other branch, and commit that
454
before doing a 'push --overwrite'.
455
"""
456
takes_options = ['remember', 'overwrite',
457
Option('create-prefix',
458
help='Create the path leading up to the branch '
459
'if it does not already exist')]
460
takes_args = ['location?']
461
462
def run(self, location=None, remember=False, overwrite=False,
463
create_prefix=False, verbose=False):
464
# FIXME: Way too big! Put this into a function called from the
465
# command.
466
import errno
467
from shutil import rmtree
468
from bzrlib.transport import get_transport
469
470
tree_from = WorkingTree.open_containing(u'.')[0]
471
br_from = tree_from.branch
472
stored_loc = tree_from.branch.get_push_location()
473
if location is None:
474
if stored_loc is None:
475
raise BzrCommandError("No push location known or specified.")
476
else:
477
print "Using saved location: %s" % stored_loc
478
location = stored_loc
479
try:
480
br_to = Branch.open(location)
481
except NotBranchError:
482
# create a branch.
483
transport = get_transport(location).clone('..')
484
if not create_prefix:
485
try:
486
transport.mkdir(transport.relpath(location))
487
except NoSuchFile:
488
raise BzrCommandError("Parent directory of %s "
489
"does not exist." % location)
490
else:
491
current = transport.base
492
needed = [(transport, transport.relpath(location))]
493
while needed:
494
try:
495
transport, relpath = needed[-1]
496
transport.mkdir(relpath)
497
needed.pop()
498
except NoSuchFile:
499
new_transport = transport.clone('..')
500
needed.append((new_transport,
501
new_transport.relpath(transport.base)))
502
if new_transport.base == transport.base:
503
raise BzrCommandError("Could not creeate "
504
"path prefix.")
505
br_to = Branch.initialize(location)
506
old_rh = br_to.revision_history()
507
try:
508
try:
509
tree_to = br_to.working_tree()
510
except NoWorkingTree:
511
# TODO: This should be updated for branches which don't have a
512
# working tree, as opposed to ones where we just couldn't
513
# update the tree.
514
warning('Unable to update the working tree of: %s' % (br_to.base,))
515
count = br_to.pull(br_from, overwrite)
516
else:
517
count = tree_to.pull(br_from, overwrite)
518
except DivergedBranches:
519
raise BzrCommandError("These branches have diverged."
520
" Try a merge then push with overwrite.")
521
if br_from.get_push_location() is None or remember:
522
br_from.set_push_location(location)
523
note('%d revision(s) pushed.' % (count,))
524
525
if verbose:
526
new_rh = br_to.revision_history()
527
if old_rh != new_rh:
528
# Something changed
529
from bzrlib.log import show_changed_revisions
530
show_changed_revisions(br_to, old_rh, new_rh)
531
532
533
class cmd_branch(Command):
534
"""Create a new copy of a branch.
535
536
If the TO_LOCATION is omitted, the last component of the FROM_LOCATION will
537
be used. In other words, "branch ../foo/bar" will attempt to create ./bar.
538
539
To retrieve the branch as of a particular revision, supply the --revision
540
parameter, as in "branch foo/bar -r 5".
541
542
--basis is to speed up branching from remote branches. When specified, it
543
copies all the file-contents, inventory and revision data from the basis
544
branch before copying anything from the remote branch.
545
"""
546
takes_args = ['from_location', 'to_location?']
547
takes_options = ['revision', 'basis']
548
aliases = ['get', 'clone']
549
550
def run(self, from_location, to_location=None, revision=None, basis=None):
551
import errno
552
from shutil import rmtree
553
if revision is None:
554
revision = [None]
555
elif len(revision) > 1:
556
raise BzrCommandError(
557
'bzr branch --revision takes exactly 1 revision value')
558
try:
559
br_from = Branch.open(from_location)
560
except OSError, e:
561
if e.errno == errno.ENOENT:
562
raise BzrCommandError('Source location "%s" does not'
563
' exist.' % to_location)
564
else:
565
raise
566
br_from.lock_read()
567
try:
568
if basis is not None:
569
basis_branch = WorkingTree.open_containing(basis)[0].branch
570
else:
571
basis_branch = None
572
if len(revision) == 1 and revision[0] is not None:
573
revision_id = revision[0].in_history(br_from)[1]
574
else:
575
revision_id = None
576
if to_location is None:
577
to_location = os.path.basename(from_location.rstrip("/\\"))
578
name = None
579
else:
580
name = os.path.basename(to_location) + '\n'
581
try:
582
os.mkdir(to_location)
583
except OSError, e:
584
if e.errno == errno.EEXIST:
585
raise BzrCommandError('Target directory "%s" already'
586
' exists.' % to_location)
587
if e.errno == errno.ENOENT:
588
raise BzrCommandError('Parent of "%s" does not exist.' %
589
to_location)
590
else:
591
raise
592
try:
593
br_from.clone(to_location, revision_id, basis_branch)
594
except bzrlib.errors.NoSuchRevision:
595
rmtree(to_location)
596
msg = "The branch %s has no revision %s." % (from_location, revision[0])
597
raise BzrCommandError(msg)
598
except bzrlib.errors.UnlistableBranch:
599
rmtree(to_location)
600
msg = "The branch %s cannot be used as a --basis"
601
raise BzrCommandError(msg)
602
branch = Branch.open(to_location)
603
if name:
604
name = StringIO(name)
605
branch.lock_write()
606
try:
607
branch.control_files.put_utf8('branch-name', name)
608
finally:
609
branch.unlock()
610
611
note('Branched %d revision(s).' % branch.revno())
612
finally:
613
br_from.unlock()
614
615
616
class cmd_renames(Command):
617
"""Show list of renamed files.
618
"""
619
# TODO: Option to show renames between two historical versions.
620
621
# TODO: Only show renames under dir, rather than in the whole branch.
622
takes_args = ['dir?']
623
624
@display_command
625
def run(self, dir=u'.'):
626
tree = WorkingTree.open_containing(dir)[0]
627
old_inv = tree.branch.basis_tree().inventory
628
new_inv = tree.read_working_inventory()
629
630
renames = list(bzrlib.tree.find_renames(old_inv, new_inv))
631
renames.sort()
632
for old_name, new_name in renames:
633
print "%s => %s" % (old_name, new_name)
634
635
636
class cmd_info(Command):
637
"""Show statistical information about a branch."""
638
takes_args = ['branch?']
639
640
@display_command
641
def run(self, branch=None):
642
import info
643
b = WorkingTree.open_containing(branch)[0].branch
644
info.show_info(b)
645
646
647
class cmd_remove(Command):
648
"""Make a file unversioned.
649
650
This makes bzr stop tracking changes to a versioned file. It does
651
not delete the working copy.
652
"""
653
takes_args = ['file+']
654
takes_options = ['verbose']
655
aliases = ['rm']
656
657
def run(self, file_list, verbose=False):
658
tree, file_list = tree_files(file_list)
659
tree.remove(file_list, verbose=verbose)
660
661
662
class cmd_file_id(Command):
663
"""Print file_id of a particular file or directory.
664
665
The file_id is assigned when the file is first added and remains the
666
same through all revisions where the file exists, even when it is
667
moved or renamed.
668
"""
669
hidden = True
670
takes_args = ['filename']
671
@display_command
672
def run(self, filename):
673
tree, relpath = WorkingTree.open_containing(filename)
674
i = tree.inventory.path2id(relpath)
675
if i == None:
676
raise BzrError("%r is not a versioned file" % filename)
677
else:
678
print i
679
680
681
class cmd_file_path(Command):
682
"""Print path of file_ids to a file or directory.
683
684
This prints one line for each directory down to the target,
685
starting at the branch root."""
686
hidden = True
687
takes_args = ['filename']
688
@display_command
689
def run(self, filename):
690
tree, relpath = WorkingTree.open_containing(filename)
691
inv = tree.inventory
692
fid = inv.path2id(relpath)
693
if fid == None:
694
raise BzrError("%r is not a versioned file" % filename)
695
for fip in inv.get_idpath(fid):
696
print fip
697
698
699
class cmd_revision_history(Command):
700
"""Display list of revision ids on this branch."""
701
hidden = True
702
@display_command
703
def run(self):
704
branch = WorkingTree.open_containing(u'.')[0].branch
705
for patchid in branch.revision_history():
706
print patchid
707
708
709
class cmd_ancestry(Command):
710
"""List all revisions merged into this branch."""
711
hidden = True
712
@display_command
713
def run(self):
714
tree = WorkingTree.open_containing(u'.')[0]
715
b = tree.branch
716
# FIXME. should be tree.last_revision
717
for revision_id in b.get_ancestry(b.last_revision()):
718
print revision_id
719
720
721
class cmd_init(Command):
722
"""Make a directory into a versioned branch.
723
724
Use this to create an empty branch, or before importing an
725
existing project.
726
727
Recipe for importing a tree of files:
728
cd ~/project
729
bzr init
730
bzr add .
731
bzr status
732
bzr commit -m 'imported project'
733
"""
734
takes_args = ['location?']
735
def run(self, location=None):
736
from bzrlib.branch import Branch
737
if location is None:
738
location = u'.'
739
else:
740
# The path has to exist to initialize a
741
# branch inside of it.
742
# Just using os.mkdir, since I don't
743
# believe that we want to create a bunch of
744
# locations if the user supplies an extended path
745
if not os.path.exists(location):
746
os.mkdir(location)
747
Branch.initialize(location)
748
749
750
class cmd_diff(Command):
751
"""Show differences in working tree.
752
753
If files are listed, only the changes in those files are listed.
754
Otherwise, all changes for the tree are listed.
755
756
examples:
757
bzr diff
758
bzr diff -r1
759
bzr diff -r1..2
760
"""
761
# TODO: Allow diff across branches.
762
# TODO: Option to use external diff command; could be GNU diff, wdiff,
763
# or a graphical diff.
764
765
# TODO: Python difflib is not exactly the same as unidiff; should
766
# either fix it up or prefer to use an external diff.
767
768
# TODO: If a directory is given, diff everything under that.
769
770
# TODO: Selected-file diff is inefficient and doesn't show you
771
# deleted files.
772
773
# TODO: This probably handles non-Unix newlines poorly.
774
775
takes_args = ['file*']
776
takes_options = ['revision', 'diff-options']
777
aliases = ['di', 'dif']
778
779
@display_command
780
def run(self, revision=None, file_list=None, diff_options=None):
781
from bzrlib.diff import show_diff
782
try:
783
tree, file_list = internal_tree_files(file_list)
784
b = None
785
b2 = None
786
except FileInWrongBranch:
787
if len(file_list) != 2:
788
raise BzrCommandError("Files are in different branches")
789
790
b, file1 = Branch.open_containing(file_list[0])
791
b2, file2 = Branch.open_containing(file_list[1])
792
if file1 != "" or file2 != "":
793
# FIXME diff those two files. rbc 20051123
794
raise BzrCommandError("Files are in different branches")
795
file_list = None
796
if revision is not None:
797
if b2 is not None:
798
raise BzrCommandError("Can't specify -r with two branches")
799
if len(revision) == 1:
800
return show_diff(tree.branch, revision[0], specific_files=file_list,
801
external_diff_options=diff_options)
802
elif len(revision) == 2:
803
return show_diff(tree.branch, revision[0], specific_files=file_list,
804
external_diff_options=diff_options,
805
revision2=revision[1])
806
else:
807
raise BzrCommandError('bzr diff --revision takes exactly one or two revision identifiers')
808
else:
809
if b is not None:
810
return show_diff(b, None, specific_files=file_list,
811
external_diff_options=diff_options, b2=b2)
812
else:
813
return show_diff(tree.branch, None, specific_files=file_list,
814
external_diff_options=diff_options)
815
816
817
class cmd_deleted(Command):
818
"""List files deleted in the working tree.
819
"""
820
# TODO: Show files deleted since a previous revision, or
821
# between two revisions.
822
# TODO: Much more efficient way to do this: read in new
823
# directories with readdir, rather than stating each one. Same
824
# level of effort but possibly much less IO. (Or possibly not,
825
# if the directories are very large...)
826
@display_command
827
def run(self, show_ids=False):
828
tree = WorkingTree.open_containing(u'.')[0]
829
old = tree.branch.basis_tree()
830
for path, ie in old.inventory.iter_entries():
831
if not tree.has_id(ie.file_id):
832
if show_ids:
833
print '%-50s %s' % (path, ie.file_id)
834
else:
835
print path
836
837
838
class cmd_modified(Command):
839
"""List files modified in working tree."""
840
hidden = True
841
@display_command
842
def run(self):
843
from bzrlib.delta import compare_trees
844
845
tree = WorkingTree.open_containing(u'.')[0]
846
td = compare_trees(tree.branch.basis_tree(), tree)
847
848
for path, id, kind, text_modified, meta_modified in td.modified:
849
print path
850
851
852
853
class cmd_added(Command):
854
"""List files added in working tree."""
855
hidden = True
856
@display_command
857
def run(self):
858
wt = WorkingTree.open_containing(u'.')[0]
859
basis_inv = wt.branch.basis_tree().inventory
860
inv = wt.inventory
861
for file_id in inv:
862
if file_id in basis_inv:
863
continue
864
path = inv.id2path(file_id)
865
if not os.access(b.abspath(path), os.F_OK):
866
continue
867
print path
868
869
870
871
class cmd_root(Command):
872
"""Show the tree root directory.
873
874
The root is the nearest enclosing directory with a .bzr control
875
directory."""
876
takes_args = ['filename?']
877
@display_command
878
def run(self, filename=None):
879
"""Print the branch root."""
880
tree = WorkingTree.open_containing(filename)[0]
881
print tree.basedir
882
883
884
class cmd_log(Command):
885
"""Show log of this branch.
886
887
To request a range of logs, you can use the command -r begin..end
888
-r revision requests a specific revision, -r ..end or -r begin.. are
889
also valid.
890
"""
891
892
# TODO: Make --revision support uuid: and hash: [future tag:] notation.
893
894
takes_args = ['filename?']
895
takes_options = [Option('forward',
896
help='show from oldest to newest'),
897
'timezone', 'verbose',
898
'show-ids', 'revision',
899
'line', 'long',
900
Option('message',
901
help='show revisions whose message matches this regexp',
902
type=str),
903
'short',
904
]
905
@display_command
906
def run(self, filename=None, timezone='original',
907
verbose=False,
908
show_ids=False,
909
forward=False,
910
revision=None,
911
message=None,
912
long=False,
913
short=False,
914
line=False):
915
from bzrlib.log import log_formatter, show_log
916
import codecs
917
assert message is None or isinstance(message, basestring), \
918
"invalid message argument %r" % message
919
direction = (forward and 'forward') or 'reverse'
920
921
if filename:
922
# might be a tree:
923
tree = None
924
try:
925
tree, fp = WorkingTree.open_containing(filename)
926
b = tree.branch
927
if fp != '':
928
inv = tree.read_working_inventory()
929
except NotBranchError:
930
pass
931
if tree is None:
932
b, fp = Branch.open_containing(filename)
933
if fp != '':
934
inv = b.repository.get_inventory(b.last_revision())
935
if fp != '':
936
file_id = inv.path2id(fp)
937
else:
938
file_id = None # points to branch root
939
else:
940
tree, relpath = WorkingTree.open_containing(u'.')
941
b = tree.branch
942
file_id = None
943
944
if revision is None:
945
rev1 = None
946
rev2 = None
947
elif len(revision) == 1:
948
rev1 = rev2 = revision[0].in_history(b).revno
949
elif len(revision) == 2:
950
rev1 = revision[0].in_history(b).revno
951
rev2 = revision[1].in_history(b).revno
952
else:
953
raise BzrCommandError('bzr log --revision takes one or two values.')
954
955
# By this point, the revision numbers are converted to the +ve
956
# form if they were supplied in the -ve form, so we can do
957
# this comparison in relative safety
958
if rev1 > rev2:
959
(rev2, rev1) = (rev1, rev2)
960
961
mutter('encoding log as %r', bzrlib.user_encoding)
962
963
# use 'replace' so that we don't abort if trying to write out
964
# in e.g. the default C locale.
965
outf = codecs.getwriter(bzrlib.user_encoding)(sys.stdout, errors='replace')
966
967
log_format = get_log_format(long=long, short=short, line=line)
968
lf = log_formatter(log_format,
969
show_ids=show_ids,
970
to_file=outf,
971
show_timezone=timezone)
972
973
show_log(b,
974
lf,
975
file_id,
976
verbose=verbose,
977
direction=direction,
978
start_revision=rev1,
979
end_revision=rev2,
980
search=message)
981
982
def get_log_format(long=False, short=False, line=False, default='long'):
983
log_format = default
984
if long:
985
log_format = 'long'
986
if short:
987
log_format = 'short'
988
if line:
989
log_format = 'line'
990
return log_format
991
992
993
class cmd_touching_revisions(Command):
994
"""Return revision-ids which affected a particular file.
995
996
A more user-friendly interface is "bzr log FILE"."""
997
hidden = True
998
takes_args = ["filename"]
999
@display_command
1000
def run(self, filename):
1001
tree, relpath = WorkingTree.open_containing(filename)
1002
b = tree.branch
1003
inv = tree.read_working_inventory()
1004
file_id = inv.path2id(relpath)
1005
for revno, revision_id, what in bzrlib.log.find_touching_revisions(b, file_id):
1006
print "%6d %s" % (revno, what)
1007
1008
1009
class cmd_ls(Command):
1010
"""List files in a tree.
1011
"""
1012
# TODO: Take a revision or remote path and list that tree instead.
1013
hidden = True
1014
takes_options = ['verbose', 'revision',
1015
Option('non-recursive',
1016
help='don\'t recurse into sub-directories'),
1017
Option('from-root',
1018
help='Print all paths from the root of the branch.'),
1019
Option('unknown', help='Print unknown files'),
1020
Option('versioned', help='Print versioned files'),
1021
Option('ignored', help='Print ignored files'),
1022
1023
Option('null', help='Null separate the files'),
1024
]
1025
@display_command
1026
def run(self, revision=None, verbose=False,
1027
non_recursive=False, from_root=False,
1028
unknown=False, versioned=False, ignored=False,
1029
null=False):
1030
1031
if verbose and null:
1032
raise BzrCommandError('Cannot set both --verbose and --null')
1033
all = not (unknown or versioned or ignored)
1034
1035
selection = {'I':ignored, '?':unknown, 'V':versioned}
1036
1037
tree, relpath = WorkingTree.open_containing(u'.')
1038
if from_root:
1039
relpath = u''
1040
elif relpath:
1041
relpath += '/'
1042
if revision is not None:
1043
tree = tree.branch.repository.revision_tree(
1044
revision[0].in_history(tree.branch).rev_id)
1045
for fp, fc, kind, fid, entry in tree.list_files():
1046
if fp.startswith(relpath):
1047
fp = fp[len(relpath):]
1048
if non_recursive and '/' in fp:
1049
continue
1050
if not all and not selection[fc]:
1051
continue
1052
if verbose:
1053
kindch = entry.kind_character()
1054
print '%-8s %s%s' % (fc, fp, kindch)
1055
elif null:
1056
sys.stdout.write(fp)
1057
sys.stdout.write('\0')
1058
sys.stdout.flush()
1059
else:
1060
print fp
1061
1062
1063
class cmd_unknowns(Command):
1064
"""List unknown files."""
1065
@display_command
1066
def run(self):
1067
from bzrlib.osutils import quotefn
1068
for f in WorkingTree.open_containing(u'.')[0].unknowns():
1069
print quotefn(f)
1070
1071
1072
class cmd_ignore(Command):
1073
"""Ignore a command or pattern.
1074
1075
To remove patterns from the ignore list, edit the .bzrignore file.
1076
1077
If the pattern contains a slash, it is compared to the whole path
1078
from the branch root. Otherwise, it is compared to only the last
1079
component of the path. To match a file only in the root directory,
1080
prepend './'.
1081
1082
Ignore patterns are case-insensitive on case-insensitive systems.
1083
1084
Note: wildcards must be quoted from the shell on Unix.
1085
1086
examples:
1087
bzr ignore ./Makefile
1088
bzr ignore '*.class'
1089
"""
1090
# TODO: Complain if the filename is absolute
1091
takes_args = ['name_pattern']
1092
1093
def run(self, name_pattern):
1094
from bzrlib.atomicfile import AtomicFile
1095
import os.path
1096
1097
tree, relpath = WorkingTree.open_containing(u'.')
1098
ifn = tree.abspath('.bzrignore')
1099
1100
if os.path.exists(ifn):
1101
f = open(ifn, 'rt')
1102
try:
1103
igns = f.read().decode('utf-8')
1104
finally:
1105
f.close()
1106
else:
1107
igns = ''
1108
1109
# TODO: If the file already uses crlf-style termination, maybe
1110
# we should use that for the newly added lines?
1111
1112
if igns and igns[-1] != '\n':
1113
igns += '\n'
1114
igns += name_pattern + '\n'
1115
1116
try:
1117
f = AtomicFile(ifn, 'wt')
1118
f.write(igns.encode('utf-8'))
1119
f.commit()
1120
finally:
1121
f.close()
1122
1123
inv = tree.inventory
1124
if inv.path2id('.bzrignore'):
1125
mutter('.bzrignore is already versioned')
1126
else:
1127
mutter('need to make new .bzrignore file versioned')
1128
tree.add(['.bzrignore'])
1129
1130
1131
class cmd_ignored(Command):
1132
"""List ignored files and the patterns that matched them.
1133
1134
See also: bzr ignore"""
1135
@display_command
1136
def run(self):
1137
tree = WorkingTree.open_containing(u'.')[0]
1138
for path, file_class, kind, file_id, entry in tree.list_files():
1139
if file_class != 'I':
1140
continue
1141
## XXX: Slightly inefficient since this was already calculated
1142
pat = tree.is_ignored(path)
1143
print '%-50s %s' % (path, pat)
1144
1145
1146
class cmd_lookup_revision(Command):
1147
"""Lookup the revision-id from a revision-number
1148
1149
example:
1150
bzr lookup-revision 33
1151
"""
1152
hidden = True
1153
takes_args = ['revno']
1154
1155
@display_command
1156
def run(self, revno):
1157
try:
1158
revno = int(revno)
1159
except ValueError:
1160
raise BzrCommandError("not a valid revision-number: %r" % revno)
1161
1162
print WorkingTree.open_containing(u'.')[0].branch.get_rev_id(revno)
1163
1164
1165
class cmd_export(Command):
1166
"""Export past revision to destination directory.
1167
1168
If no revision is specified this exports the last committed revision.
1169
1170
Format may be an "exporter" name, such as tar, tgz, tbz2. If none is
1171
given, try to find the format with the extension. If no extension
1172
is found exports to a directory (equivalent to --format=dir).
1173
1174
Root may be the top directory for tar, tgz and tbz2 formats. If none
1175
is given, the top directory will be the root name of the file.
1176
1177
Note: export of tree with non-ascii filenames to zip is not supported.
1178
1179
Supported formats Autodetected by extension
1180
----------------- -------------------------
1181
dir -
1182
tar .tar
1183
tbz2 .tar.bz2, .tbz2
1184
tgz .tar.gz, .tgz
1185
zip .zip
1186
"""
1187
takes_args = ['dest']
1188
takes_options = ['revision', 'format', 'root']
1189
def run(self, dest, revision=None, format=None, root=None):
1190
import os.path
1191
from bzrlib.export import export
1192
tree = WorkingTree.open_containing(u'.')[0]
1193
b = tree.branch
1194
if revision is None:
1195
# should be tree.last_revision FIXME
1196
rev_id = b.last_revision()
1197
else:
1198
if len(revision) != 1:
1199
raise BzrError('bzr export --revision takes exactly 1 argument')
1200
rev_id = revision[0].in_history(b).rev_id
1201
t = b.repository.revision_tree(rev_id)
1202
try:
1203
export(t, dest, format, root)
1204
except errors.NoSuchExportFormat, e:
1205
raise BzrCommandError('Unsupported export format: %s' % e.format)
1206
1207
1208
class cmd_cat(Command):
1209
"""Write a file's text from a previous revision."""
1210
1211
takes_options = ['revision']
1212
takes_args = ['filename']
1213
1214
@display_command
1215
def run(self, filename, revision=None):
1216
if revision is not None and len(revision) != 1:
1217
raise BzrCommandError("bzr cat --revision takes exactly one number")
1218
tree = None
1219
try:
1220
tree, relpath = WorkingTree.open_containing(filename)
1221
b = tree.branch
1222
except NotBranchError:
1223
pass
1224
1225
if tree is None:
1226
b, relpath = Branch.open_containing(filename)
1227
if revision is None:
1228
revision_id = b.last_revision()
1229
else:
1230
revision_id = revision[0].in_history(b).rev_id
1231
b.print_file(relpath, revision_id)
1232
1233
1234
class cmd_local_time_offset(Command):
1235
"""Show the offset in seconds from GMT to local time."""
1236
hidden = True
1237
@display_command
1238
def run(self):
1239
print bzrlib.osutils.local_time_offset()
1240
1241
1242
1243
class cmd_commit(Command):
1244
"""Commit changes into a new revision.
1245
1246
If no arguments are given, the entire tree is committed.
1247
1248
If selected files are specified, only changes to those files are
1249
committed. If a directory is specified then the directory and everything
1250
within it is committed.
1251
1252
A selected-file commit may fail in some cases where the committed
1253
tree would be invalid, such as trying to commit a file in a
1254
newly-added directory that is not itself committed.
1255
"""
1256
# TODO: Run hooks on tree to-be-committed, and after commit.
1257
1258
# TODO: Strict commit that fails if there are deleted files.
1259
# (what does "deleted files" mean ??)
1260
1261
# TODO: Give better message for -s, --summary, used by tla people
1262
1263
# XXX: verbose currently does nothing
1264
1265
takes_args = ['selected*']
1266
takes_options = ['message', 'verbose',
1267
Option('unchanged',
1268
help='commit even if nothing has changed'),
1269
Option('file', type=str,
1270
argname='msgfile',
1271
help='file containing commit message'),
1272
Option('strict',
1273
help="refuse to commit if there are unknown "
1274
"files in the working tree."),
1275
]
1276
aliases = ['ci', 'checkin']
1277
1278
def run(self, message=None, file=None, verbose=True, selected_list=None,
1279
unchanged=False, strict=False):
1280
from bzrlib.errors import (PointlessCommit, ConflictsInTree,
1281
StrictCommitFailed)
1282
from bzrlib.msgeditor import edit_commit_message, \
1283
make_commit_message_template
1284
from bzrlib.status import show_status
1285
from tempfile import TemporaryFile
1286
import codecs
1287
1288
# TODO: Need a blackbox test for invoking the external editor; may be
1289
# slightly problematic to run this cross-platform.
1290
1291
# TODO: do more checks that the commit will succeed before
1292
# spending the user's valuable time typing a commit message.
1293
#
1294
# TODO: if the commit *does* happen to fail, then save the commit
1295
# message to a temporary file where it can be recovered
1296
tree, selected_list = tree_files(selected_list)
1297
if message is None and not file:
1298
template = make_commit_message_template(tree, selected_list)
1299
message = edit_commit_message(template)
1300
if message is None:
1301
raise BzrCommandError("please specify a commit message"
1302
" with either --message or --file")
1303
elif message and file:
1304
raise BzrCommandError("please specify either --message or --file")
1305
1306
if file:
1307
import codecs
1308
message = codecs.open(file, 'rt', bzrlib.user_encoding).read()
1309
1310
if message == "":
1311
raise BzrCommandError("empty commit message specified")
1312
1313
try:
1314
tree.commit(message, specific_files=selected_list,
1315
allow_pointless=unchanged, strict=strict)
1316
except PointlessCommit:
1317
# FIXME: This should really happen before the file is read in;
1318
# perhaps prepare the commit; get the message; then actually commit
1319
raise BzrCommandError("no changes to commit",
1320
["use --unchanged to commit anyhow"])
1321
except ConflictsInTree:
1322
raise BzrCommandError("Conflicts detected in working tree. "
1323
'Use "bzr conflicts" to list, "bzr resolve FILE" to resolve.')
1324
except StrictCommitFailed:
1325
raise BzrCommandError("Commit refused because there are unknown "
1326
"files in the working tree.")
1327
note('Committed revision %d.' % (tree.branch.revno(),))
1328
1329
1330
class cmd_check(Command):
1331
"""Validate consistency of branch history.
1332
1333
This command checks various invariants about the branch storage to
1334
detect data corruption or bzr bugs.
1335
"""
1336
takes_args = ['branch?']
1337
takes_options = ['verbose']
1338
1339
def run(self, branch=None, verbose=False):
1340
from bzrlib.check import check
1341
if branch is None:
1342
tree = WorkingTree.open_containing()[0]
1343
branch = tree.branch
1344
else:
1345
branch = Branch.open(branch)
1346
check(branch, verbose)
1347
1348
1349
class cmd_scan_cache(Command):
1350
hidden = True
1351
def run(self):
1352
from bzrlib.hashcache import HashCache
1353
1354
c = HashCache(u'.')
1355
c.read()
1356
c.scan()
1357
1358
print '%6d stats' % c.stat_count
1359
print '%6d in hashcache' % len(c._cache)
1360
print '%6d files removed from cache' % c.removed_count
1361
print '%6d hashes updated' % c.update_count
1362
print '%6d files changed too recently to cache' % c.danger_count
1363
1364
if c.needs_write:
1365
c.write()
1366
1367
1368
1369
class cmd_upgrade(Command):
1370
"""Upgrade branch storage to current format.
1371
1372
The check command or bzr developers may sometimes advise you to run
1373
this command.
1374
1375
This version of this command upgrades from the full-text storage
1376
used by bzr 0.0.8 and earlier to the weave format (v5).
1377
"""
1378
takes_args = ['dir?']
1379
1380
def run(self, dir=u'.'):
1381
from bzrlib.upgrade import upgrade
1382
upgrade(dir)
1383
1384
1385
class cmd_whoami(Command):
1386
"""Show bzr user id."""
1387
takes_options = ['email']
1388
1389
@display_command
1390
def run(self, email=False):
1391
try:
1392
b = WorkingTree.open_containing(u'.')[0].branch
1393
config = bzrlib.config.BranchConfig(b)
1394
except NotBranchError:
1395
config = bzrlib.config.GlobalConfig()
1396
1397
if email:
1398
print config.user_email()
1399
else:
1400
print config.username()
1401
1402
class cmd_nick(Command):
1403
"""\
1404
Print or set the branch nickname.
1405
If unset, the tree root directory name is used as the nickname
1406
To print the current nickname, execute with no argument.
1407
"""
1408
takes_args = ['nickname?']
1409
def run(self, nickname=None):
1410
branch = Branch.open_containing(u'.')[0]
1411
if nickname is None:
1412
self.printme(branch)
1413
else:
1414
branch.nick = nickname
1415
1416
@display_command
1417
def printme(self, branch):
1418
print branch.nick
1419
1420
class cmd_selftest(Command):
1421
"""Run internal test suite.
1422
1423
This creates temporary test directories in the working directory,
1424
but not existing data is affected. These directories are deleted
1425
if the tests pass, or left behind to help in debugging if they
1426
fail and --keep-output is specified.
1427
1428
If arguments are given, they are regular expressions that say
1429
which tests should run.
1430
"""
1431
# TODO: --list should give a list of all available tests
1432
hidden = True
1433
takes_args = ['testspecs*']
1434
takes_options = ['verbose',
1435
Option('one', help='stop when one test fails'),
1436
Option('keep-output',
1437
help='keep output directories when tests fail')
1438
]
1439
1440
def run(self, testspecs_list=None, verbose=False, one=False,
1441
keep_output=False):
1442
import bzrlib.ui
1443
from bzrlib.tests import selftest
1444
# we don't want progress meters from the tests to go to the
1445
# real output; and we don't want log messages cluttering up
1446
# the real logs.
1447
save_ui = bzrlib.ui.ui_factory
1448
bzrlib.trace.info('running tests...')
1449
try:
1450
bzrlib.ui.ui_factory = bzrlib.ui.SilentUIFactory()
1451
if testspecs_list is not None:
1452
pattern = '|'.join(testspecs_list)
1453
else:
1454
pattern = ".*"
1455
result = selftest(verbose=verbose,
1456
pattern=pattern,
1457
stop_on_failure=one,
1458
keep_output=keep_output)
1459
if result:
1460
bzrlib.trace.info('tests passed')
1461
else:
1462
bzrlib.trace.info('tests failed')
1463
return int(not result)
1464
finally:
1465
bzrlib.ui.ui_factory = save_ui
1466
1467
1468
def _get_bzr_branch():
1469
"""If bzr is run from a branch, return Branch or None"""
1470
import bzrlib.errors
1471
from bzrlib.branch import Branch
1472
from bzrlib.osutils import abspath
1473
from os.path import dirname
1474
1475
try:
1476
branch = Branch.open(dirname(abspath(dirname(__file__))))
1477
return branch
1478
except bzrlib.errors.BzrError:
1479
return None
1480
1481
1482
def show_version():
1483
print "bzr (bazaar-ng) %s" % bzrlib.__version__
1484
# is bzrlib itself in a branch?
1485
branch = _get_bzr_branch()
1486
if branch:
1487
rh = branch.revision_history()
1488
revno = len(rh)
1489
print " bzr checkout, revision %d" % (revno,)
1490
print " nick: %s" % (branch.nick,)
1491
if rh:
1492
print " revid: %s" % (rh[-1],)
1493
print bzrlib.__copyright__
1494
print "http://bazaar-ng.org/"
1495
print
1496
print "bzr comes with ABSOLUTELY NO WARRANTY. bzr is free software, and"
1497
print "you may use, modify and redistribute it under the terms of the GNU"
1498
print "General Public License version 2 or later."
1499
1500
1501
class cmd_version(Command):
1502
"""Show version of bzr."""
1503
@display_command
1504
def run(self):
1505
show_version()
1506
1507
class cmd_rocks(Command):
1508
"""Statement of optimism."""
1509
hidden = True
1510
@display_command
1511
def run(self):
1512
print "it sure does!"
1513
1514
1515
class cmd_find_merge_base(Command):
1516
"""Find and print a base revision for merging two branches.
1517
"""
1518
# TODO: Options to specify revisions on either side, as if
1519
# merging only part of the history.
1520
takes_args = ['branch', 'other']
1521
hidden = True
1522
1523
@display_command
1524
def run(self, branch, other):
1525
from bzrlib.revision import common_ancestor, MultipleRevisionSources
1526
1527
branch1 = Branch.open_containing(branch)[0]
1528
branch2 = Branch.open_containing(other)[0]
1529
1530
history_1 = branch1.revision_history()
1531
history_2 = branch2.revision_history()
1532
1533
last1 = branch1.last_revision()
1534
last2 = branch2.last_revision()
1535
1536
source = MultipleRevisionSources(branch1, branch2)
1537
1538
base_rev_id = common_ancestor(last1, last2, source)
1539
1540
print 'merge base is revision %s' % base_rev_id
1541
1542
return
1543
1544
if base_revno is None:
1545
raise bzrlib.errors.UnrelatedBranches()
1546
1547
print ' r%-6d in %s' % (base_revno, branch)
1548
1549
other_revno = branch2.revision_id_to_revno(base_revid)
1550
1551
print ' r%-6d in %s' % (other_revno, other)
1552
1553
1554
1555
class cmd_merge(Command):
1556
"""Perform a three-way merge.
1557
1558
The branch is the branch you will merge from. By default, it will
1559
merge the latest revision. If you specify a revision, that
1560
revision will be merged. If you specify two revisions, the first
1561
will be used as a BASE, and the second one as OTHER. Revision
1562
numbers are always relative to the specified branch.
1563
1564
By default bzr will try to merge in all new work from the other
1565
branch, automatically determining an appropriate base. If this
1566
fails, you may need to give an explicit base.
1567
1568
Examples:
1569
1570
To merge the latest revision from bzr.dev
1571
bzr merge ../bzr.dev
1572
1573
To merge changes up to and including revision 82 from bzr.dev
1574
bzr merge -r 82 ../bzr.dev
1575
1576
To merge the changes introduced by 82, without previous changes:
1577
bzr merge -r 81..82 ../bzr.dev
1578
1579
merge refuses to run if there are any uncommitted changes, unless
1580
--force is given.
1581
"""
1582
takes_args = ['branch?']
1583
takes_options = ['revision', 'force', 'merge-type', 'reprocess',
1584
Option('show-base', help="Show base revision text in "
1585
"conflicts")]
1586
1587
def run(self, branch=None, revision=None, force=False, merge_type=None,
1588
show_base=False, reprocess=False):
1589
from bzrlib.merge import merge
1590
from bzrlib.merge_core import ApplyMerge3
1591
if merge_type is None:
1592
merge_type = ApplyMerge3
1593
if branch is None:
1594
branch = WorkingTree.open_containing(u'.')[0].branch.get_parent()
1595
if branch is None:
1596
raise BzrCommandError("No merge location known or specified.")
1597
else:
1598
print "Using saved location: %s" % branch
1599
if revision is None or len(revision) < 1:
1600
base = [None, None]
1601
other = [branch, -1]
1602
else:
1603
if len(revision) == 1:
1604
base = [None, None]
1605
other_branch = Branch.open_containing(branch)[0]
1606
revno = revision[0].in_history(other_branch).revno
1607
other = [branch, revno]
1608
else:
1609
assert len(revision) == 2
1610
if None in revision:
1611
raise BzrCommandError(
1612
"Merge doesn't permit that revision specifier.")
1613
b = Branch.open_containing(branch)[0]
1614
1615
base = [branch, revision[0].in_history(b).revno]
1616
other = [branch, revision[1].in_history(b).revno]
1617
1618
try:
1619
conflict_count = merge(other, base, check_clean=(not force),
1620
merge_type=merge_type, reprocess=reprocess,
1621
show_base=show_base)
1622
if conflict_count != 0:
1623
return 1
1624
else:
1625
return 0
1626
except bzrlib.errors.AmbiguousBase, e:
1627
m = ("sorry, bzr can't determine the right merge base yet\n"
1628
"candidates are:\n "
1629
+ "\n ".join(e.bases)
1630
+ "\n"
1631
"please specify an explicit base with -r,\n"
1632
"and (if you want) report this to the bzr developers\n")
1633
log_error(m)
1634
1635
1636
class cmd_remerge(Command):
1637
"""Redo a merge.
1638
"""
1639
takes_args = ['file*']
1640
takes_options = ['merge-type', 'reprocess',
1641
Option('show-base', help="Show base revision text in "
1642
"conflicts")]
1643
1644
def run(self, file_list=None, merge_type=None, show_base=False,
1645
reprocess=False):
1646
from bzrlib.merge import merge_inner, transform_tree
1647
from bzrlib.merge_core import ApplyMerge3
1648
if merge_type is None:
1649
merge_type = ApplyMerge3
1650
tree, file_list = tree_files(file_list)
1651
tree.lock_write()
1652
try:
1653
pending_merges = tree.pending_merges()
1654
if len(pending_merges) != 1:
1655
raise BzrCommandError("Sorry, remerge only works after normal"
1656
+ " merges. Not cherrypicking or"
1657
+ "multi-merges.")
1658
repository = tree.branch.repository
1659
base_revision = common_ancestor(tree.branch.last_revision(),
1660
pending_merges[0], repository)
1661
base_tree = repository.revision_tree(base_revision)
1662
other_tree = repository.revision_tree(pending_merges[0])
1663
interesting_ids = None
1664
if file_list is not None:
1665
interesting_ids = set()
1666
for filename in file_list:
1667
file_id = tree.path2id(filename)
1668
interesting_ids.add(file_id)
1669
if tree.kind(file_id) != "directory":
1670
continue
1671
1672
for name, ie in tree.inventory.iter_entries(file_id):
1673
interesting_ids.add(ie.file_id)
1674
transform_tree(tree, tree.branch.basis_tree(), interesting_ids)
1675
if file_list is None:
1676
restore_files = list(tree.iter_conflicts())
1677
else:
1678
restore_files = file_list
1679
for filename in restore_files:
1680
try:
1681
restore(tree.abspath(filename))
1682
except NotConflicted:
1683
pass
1684
conflicts = merge_inner(tree.branch, other_tree, base_tree,
1685
interesting_ids = interesting_ids,
1686
other_rev_id=pending_merges[0],
1687
merge_type=merge_type,
1688
show_base=show_base,
1689
reprocess=reprocess)
1690
finally:
1691
tree.unlock()
1692
if conflicts > 0:
1693
return 1
1694
else:
1695
return 0
1696
1697
class cmd_revert(Command):
1698
"""Reverse all changes since the last commit.
1699
1700
Only versioned files are affected. Specify filenames to revert only
1701
those files. By default, any files that are changed will be backed up
1702
first. Backup files have a '~' appended to their name.
1703
"""
1704
takes_options = ['revision', 'no-backup']
1705
takes_args = ['file*']
1706
aliases = ['merge-revert']
1707
1708
def run(self, revision=None, no_backup=False, file_list=None):
1709
from bzrlib.merge import merge_inner
1710
from bzrlib.commands import parse_spec
1711
if file_list is not None:
1712
if len(file_list) == 0:
1713
raise BzrCommandError("No files specified")
1714
else:
1715
file_list = []
1716
if revision is None:
1717
revno = -1
1718
tree = WorkingTree.open_containing(u'.')[0]
1719
# FIXME should be tree.last_revision
1720
rev_id = tree.branch.last_revision()
1721
elif len(revision) != 1:
1722
raise BzrCommandError('bzr revert --revision takes exactly 1 argument')
1723
else:
1724
tree, file_list = tree_files(file_list)
1725
rev_id = revision[0].in_history(tree.branch).rev_id
1726
tree.revert(file_list, tree.branch.repository.revision_tree(rev_id),
1727
not no_backup)
1728
1729
1730
class cmd_assert_fail(Command):
1731
"""Test reporting of assertion failures"""
1732
hidden = True
1733
def run(self):
1734
assert False, "always fails"
1735
1736
1737
class cmd_help(Command):
1738
"""Show help on a command or other topic.
1739
1740
For a list of all available commands, say 'bzr help commands'."""
1741
takes_options = ['long']
1742
takes_args = ['topic?']
1743
aliases = ['?']
1744
1745
@display_command
1746
def run(self, topic=None, long=False):
1747
import help
1748
if topic is None and long:
1749
topic = "commands"
1750
help.help(topic)
1751
1752
1753
class cmd_shell_complete(Command):
1754
"""Show appropriate completions for context.
1755
1756
For a list of all available commands, say 'bzr shell-complete'."""
1757
takes_args = ['context?']
1758
aliases = ['s-c']
1759
hidden = True
1760
1761
@display_command
1762
def run(self, context=None):
1763
import shellcomplete
1764
shellcomplete.shellcomplete(context)
1765
1766
1767
class cmd_fetch(Command):
1768
"""Copy in history from another branch but don't merge it.
1769
1770
This is an internal method used for pull and merge."""
1771
hidden = True
1772
takes_args = ['from_branch', 'to_branch']
1773
def run(self, from_branch, to_branch):
1774
from bzrlib.fetch import Fetcher
1775
from bzrlib.branch import Branch
1776
from_b = Branch.open(from_branch)
1777
to_b = Branch.open(to_branch)
1778
from_b.lock_read()
1779
try:
1780
to_b.lock_write()
1781
try:
1782
Fetcher(to_b, from_b)
1783
finally:
1784
to_b.unlock()
1785
finally:
1786
from_b.unlock()
1787
1788
1789
class cmd_missing(Command):
1790
"""Show unmerged/unpulled revisions between two branches.
1791
1792
OTHER_BRANCH may be local or remote."""
1793
takes_args = ['other_branch?']
1794
takes_options = [Option('reverse', 'Reverse the order of revisions'),
1795
Option('mine-only',
1796
'Display changes in the local branch only'),
1797
Option('theirs-only',
1798
'Display changes in the remote branch only'),
1799
'line',
1800
'long',
1801
'short',
1802
'show-ids',
1803
'verbose'
1804
]
1805
1806
def run(self, other_branch=None, reverse=False, mine_only=False,
1807
theirs_only=False, long=True, short=False, line=False,
1808
show_ids=False, verbose=False):
1809
from bzrlib.missing import find_unmerged, iter_log_data
1810
from bzrlib.log import log_formatter
1811
local_branch = bzrlib.branch.Branch.open_containing(u".")[0]
1812
parent = local_branch.get_parent()
1813
if other_branch is None:
1814
other_branch = parent
1815
if other_branch is None:
1816
raise BzrCommandError("No missing location known or specified.")
1817
print "Using last location: " + local_branch.get_parent()
1818
remote_branch = bzrlib.branch.Branch.open(other_branch)
1819
local_extra, remote_extra = find_unmerged(local_branch, remote_branch)
1820
log_format = get_log_format(long=long, short=short, line=line)
1821
lf = log_formatter(log_format, sys.stdout,
1822
show_ids=show_ids,
1823
show_timezone='original')
1824
if reverse is False:
1825
local_extra.reverse()
1826
remote_extra.reverse()
1827
if local_extra and not theirs_only:
1828
print "You have %d extra revision(s):" % len(local_extra)
1829
for data in iter_log_data(local_extra, local_branch.repository,
1830
verbose):
1831
lf.show(*data)
1832
printed_local = True
1833
else:
1834
printed_local = False
1835
if remote_extra and not mine_only:
1836
if printed_local is True:
1837
print "\n\n"
1838
print "You are missing %d revision(s):" % len(remote_extra)
1839
for data in iter_log_data(remote_extra, remote_branch.repository,
1840
verbose):
1841
lf.show(*data)
1842
if not remote_extra and not local_extra:
1843
status_code = 0
1844
print "Branches are up to date."
1845
else:
1846
status_code = 1
1847
if parent is None and other_branch is not None:
1848
local_branch.set_parent(other_branch)
1849
return status_code
1850
1851
1852
class cmd_plugins(Command):
1853
"""List plugins"""
1854
hidden = True
1855
@display_command
1856
def run(self):
1857
import bzrlib.plugin
1858
from inspect import getdoc
1859
for name, plugin in bzrlib.plugin.all_plugins().items():
1860
if hasattr(plugin, '__path__'):
1861
print plugin.__path__[0]
1862
elif hasattr(plugin, '__file__'):
1863
print plugin.__file__
1864
else:
1865
print `plugin`
1866
1867
d = getdoc(plugin)
1868
if d:
1869
print '\t', d.split('\n')[0]
1870
1871
1872
class cmd_testament(Command):
1873
"""Show testament (signing-form) of a revision."""
1874
takes_options = ['revision', 'long']
1875
takes_args = ['branch?']
1876
@display_command
1877
def run(self, branch=u'.', revision=None, long=False):
1878
from bzrlib.testament import Testament
1879
b = WorkingTree.open_containing(branch)[0].branch
1880
b.lock_read()
1881
try:
1882
if revision is None:
1883
rev_id = b.last_revision()
1884
else:
1885
rev_id = revision[0].in_history(b).rev_id
1886
t = Testament.from_revision(b.repository, rev_id)
1887
if long:
1888
sys.stdout.writelines(t.as_text_lines())
1889
else:
1890
sys.stdout.write(t.as_short_text())
1891
finally:
1892
b.unlock()
1893
1894
1895
class cmd_annotate(Command):
1896
"""Show the origin of each line in a file.
1897
1898
This prints out the given file with an annotation on the left side
1899
indicating which revision, author and date introduced the change.
1900
1901
If the origin is the same for a run of consecutive lines, it is
1902
shown only at the top, unless the --all option is given.
1903
"""
1904
# TODO: annotate directories; showing when each file was last changed
1905
# TODO: annotate a previous version of a file
1906
# TODO: if the working copy is modified, show annotations on that
1907
# with new uncommitted lines marked
1908
aliases = ['blame', 'praise']
1909
takes_args = ['filename']
1910
takes_options = [Option('all', help='show annotations on all lines'),
1911
Option('long', help='show date in annotations'),
1912
]
1913
1914
@display_command
1915
def run(self, filename, all=False, long=False):
1916
from bzrlib.annotate import annotate_file
1917
tree, relpath = WorkingTree.open_containing(filename)
1918
branch = tree.branch
1919
branch.lock_read()
1920
try:
1921
file_id = tree.inventory.path2id(relpath)
1922
tree = branch.repository.revision_tree(branch.last_revision())
1923
file_version = tree.inventory[file_id].revision
1924
annotate_file(branch, file_version, file_id, long, all, sys.stdout)
1925
finally:
1926
branch.unlock()
1927
1928
1929
class cmd_re_sign(Command):
1930
"""Create a digital signature for an existing revision."""
1931
# TODO be able to replace existing ones.
1932
1933
hidden = True # is this right ?
1934
takes_args = ['revision_id?']
1935
takes_options = ['revision']
1936
1937
def run(self, revision_id=None, revision=None):
1938
import bzrlib.config as config
1939
import bzrlib.gpg as gpg
1940
if revision_id is not None and revision is not None:
1941
raise BzrCommandError('You can only supply one of revision_id or --revision')
1942
if revision_id is None and revision is None:
1943
raise BzrCommandError('You must supply either --revision or a revision_id')
1944
b = WorkingTree.open_containing(u'.')[0].branch
1945
gpg_strategy = gpg.GPGStrategy(config.BranchConfig(b))
1946
if revision_id is not None:
1947
b.repository.sign_revision(revision_id, gpg_strategy)
1948
elif revision is not None:
1949
if len(revision) == 1:
1950
revno, rev_id = revision[0].in_history(b)
1951
b.repository.sign_revision(rev_id, gpg_strategy)
1952
elif len(revision) == 2:
1953
# are they both on rh- if so we can walk between them
1954
# might be nice to have a range helper for arbitrary
1955
# revision paths. hmm.
1956
from_revno, from_revid = revision[0].in_history(b)
1957
to_revno, to_revid = revision[1].in_history(b)
1958
if to_revid is None:
1959
to_revno = b.revno()
1960
if from_revno is None or to_revno is None:
1961
raise BzrCommandError('Cannot sign a range of non-revision-history revisions')
1962
for revno in range(from_revno, to_revno + 1):
1963
b.repository.sign_revision(b.get_rev_id(revno),
1964
gpg_strategy)
1965
else:
1966
raise BzrCommandError('Please supply either one revision, or a range.')
1967
1968
1969
class cmd_uncommit(bzrlib.commands.Command):
1970
"""Remove the last committed revision.
1971
1972
By supplying the --all flag, it will not only remove the entry
1973
from revision_history, but also remove all of the entries in the
1974
stores.
1975
1976
--verbose will print out what is being removed.
1977
--dry-run will go through all the motions, but not actually
1978
remove anything.
1979
1980
In the future, uncommit will create a changeset, which can then
1981
be re-applied.
1982
"""
1983
takes_options = ['all', 'verbose', 'revision',
1984
Option('dry-run', help='Don\'t actually make changes'),
1985
Option('force', help='Say yes to all questions.')]
1986
takes_args = ['location?']
1987
aliases = []
1988
1989
def run(self, location=None, all=False,
1990
dry_run=False, verbose=False,
1991
revision=None, force=False):
1992
from bzrlib.branch import Branch
1993
from bzrlib.log import log_formatter
1994
import sys
1995
from bzrlib.uncommit import uncommit
1996
1997
if location is None:
1998
location = u'.'
1999
b, relpath = Branch.open_containing(location)
2000
2001
if revision is None:
2002
revno = b.revno()
2003
rev_id = b.last_revision()
2004
else:
2005
revno, rev_id = revision[0].in_history(b)
2006
if rev_id is None:
2007
print 'No revisions to uncommit.'
2008
2009
for r in range(revno, b.revno()+1):
2010
rev_id = b.get_rev_id(r)
2011
lf = log_formatter('short', to_file=sys.stdout,show_timezone='original')
2012
lf.show(r, b.repository.get_revision(rev_id), None)
2013
2014
if dry_run:
2015
print 'Dry-run, pretending to remove the above revisions.'
2016
if not force:
2017
val = raw_input('Press <enter> to continue')
2018
else:
2019
print 'The above revision(s) will be removed.'
2020
if not force:
2021
val = raw_input('Are you sure [y/N]? ')
2022
if val.lower() not in ('y', 'yes'):
2023
print 'Canceled'
2024
return 0
2025
2026
uncommit(b, remove_files=all,
2027
dry_run=dry_run, verbose=verbose,
2028
revno=revno)
2029
2030
2031
# these get imported and then picked up by the scan for cmd_*
2032
# TODO: Some more consistent way to split command definitions across files;
2033
# we do need to load at least some information about them to know of
2034
# aliases.
2035
from bzrlib.conflicts import cmd_resolve, cmd_conflicts, restore
Loggerhead is a web-based interface for Breezy
Version: 2.0.1