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