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