To get this branch, use:
bzr branch
http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar
« back to all changes in this revision
Viewing changes to bzrlib/builtins.py
- browse files at revision 2256.2.3
- compare with another revision
- download diff
- download tarball
- view history from revision 2256.2.3
- Committer: Robert Collins
- Date: 2007-02-02 20:27:53 UTC
- mto: (2257.1.1 integration)
- mto: This revision was merged to the branch mainline in revision 2258.
- Revision ID: robertc@robertcollins.net-20070202202753-uu1ixgssi7471vi9
Review feedback.
- files added:
- .bzrignore
- bzrlib
- bzrlib/benchmarks
- bzrlib/benchmarks/tree_creator
- bzrlib/bundle
- bzrlib/bundle/old
- bzrlib/bundle/serializer
- bzrlib/doc
- bzrlib/doc/api
- bzrlib/export
- bzrlib/plugins
- bzrlib/plugins/launchpad
- bzrlib/repofmt
- 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/intertree_implementations
- bzrlib/tests/interversionedfile_implementations
- bzrlib/tests/repository_implementations
- bzrlib/tests/revisionstore_implementations
- bzrlib/tests/test_patches_data
- bzrlib/tests/tree_implementations
- bzrlib/tests/workingtree_implementations
- bzrlib/transport
- bzrlib/transport/http
- bzrlib/ui
- bzrlib/util
- bzrlib/util/configobj
- bzrlib/util/configobj/docs
- bzrlib/util/effbot
- bzrlib/util/effbot/org
- bzrlib/util/elementtree
- bzrlib/version_info_formats
- contrib
- contrib/bash
- contrib/emacs
- contrib/zsh
- doc
- tools
- tools/doc_generate
- tools/win32
- files removed:
- .bzrignore
- notes
- tests
added
removed
bzrlib/builtins.py
1
# Copyright (C) 2004, 2005, 2006 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
import os
20
21
from bzrlib.lazy_import import lazy_import
22
lazy_import(globals(), """
23
import codecs
24
import errno
25
import sys
26
import tempfile
27
28
import bzrlib
29
from bzrlib import (
30
branch,
31
bundle,
32
bzrdir,
33
delta,
34
config,
35
errors,
36
ignores,
37
log,
38
merge as _mod_merge,
39
osutils,
40
repository,
41
symbol_versioning,
42
transport,
43
tree as _mod_tree,
44
ui,
45
urlutils,
46
)
47
from bzrlib.branch import Branch
48
from bzrlib.bundle.apply_bundle import install_bundle, merge_bundle
49
from bzrlib.conflicts import ConflictList
50
from bzrlib.revision import common_ancestor
51
from bzrlib.revisionspec import RevisionSpec
52
from bzrlib.workingtree import WorkingTree
53
""")
54
55
from bzrlib.commands import Command, display_command
56
from bzrlib.option import Option, RegistryOption
57
from bzrlib.progress import DummyProgress, ProgressPhase
58
from bzrlib.trace import mutter, note, log_error, warning, is_quiet, info
59
60
61
def tree_files(file_list, default_branch=u'.'):
62
try:
63
return internal_tree_files(file_list, default_branch)
64
except errors.FileInWrongBranch, e:
65
raise errors.BzrCommandError("%s is not in the same branch as %s" %
66
(e.path, file_list[0]))
67
68
69
# XXX: Bad function name; should possibly also be a class method of
70
# WorkingTree rather than a function.
71
def internal_tree_files(file_list, default_branch=u'.'):
72
"""Convert command-line paths to a WorkingTree and relative paths.
73
74
This is typically used for command-line processors that take one or
75
more filenames, and infer the workingtree that contains them.
76
77
The filenames given are not required to exist.
78
79
:param file_list: Filenames to convert.
80
81
:param default_branch: Fallback tree path to use if file_list is empty or
82
None.
83
84
:return: workingtree, [relative_paths]
85
"""
86
if file_list is None or len(file_list) == 0:
87
return WorkingTree.open_containing(default_branch)[0], file_list
88
tree = WorkingTree.open_containing(osutils.realpath(file_list[0]))[0]
89
new_list = []
90
for filename in file_list:
91
try:
92
new_list.append(tree.relpath(osutils.dereference_path(filename)))
93
except errors.PathNotChild:
94
raise errors.FileInWrongBranch(tree.branch, filename)
95
return tree, new_list
96
97
98
@symbol_versioning.deprecated_function(symbol_versioning.zero_fifteen)
99
def get_format_type(typestring):
100
"""Parse and return a format specifier."""
101
# Have to use BzrDirMetaFormat1 directly, so that
102
# RepositoryFormat.set_default_format works
103
if typestring == "default":
104
return bzrdir.BzrDirMetaFormat1()
105
try:
106
return bzrdir.format_registry.make_bzrdir(typestring)
107
except KeyError:
108
msg = 'Unknown bzr format "%s". See "bzr help formats".' % typestring
109
raise errors.BzrCommandError(msg)
110
111
112
# TODO: Make sure no commands unconditionally use the working directory as a
113
# branch. If a filename argument is used, the first of them should be used to
114
# specify the branch. (Perhaps this can be factored out into some kind of
115
# Argument class, representing a file in a branch, where the first occurrence
116
# opens the branch?)
117
118
class cmd_status(Command):
119
"""Display status summary.
120
121
This reports on versioned and unknown files, reporting them
122
grouped by state. Possible states are:
123
124
added / A
125
Versioned in the working copy but not in the previous revision.
126
127
removed / D
128
Versioned in the previous revision but removed or deleted
129
in the working copy.
130
131
renamed / R
132
Path of this file changed from the previous revision;
133
the text may also have changed. This includes files whose
134
parent directory was renamed.
135
136
modified / M
137
Text has changed since the previous revision.
138
139
unknown / ?
140
Not versioned and not matching an ignore pattern.
141
142
To see ignored files use 'bzr ignored'. For details in the
143
changes to file texts, use 'bzr diff'.
144
145
--short gives a one character status flag for each item, similar
146
to the SVN's status command.
147
148
If no arguments are specified, the status of the entire working
149
directory is shown. Otherwise, only the status of the specified
150
files or directories is reported. If a directory is given, status
151
is reported for everything inside that directory.
152
153
If a revision argument is given, the status is calculated against
154
that revision, or between two revisions if two are provided.
155
"""
156
157
# TODO: --no-recurse, --recurse options
158
159
takes_args = ['file*']
160
takes_options = ['show-ids', 'revision', 'short']
161
aliases = ['st', 'stat']
162
163
encoding_type = 'replace'
164
165
@display_command
166
def run(self, show_ids=False, file_list=None, revision=None, short=False):
167
from bzrlib.status import show_tree_status
168
169
tree, file_list = tree_files(file_list)
170
171
show_tree_status(tree, show_ids=show_ids,
172
specific_files=file_list, revision=revision,
173
to_file=self.outf,
174
short=short)
175
176
177
class cmd_cat_revision(Command):
178
"""Write out metadata for a revision.
179
180
The revision to print can either be specified by a specific
181
revision identifier, or you can use --revision.
182
"""
183
184
hidden = True
185
takes_args = ['revision_id?']
186
takes_options = ['revision']
187
# cat-revision is more for frontends so should be exact
188
encoding = 'strict'
189
190
@display_command
191
def run(self, revision_id=None, revision=None):
192
193
if revision_id is not None and revision is not None:
194
raise errors.BzrCommandError('You can only supply one of'
195
' revision_id or --revision')
196
if revision_id is None and revision is None:
197
raise errors.BzrCommandError('You must supply either'
198
' --revision or a revision_id')
199
b = WorkingTree.open_containing(u'.')[0].branch
200
201
# TODO: jam 20060112 should cat-revision always output utf-8?
202
if revision_id is not None:
203
self.outf.write(b.repository.get_revision_xml(revision_id).decode('utf-8'))
204
elif revision is not None:
205
for rev in revision:
206
if rev is None:
207
raise errors.BzrCommandError('You cannot specify a NULL'
208
' revision.')
209
revno, rev_id = rev.in_history(b)
210
self.outf.write(b.repository.get_revision_xml(rev_id).decode('utf-8'))
211
212
213
class cmd_remove_tree(Command):
214
"""Remove the working tree from a given branch/checkout.
215
216
Since a lightweight checkout is little more than a working tree
217
this will refuse to run against one.
218
"""
219
220
hidden = True
221
222
takes_args = ['location?']
223
224
def run(self, location='.'):
225
d = bzrdir.BzrDir.open(location)
226
227
try:
228
working = d.open_workingtree()
229
except errors.NoWorkingTree:
230
raise errors.BzrCommandError("No working tree to remove")
231
except errors.NotLocalUrl:
232
raise errors.BzrCommandError("You cannot remove the working tree of a "
233
"remote path")
234
235
working_path = working.bzrdir.root_transport.base
236
branch_path = working.branch.bzrdir.root_transport.base
237
if working_path != branch_path:
238
raise errors.BzrCommandError("You cannot remove the working tree from "
239
"a lightweight checkout")
240
241
d.destroy_workingtree()
242
243
244
class cmd_revno(Command):
245
"""Show current revision number.
246
247
This is equal to the number of revisions on this branch.
248
"""
249
250
takes_args = ['location?']
251
252
@display_command
253
def run(self, location=u'.'):
254
self.outf.write(str(Branch.open_containing(location)[0].revno()))
255
self.outf.write('\n')
256
257
258
class cmd_revision_info(Command):
259
"""Show revision number and revision id for a given revision identifier.
260
"""
261
hidden = True
262
takes_args = ['revision_info*']
263
takes_options = ['revision']
264
265
@display_command
266
def run(self, revision=None, revision_info_list=[]):
267
268
revs = []
269
if revision is not None:
270
revs.extend(revision)
271
if revision_info_list is not None:
272
for rev in revision_info_list:
273
revs.append(RevisionSpec.from_string(rev))
274
if len(revs) == 0:
275
raise errors.BzrCommandError('You must supply a revision identifier')
276
277
b = WorkingTree.open_containing(u'.')[0].branch
278
279
for rev in revs:
280
revinfo = rev.in_history(b)
281
if revinfo.revno is None:
282
print ' %s' % revinfo.rev_id
283
else:
284
print '%4d %s' % (revinfo.revno, revinfo.rev_id)
285
286
287
class cmd_add(Command):
288
"""Add specified files or directories.
289
290
In non-recursive mode, all the named items are added, regardless
291
of whether they were previously ignored. A warning is given if
292
any of the named files are already versioned.
293
294
In recursive mode (the default), files are treated the same way
295
but the behaviour for directories is different. Directories that
296
are already versioned do not give a warning. All directories,
297
whether already versioned or not, are searched for files or
298
subdirectories that are neither versioned or ignored, and these
299
are added. This search proceeds recursively into versioned
300
directories. If no names are given '.' is assumed.
301
302
Therefore simply saying 'bzr add' will version all files that
303
are currently unknown.
304
305
Adding a file whose parent directory is not versioned will
306
implicitly add the parent, and so on up to the root. This means
307
you should never need to explicitly add a directory, they'll just
308
get added when you add a file in the directory.
309
310
--dry-run will show which files would be added, but not actually
311
add them.
312
313
--file-ids-from will try to use the file ids from the supplied path.
314
It looks up ids trying to find a matching parent directory with the
315
same filename, and then by pure path.
316
"""
317
takes_args = ['file*']
318
takes_options = ['no-recurse', 'dry-run', 'verbose',
319
Option('file-ids-from', type=unicode,
320
help='Lookup file ids from here')]
321
encoding_type = 'replace'
322
323
def run(self, file_list, no_recurse=False, dry_run=False, verbose=False,
324
file_ids_from=None):
325
import bzrlib.add
326
327
if file_ids_from is not None:
328
try:
329
base_tree, base_path = WorkingTree.open_containing(
330
file_ids_from)
331
except errors.NoWorkingTree:
332
base_branch, base_path = Branch.open_containing(
333
file_ids_from)
334
base_tree = base_branch.basis_tree()
335
336
action = bzrlib.add.AddFromBaseAction(base_tree, base_path,
337
to_file=self.outf, should_print=(not is_quiet()))
338
else:
339
action = bzrlib.add.AddAction(to_file=self.outf,
340
should_print=(not is_quiet()))
341
342
added, ignored = bzrlib.add.smart_add(file_list, not no_recurse,
343
action=action, save=not dry_run)
344
if len(ignored) > 0:
345
if verbose:
346
for glob in sorted(ignored.keys()):
347
for path in ignored[glob]:
348
self.outf.write("ignored %s matching \"%s\"\n"
349
% (path, glob))
350
else:
351
match_len = 0
352
for glob, paths in ignored.items():
353
match_len += len(paths)
354
self.outf.write("ignored %d file(s).\n" % match_len)
355
self.outf.write("If you wish to add some of these files,"
356
" please add them by name.\n")
357
358
359
class cmd_mkdir(Command):
360
"""Create a new versioned directory.
361
362
This is equivalent to creating the directory and then adding it.
363
"""
364
365
takes_args = ['dir+']
366
encoding_type = 'replace'
367
368
def run(self, dir_list):
369
for d in dir_list:
370
os.mkdir(d)
371
wt, dd = WorkingTree.open_containing(d)
372
wt.add([dd])
373
self.outf.write('added %s\n' % d)
374
375
376
class cmd_relpath(Command):
377
"""Show path of a file relative to root"""
378
379
takes_args = ['filename']
380
hidden = True
381
382
@display_command
383
def run(self, filename):
384
# TODO: jam 20050106 Can relpath return a munged path if
385
# sys.stdout encoding cannot represent it?
386
tree, relpath = WorkingTree.open_containing(filename)
387
self.outf.write(relpath)
388
self.outf.write('\n')
389
390
391
class cmd_inventory(Command):
392
"""Show inventory of the current working copy or a revision.
393
394
It is possible to limit the output to a particular entry
395
type using the --kind option. For example: --kind file.
396
397
It is also possible to restrict the list of files to a specific
398
set. For example: bzr inventory --show-ids this/file
399
"""
400
401
takes_options = ['revision', 'show-ids', 'kind']
402
takes_args = ['file*']
403
404
@display_command
405
def run(self, revision=None, show_ids=False, kind=None, file_list=None):
406
if kind and kind not in ['file', 'directory', 'symlink']:
407
raise errors.BzrCommandError('invalid kind specified')
408
409
work_tree, file_list = tree_files(file_list)
410
411
if revision is not None:
412
if len(revision) > 1:
413
raise errors.BzrCommandError('bzr inventory --revision takes'
414
' exactly one revision identifier')
415
revision_id = revision[0].in_history(work_tree.branch).rev_id
416
tree = work_tree.branch.repository.revision_tree(revision_id)
417
418
# We include work_tree as well as 'tree' here
419
# So that doing '-r 10 path/foo' will lookup whatever file
420
# exists now at 'path/foo' even if it has been renamed, as
421
# well as whatever files existed in revision 10 at path/foo
422
trees = [tree, work_tree]
423
else:
424
tree = work_tree
425
trees = [tree]
426
427
if file_list is not None:
428
file_ids = _mod_tree.find_ids_across_trees(file_list, trees,
429
require_versioned=True)
430
# find_ids_across_trees may include some paths that don't
431
# exist in 'tree'.
432
entries = sorted((tree.id2path(file_id), tree.inventory[file_id])
433
for file_id in file_ids if file_id in tree)
434
else:
435
entries = tree.inventory.entries()
436
437
for path, entry in entries:
438
if kind and kind != entry.kind:
439
continue
440
if show_ids:
441
self.outf.write('%-50s %s\n' % (path, entry.file_id))
442
else:
443
self.outf.write(path)
444
self.outf.write('\n')
445
446
447
class cmd_mv(Command):
448
"""Move or rename a file.
449
450
usage:
451
bzr mv OLDNAME NEWNAME
452
bzr mv SOURCE... DESTINATION
453
454
If the last argument is a versioned directory, all the other names
455
are moved into it. Otherwise, there must be exactly two arguments
456
and the file is changed to a new name.
457
458
If OLDNAME does not exist on the filesystem but is versioned and
459
NEWNAME does exist on the filesystem but is not versioned, mv
460
assumes that the file has been manually moved and only updates
461
its internal inventory to reflect that change.
462
The same is valid when moving many SOURCE files to a DESTINATION.
463
464
Files cannot be moved between branches.
465
"""
466
467
takes_args = ['names*']
468
takes_options = [Option("after", help="move only the bzr identifier"
469
" of the file (file has already been moved). Use this flag if"
470
" bzr is not able to detect this itself.")]
471
aliases = ['move', 'rename']
472
encoding_type = 'replace'
473
474
def run(self, names_list, after=False):
475
if names_list is None:
476
names_list = []
477
478
if len(names_list) < 2:
479
raise errors.BzrCommandError("missing file argument")
480
tree, rel_names = tree_files(names_list)
481
482
if os.path.isdir(names_list[-1]):
483
# move into existing directory
484
for pair in tree.move(rel_names[:-1], rel_names[-1], after=after):
485
self.outf.write("%s => %s\n" % pair)
486
else:
487
if len(names_list) != 2:
488
raise errors.BzrCommandError('to mv multiple files the'
489
' destination must be a versioned'
490
' directory')
491
tree.rename_one(rel_names[0], rel_names[1], after=after)
492
self.outf.write("%s => %s\n" % (rel_names[0], rel_names[1]))
493
494
495
class cmd_pull(Command):
496
"""Turn this branch into a mirror of another branch.
497
498
This command only works on branches that have not diverged. Branches are
499
considered diverged if the destination branch's most recent commit is one
500
that has not been merged (directly or indirectly) into the parent.
501
502
If branches have diverged, you can use 'bzr merge' to integrate the changes
503
from one into the other. Once one branch has merged, the other should
504
be able to pull it again.
505
506
If you want to forget your local changes and just update your branch to
507
match the remote one, use pull --overwrite.
508
509
If there is no default location set, the first pull will set it. After
510
that, you can omit the location to use the default. To change the
511
default, use --remember. The value will only be saved if the remote
512
location can be accessed.
513
"""
514
515
takes_options = ['remember', 'overwrite', 'revision', 'verbose']
516
takes_args = ['location?']
517
encoding_type = 'replace'
518
519
def run(self, location=None, remember=False, overwrite=False, revision=None, verbose=False):
520
# FIXME: too much stuff is in the command class
521
try:
522
tree_to = WorkingTree.open_containing(u'.')[0]
523
branch_to = tree_to.branch
524
except errors.NoWorkingTree:
525
tree_to = None
526
branch_to = Branch.open_containing(u'.')[0]
527
528
reader = None
529
if location is not None:
530
try:
531
reader = bundle.read_bundle_from_url(location)
532
except errors.NotABundle:
533
pass # Continue on considering this url a Branch
534
535
stored_loc = branch_to.get_parent()
536
if location is None:
537
if stored_loc is None:
538
raise errors.BzrCommandError("No pull location known or"
539
" specified.")
540
else:
541
display_url = urlutils.unescape_for_display(stored_loc,
542
self.outf.encoding)
543
self.outf.write("Using saved location: %s\n" % display_url)
544
location = stored_loc
545
546
547
if reader is not None:
548
install_bundle(branch_to.repository, reader)
549
branch_from = branch_to
550
else:
551
branch_from = Branch.open(location)
552
553
if branch_to.get_parent() is None or remember:
554
branch_to.set_parent(branch_from.base)
555
556
rev_id = None
557
if revision is None:
558
if reader is not None:
559
rev_id = reader.target
560
elif len(revision) == 1:
561
rev_id = revision[0].in_history(branch_from).rev_id
562
else:
563
raise errors.BzrCommandError('bzr pull --revision takes one value.')
564
565
old_rh = branch_to.revision_history()
566
if tree_to is not None:
567
count = tree_to.pull(branch_from, overwrite, rev_id)
568
else:
569
count = branch_to.pull(branch_from, overwrite, rev_id)
570
note('%d revision(s) pulled.' % (count,))
571
572
if verbose:
573
new_rh = branch_to.revision_history()
574
if old_rh != new_rh:
575
# Something changed
576
from bzrlib.log import show_changed_revisions
577
show_changed_revisions(branch_to, old_rh, new_rh,
578
to_file=self.outf)
579
580
581
class cmd_push(Command):
582
"""Update a mirror of this branch.
583
584
The target branch will not have its working tree populated because this
585
is both expensive, and is not supported on remote file systems.
586
587
Some smart servers or protocols *may* put the working tree in place in
588
the future.
589
590
This command only works on branches that have not diverged. Branches are
591
considered diverged if the destination branch's most recent commit is one
592
that has not been merged (directly or indirectly) by the source branch.
593
594
If branches have diverged, you can use 'bzr push --overwrite' to replace
595
the other branch completely, discarding its unmerged changes.
596
597
If you want to ensure you have the different changes in the other branch,
598
do a merge (see bzr help merge) from the other branch, and commit that.
599
After that you will be able to do a push without '--overwrite'.
600
601
If there is no default push location set, the first push will set it.
602
After that, you can omit the location to use the default. To change the
603
default, use --remember. The value will only be saved if the remote
604
location can be accessed.
605
"""
606
607
takes_options = ['remember', 'overwrite', 'verbose',
608
Option('create-prefix',
609
help='Create the path leading up to the branch '
610
'if it does not already exist')]
611
takes_args = ['location?']
612
encoding_type = 'replace'
613
614
def run(self, location=None, remember=False, overwrite=False,
615
create_prefix=False, verbose=False):
616
# FIXME: Way too big! Put this into a function called from the
617
# command.
618
619
br_from = Branch.open_containing('.')[0]
620
stored_loc = br_from.get_push_location()
621
if location is None:
622
if stored_loc is None:
623
raise errors.BzrCommandError("No push location known or specified.")
624
else:
625
display_url = urlutils.unescape_for_display(stored_loc,
626
self.outf.encoding)
627
self.outf.write("Using saved location: %s\n" % display_url)
628
location = stored_loc
629
630
to_transport = transport.get_transport(location)
631
location_url = to_transport.base
632
633
old_rh = []
634
try:
635
dir_to = bzrdir.BzrDir.open(location_url)
636
br_to = dir_to.open_branch()
637
except errors.NotBranchError:
638
# create a branch.
639
to_transport = to_transport.clone('..')
640
if not create_prefix:
641
try:
642
relurl = to_transport.relpath(location_url)
643
mutter('creating directory %s => %s', location_url, relurl)
644
to_transport.mkdir(relurl)
645
except errors.NoSuchFile:
646
raise errors.BzrCommandError("Parent directory of %s "
647
"does not exist." % location)
648
else:
649
current = to_transport.base
650
needed = [(to_transport, to_transport.relpath(location_url))]
651
while needed:
652
try:
653
to_transport, relpath = needed[-1]
654
to_transport.mkdir(relpath)
655
needed.pop()
656
except errors.NoSuchFile:
657
new_transport = to_transport.clone('..')
658
needed.append((new_transport,
659
new_transport.relpath(to_transport.base)))
660
if new_transport.base == to_transport.base:
661
raise errors.BzrCommandError("Could not create "
662
"path prefix.")
663
dir_to = br_from.bzrdir.clone(location_url,
664
revision_id=br_from.last_revision())
665
br_to = dir_to.open_branch()
666
count = len(br_to.revision_history())
667
# We successfully created the target, remember it
668
if br_from.get_push_location() is None or remember:
669
br_from.set_push_location(br_to.base)
670
else:
671
# We were able to connect to the remote location, so remember it
672
# we don't need to successfully push because of possible divergence.
673
if br_from.get_push_location() is None or remember:
674
br_from.set_push_location(br_to.base)
675
old_rh = br_to.revision_history()
676
try:
677
try:
678
tree_to = dir_to.open_workingtree()
679
except errors.NotLocalUrl:
680
warning('This transport does not update the working '
681
'tree of: %s' % (br_to.base,))
682
count = br_from.push(br_to, overwrite)
683
except errors.NoWorkingTree:
684
count = br_from.push(br_to, overwrite)
685
else:
686
tree_to.lock_write()
687
try:
688
count = br_from.push(tree_to.branch, overwrite)
689
tree_to.update()
690
finally:
691
tree_to.unlock()
692
except errors.DivergedBranches:
693
raise errors.BzrCommandError('These branches have diverged.'
694
' Try using "merge" and then "push".')
695
note('%d revision(s) pushed.' % (count,))
696
697
if verbose:
698
new_rh = br_to.revision_history()
699
if old_rh != new_rh:
700
# Something changed
701
from bzrlib.log import show_changed_revisions
702
show_changed_revisions(br_to, old_rh, new_rh,
703
to_file=self.outf)
704
705
706
class cmd_branch(Command):
707
"""Create a new copy of a branch.
708
709
If the TO_LOCATION is omitted, the last component of the FROM_LOCATION will
710
be used. In other words, "branch ../foo/bar" will attempt to create ./bar.
711
712
To retrieve the branch as of a particular revision, supply the --revision
713
parameter, as in "branch foo/bar -r 5".
714
715
--basis is to speed up branching from remote branches. When specified, it
716
copies all the file-contents, inventory and revision data from the basis
717
branch before copying anything from the remote branch.
718
"""
719
takes_args = ['from_location', 'to_location?']
720
takes_options = ['revision', 'basis']
721
aliases = ['get', 'clone']
722
723
def run(self, from_location, to_location=None, revision=None, basis=None):
724
if revision is None:
725
revision = [None]
726
elif len(revision) > 1:
727
raise errors.BzrCommandError(
728
'bzr branch --revision takes exactly 1 revision value')
729
try:
730
br_from = Branch.open(from_location)
731
except OSError, e:
732
if e.errno == errno.ENOENT:
733
raise errors.BzrCommandError('Source location "%s" does not'
734
' exist.' % to_location)
735
else:
736
raise
737
br_from.lock_read()
738
try:
739
if basis is not None:
740
basis_dir = bzrdir.BzrDir.open_containing(basis)[0]
741
else:
742
basis_dir = None
743
if len(revision) == 1 and revision[0] is not None:
744
revision_id = revision[0].in_history(br_from)[1]
745
else:
746
# FIXME - wt.last_revision, fallback to branch, fall back to
747
# None or perhaps NULL_REVISION to mean copy nothing
748
# RBC 20060209
749
revision_id = br_from.last_revision()
750
if to_location is None:
751
to_location = os.path.basename(from_location.rstrip("/\\"))
752
name = None
753
else:
754
name = os.path.basename(to_location) + '\n'
755
756
to_transport = transport.get_transport(to_location)
757
try:
758
to_transport.mkdir('.')
759
except errors.FileExists:
760
raise errors.BzrCommandError('Target directory "%s" already'
761
' exists.' % to_location)
762
except errors.NoSuchFile:
763
raise errors.BzrCommandError('Parent of "%s" does not exist.'
764
% to_location)
765
try:
766
# preserve whatever source format we have.
767
dir = br_from.bzrdir.sprout(to_transport.base,
768
revision_id, basis_dir)
769
branch = dir.open_branch()
770
except errors.NoSuchRevision:
771
to_transport.delete_tree('.')
772
msg = "The branch %s has no revision %s." % (from_location, revision[0])
773
raise errors.BzrCommandError(msg)
774
except errors.UnlistableBranch:
775
osutils.rmtree(to_location)
776
msg = "The branch %s cannot be used as a --basis" % (basis,)
777
raise errors.BzrCommandError(msg)
778
if name:
779
branch.control_files.put_utf8('branch-name', name)
780
note('Branched %d revision(s).' % branch.revno())
781
finally:
782
br_from.unlock()
783
784
785
class cmd_checkout(Command):
786
"""Create a new checkout of an existing branch.
787
788
If BRANCH_LOCATION is omitted, checkout will reconstitute a working tree for
789
the branch found in '.'. This is useful if you have removed the working tree
790
or if it was never created - i.e. if you pushed the branch to its current
791
location using SFTP.
792
793
If the TO_LOCATION is omitted, the last component of the BRANCH_LOCATION will
794
be used. In other words, "checkout ../foo/bar" will attempt to create ./bar.
795
796
To retrieve the branch as of a particular revision, supply the --revision
797
parameter, as in "checkout foo/bar -r 5". Note that this will be immediately
798
out of date [so you cannot commit] but it may be useful (i.e. to examine old
799
code.)
800
801
--basis is to speed up checking out from remote branches. When specified, it
802
uses the inventory and file contents from the basis branch in preference to the
803
branch being checked out.
804
"""
805
takes_args = ['branch_location?', 'to_location?']
806
takes_options = ['revision', # , 'basis']
807
Option('lightweight',
808
help="perform a lightweight checkout. Lightweight "
809
"checkouts depend on access to the branch for "
810
"every operation. Normal checkouts can perform "
811
"common operations like diff and status without "
812
"such access, and also support local commits."
813
),
814
]
815
aliases = ['co']
816
817
def run(self, branch_location=None, to_location=None, revision=None, basis=None,
818
lightweight=False):
819
if revision is None:
820
revision = [None]
821
elif len(revision) > 1:
822
raise errors.BzrCommandError(
823
'bzr checkout --revision takes exactly 1 revision value')
824
if branch_location is None:
825
branch_location = osutils.getcwd()
826
to_location = branch_location
827
source = Branch.open(branch_location)
828
if len(revision) == 1 and revision[0] is not None:
829
revision_id = revision[0].in_history(source)[1]
830
else:
831
revision_id = None
832
if to_location is None:
833
to_location = os.path.basename(branch_location.rstrip("/\\"))
834
# if the source and to_location are the same,
835
# and there is no working tree,
836
# then reconstitute a branch
837
if (osutils.abspath(to_location) ==
838
osutils.abspath(branch_location)):
839
try:
840
source.bzrdir.open_workingtree()
841
except errors.NoWorkingTree:
842
source.bzrdir.create_workingtree()
843
return
844
try:
845
os.mkdir(to_location)
846
except OSError, e:
847
if e.errno == errno.EEXIST:
848
raise errors.BzrCommandError('Target directory "%s" already'
849
' exists.' % to_location)
850
if e.errno == errno.ENOENT:
851
raise errors.BzrCommandError('Parent of "%s" does not exist.'
852
% to_location)
853
else:
854
raise
855
source.create_checkout(to_location, revision_id, lightweight)
856
857
858
class cmd_renames(Command):
859
"""Show list of renamed files.
860
"""
861
# TODO: Option to show renames between two historical versions.
862
863
# TODO: Only show renames under dir, rather than in the whole branch.
864
takes_args = ['dir?']
865
866
@display_command
867
def run(self, dir=u'.'):
868
tree = WorkingTree.open_containing(dir)[0]
869
old_inv = tree.basis_tree().inventory
870
new_inv = tree.read_working_inventory()
871
renames = list(_mod_tree.find_renames(old_inv, new_inv))
872
renames.sort()
873
for old_name, new_name in renames:
874
self.outf.write("%s => %s\n" % (old_name, new_name))
875
876
877
class cmd_update(Command):
878
"""Update a tree to have the latest code committed to its branch.
879
880
This will perform a merge into the working tree, and may generate
881
conflicts. If you have any local changes, you will still
882
need to commit them after the update for the update to be complete.
883
884
If you want to discard your local changes, you can just do a
885
'bzr revert' instead of 'bzr commit' after the update.
886
"""
887
takes_args = ['dir?']
888
aliases = ['up']
889
890
def run(self, dir='.'):
891
tree = WorkingTree.open_containing(dir)[0]
892
master = tree.branch.get_master_branch()
893
if master is not None:
894
tree.lock_write()
895
else:
896
tree.lock_tree_write()
897
try:
898
existing_pending_merges = tree.get_parent_ids()[1:]
899
last_rev = tree.last_revision()
900
if last_rev == tree.branch.last_revision():
901
# may be up to date, check master too.
902
master = tree.branch.get_master_branch()
903
if master is None or last_rev == master.last_revision():
904
revno = tree.branch.revision_id_to_revno(last_rev)
905
note("Tree is up to date at revision %d." % (revno,))
906
return 0
907
conflicts = tree.update()
908
revno = tree.branch.revision_id_to_revno(tree.last_revision())
909
note('Updated to revision %d.' % (revno,))
910
if tree.get_parent_ids()[1:] != existing_pending_merges:
911
note('Your local commits will now show as pending merges with '
912
"'bzr status', and can be committed with 'bzr commit'.")
913
if conflicts != 0:
914
return 1
915
else:
916
return 0
917
finally:
918
tree.unlock()
919
920
921
class cmd_info(Command):
922
"""Show information about a working tree, branch or repository.
923
924
This command will show all known locations and formats associated to the
925
tree, branch or repository. Statistical information is included with
926
each report.
927
928
Branches and working trees will also report any missing revisions.
929
"""
930
takes_args = ['location?']
931
takes_options = ['verbose']
932
933
@display_command
934
def run(self, location=None, verbose=False):
935
from bzrlib.info import show_bzrdir_info
936
show_bzrdir_info(bzrdir.BzrDir.open_containing(location)[0],
937
verbose=verbose)
938
939
940
class cmd_remove(Command):
941
"""Make a file unversioned.
942
943
This makes bzr stop tracking changes to a versioned file. It does
944
not delete the working copy.
945
946
You can specify one or more files, and/or --new. If you specify --new,
947
only 'added' files will be removed. If you specify both, then new files
948
in the specified directories will be removed. If the directories are
949
also new, they will also be removed.
950
"""
951
takes_args = ['file*']
952
takes_options = ['verbose', Option('new', help='remove newly-added files')]
953
aliases = ['rm']
954
encoding_type = 'replace'
955
956
def run(self, file_list, verbose=False, new=False):
957
tree, file_list = tree_files(file_list)
958
if new is False:
959
if file_list is None:
960
raise errors.BzrCommandError('Specify one or more files to'
961
' remove, or use --new.')
962
else:
963
added = tree.changes_from(tree.basis_tree(),
964
specific_files=file_list).added
965
file_list = sorted([f[0] for f in added], reverse=True)
966
if len(file_list) == 0:
967
raise errors.BzrCommandError('No matching files.')
968
tree.remove(file_list, verbose=verbose, to_file=self.outf)
969
970
971
class cmd_file_id(Command):
972
"""Print file_id of a particular file or directory.
973
974
The file_id is assigned when the file is first added and remains the
975
same through all revisions where the file exists, even when it is
976
moved or renamed.
977
"""
978
979
hidden = True
980
takes_args = ['filename']
981
982
@display_command
983
def run(self, filename):
984
tree, relpath = WorkingTree.open_containing(filename)
985
i = tree.inventory.path2id(relpath)
986
if i is None:
987
raise errors.NotVersionedError(filename)
988
else:
989
self.outf.write(i + '\n')
990
991
992
class cmd_file_path(Command):
993
"""Print path of file_ids to a file or directory.
994
995
This prints one line for each directory down to the target,
996
starting at the branch root.
997
"""
998
999
hidden = True
1000
takes_args = ['filename']
1001
1002
@display_command
1003
def run(self, filename):
1004
tree, relpath = WorkingTree.open_containing(filename)
1005
inv = tree.inventory
1006
fid = inv.path2id(relpath)
1007
if fid is None:
1008
raise errors.NotVersionedError(filename)
1009
for fip in inv.get_idpath(fid):
1010
self.outf.write(fip + '\n')
1011
1012
1013
class cmd_reconcile(Command):
1014
"""Reconcile bzr metadata in a branch.
1015
1016
This can correct data mismatches that may have been caused by
1017
previous ghost operations or bzr upgrades. You should only
1018
need to run this command if 'bzr check' or a bzr developer
1019
advises you to run it.
1020
1021
If a second branch is provided, cross-branch reconciliation is
1022
also attempted, which will check that data like the tree root
1023
id which was not present in very early bzr versions is represented
1024
correctly in both branches.
1025
1026
At the same time it is run it may recompress data resulting in
1027
a potential saving in disk space or performance gain.
1028
1029
The branch *MUST* be on a listable system such as local disk or sftp.
1030
"""
1031
takes_args = ['branch?']
1032
1033
def run(self, branch="."):
1034
from bzrlib.reconcile import reconcile
1035
dir = bzrdir.BzrDir.open(branch)
1036
reconcile(dir)
1037
1038
1039
class cmd_revision_history(Command):
1040
"""Display the list of revision ids on a branch."""
1041
takes_args = ['location?']
1042
1043
hidden = True
1044
1045
@display_command
1046
def run(self, location="."):
1047
branch = Branch.open_containing(location)[0]
1048
for revid in branch.revision_history():
1049
self.outf.write(revid)
1050
self.outf.write('\n')
1051
1052
1053
class cmd_ancestry(Command):
1054
"""List all revisions merged into this branch."""
1055
takes_args = ['location?']
1056
1057
hidden = True
1058
1059
@display_command
1060
def run(self, location="."):
1061
try:
1062
wt = WorkingTree.open_containing(location)[0]
1063
except errors.NoWorkingTree:
1064
b = Branch.open(location)
1065
last_revision = b.last_revision()
1066
else:
1067
b = wt.branch
1068
last_revision = wt.last_revision()
1069
1070
revision_ids = b.repository.get_ancestry(last_revision)
1071
assert revision_ids[0] is None
1072
revision_ids.pop(0)
1073
for revision_id in revision_ids:
1074
self.outf.write(revision_id + '\n')
1075
1076
1077
class cmd_init(Command):
1078
"""Make a directory into a versioned branch.
1079
1080
Use this to create an empty branch, or before importing an
1081
existing project.
1082
1083
If there is a repository in a parent directory of the location, then
1084
the history of the branch will be stored in the repository. Otherwise
1085
init creates a standalone branch which carries its own history in
1086
.bzr.
1087
1088
If there is already a branch at the location but it has no working tree,
1089
the tree can be populated with 'bzr checkout'.
1090
1091
Recipe for importing a tree of files:
1092
cd ~/project
1093
bzr init
1094
bzr add .
1095
bzr status
1096
bzr commit -m 'imported project'
1097
"""
1098
takes_args = ['location?']
1099
takes_options = [
1100
RegistryOption('format',
1101
help='Specify a format for this branch. Current'
1102
' formats are: default, knit, metaweave and'
1103
' weave. Default is knit; metaweave and'
1104
' weave are deprecated',
1105
converter=bzrdir.format_registry.make_bzrdir,
1106
registry=bzrdir.format_registry,
1107
value_switches=True),
1108
]
1109
def run(self, location=None, format=None):
1110
if format is None:
1111
format = bzrdir.format_registry.make_bzrdir('default')
1112
if location is None:
1113
location = u'.'
1114
1115
to_transport = transport.get_transport(location)
1116
1117
# The path has to exist to initialize a
1118
# branch inside of it.
1119
# Just using os.mkdir, since I don't
1120
# believe that we want to create a bunch of
1121
# locations if the user supplies an extended path
1122
# TODO: create-prefix
1123
try:
1124
to_transport.mkdir('.')
1125
except errors.FileExists:
1126
pass
1127
1128
try:
1129
existing_bzrdir = bzrdir.BzrDir.open(location)
1130
except errors.NotBranchError:
1131
# really a NotBzrDir error...
1132
bzrdir.BzrDir.create_branch_convenience(location, format=format)
1133
else:
1134
from bzrlib.transport.local import LocalTransport
1135
if existing_bzrdir.has_branch():
1136
if (isinstance(to_transport, LocalTransport)
1137
and not existing_bzrdir.has_workingtree()):
1138
raise errors.BranchExistsWithoutWorkingTree(location)
1139
raise errors.AlreadyBranchError(location)
1140
else:
1141
existing_bzrdir.create_branch()
1142
existing_bzrdir.create_workingtree()
1143
1144
1145
class cmd_init_repository(Command):
1146
"""Create a shared repository to hold branches.
1147
1148
New branches created under the repository directory will store their revisions
1149
in the repository, not in the branch directory, if the branch format supports
1150
shared storage.
1151
1152
example:
1153
bzr init-repo repo
1154
bzr init repo/trunk
1155
bzr checkout --lightweight repo/trunk trunk-checkout
1156
cd trunk-checkout
1157
(add files here)
1158
"""
1159
takes_args = ["location"]
1160
takes_options = [RegistryOption('format',
1161
help='Specify a format for this repository.'
1162
' Current formats are: default, knit,'
1163
' metaweave and weave. Default is knit;'
1164
' metaweave and weave are deprecated',
1165
registry=bzrdir.format_registry,
1166
converter=bzrdir.format_registry.make_bzrdir,
1167
value_switches=True),
1168
Option('trees',
1169
help='Allows branches in repository to have'
1170
' a working tree')]
1171
aliases = ["init-repo"]
1172
def run(self, location, format=None, trees=False):
1173
if format is None:
1174
format = bzrdir.format_registry.make_bzrdir('default')
1175
1176
if location is None:
1177
location = '.'
1178
1179
to_transport = transport.get_transport(location)
1180
try:
1181
to_transport.mkdir('.')
1182
except errors.FileExists:
1183
pass
1184
1185
newdir = format.initialize_on_transport(to_transport)
1186
repo = newdir.create_repository(shared=True)
1187
repo.set_make_working_trees(trees)
1188
1189
1190
class cmd_diff(Command):
1191
"""Show differences in the working tree or between revisions.
1192
1193
If files are listed, only the changes in those files are listed.
1194
Otherwise, all changes for the tree are listed.
1195
1196
"bzr diff -p1" is equivalent to "bzr diff --prefix old/:new/", and
1197
produces patches suitable for "patch -p1".
1198
1199
examples:
1200
bzr diff
1201
Shows the difference in the working tree versus the last commit
1202
bzr diff -r1
1203
Difference between the working tree and revision 1
1204
bzr diff -r1..2
1205
Difference between revision 2 and revision 1
1206
bzr diff --diff-prefix old/:new/
1207
Same as 'bzr diff' but prefix paths with old/ and new/
1208
bzr diff bzr.mine bzr.dev
1209
Show the differences between the two working trees
1210
bzr diff foo.c
1211
Show just the differences for 'foo.c'
1212
"""
1213
# TODO: Option to use external diff command; could be GNU diff, wdiff,
1214
# or a graphical diff.
1215
1216
# TODO: Python difflib is not exactly the same as unidiff; should
1217
# either fix it up or prefer to use an external diff.
1218
1219
# TODO: Selected-file diff is inefficient and doesn't show you
1220
# deleted files.
1221
1222
# TODO: This probably handles non-Unix newlines poorly.
1223
1224
takes_args = ['file*']
1225
takes_options = ['revision', 'diff-options',
1226
Option('prefix', type=str,
1227
short_name='p',
1228
help='Set prefixes to added to old and new filenames, as '
1229
'two values separated by a colon.'),
1230
]
1231
aliases = ['di', 'dif']
1232
encoding_type = 'exact'
1233
1234
@display_command
1235
def run(self, revision=None, file_list=None, diff_options=None,
1236
prefix=None):
1237
from bzrlib.diff import diff_cmd_helper, show_diff_trees
1238
1239
if (prefix is None) or (prefix == '0'):
1240
# diff -p0 format
1241
old_label = ''
1242
new_label = ''
1243
elif prefix == '1':
1244
old_label = 'old/'
1245
new_label = 'new/'
1246
elif ':' in prefix:
1247
old_label, new_label = prefix.split(":")
1248
else:
1249
raise BzrCommandError(
1250
"--prefix expects two values separated by a colon")
1251
1252
if revision and len(revision) > 2:
1253
raise errors.BzrCommandError('bzr diff --revision takes exactly'
1254
' one or two revision specifiers')
1255
1256
try:
1257
tree1, file_list = internal_tree_files(file_list)
1258
tree2 = None
1259
b = None
1260
b2 = None
1261
except errors.FileInWrongBranch:
1262
if len(file_list) != 2:
1263
raise errors.BzrCommandError("Files are in different branches")
1264
1265
tree1, file1 = WorkingTree.open_containing(file_list[0])
1266
tree2, file2 = WorkingTree.open_containing(file_list[1])
1267
if file1 != "" or file2 != "":
1268
# FIXME diff those two files. rbc 20051123
1269
raise errors.BzrCommandError("Files are in different branches")
1270
file_list = None
1271
except errors.NotBranchError:
1272
if (revision is not None and len(revision) == 2
1273
and not revision[0].needs_branch()
1274
and not revision[1].needs_branch()):
1275
# If both revision specs include a branch, we can
1276
# diff them without needing a local working tree
1277
tree1, tree2 = None, None
1278
else:
1279
raise
1280
1281
if tree2 is not None:
1282
if revision is not None:
1283
# FIXME: but there should be a clean way to diff between
1284
# non-default versions of two trees, it's not hard to do
1285
# internally...
1286
raise errors.BzrCommandError(
1287
"Sorry, diffing arbitrary revisions across branches "
1288
"is not implemented yet")
1289
return show_diff_trees(tree1, tree2, sys.stdout,
1290
specific_files=file_list,
1291
external_diff_options=diff_options,
1292
old_label=old_label, new_label=new_label)
1293
1294
return diff_cmd_helper(tree1, file_list, diff_options,
1295
revision_specs=revision,
1296
old_label=old_label, new_label=new_label)
1297
1298
1299
class cmd_deleted(Command):
1300
"""List files deleted in the working tree.
1301
"""
1302
# TODO: Show files deleted since a previous revision, or
1303
# between two revisions.
1304
# TODO: Much more efficient way to do this: read in new
1305
# directories with readdir, rather than stating each one. Same
1306
# level of effort but possibly much less IO. (Or possibly not,
1307
# if the directories are very large...)
1308
takes_options = ['show-ids']
1309
1310
@display_command
1311
def run(self, show_ids=False):
1312
tree = WorkingTree.open_containing(u'.')[0]
1313
old = tree.basis_tree()
1314
for path, ie in old.inventory.iter_entries():
1315
if not tree.has_id(ie.file_id):
1316
self.outf.write(path)
1317
if show_ids:
1318
self.outf.write(' ')
1319
self.outf.write(ie.file_id)
1320
self.outf.write('\n')
1321
1322
1323
class cmd_modified(Command):
1324
"""List files modified in working tree."""
1325
hidden = True
1326
@display_command
1327
def run(self):
1328
tree = WorkingTree.open_containing(u'.')[0]
1329
td = tree.changes_from(tree.basis_tree())
1330
for path, id, kind, text_modified, meta_modified in td.modified:
1331
self.outf.write(path + '\n')
1332
1333
1334
class cmd_added(Command):
1335
"""List files added in working tree."""
1336
hidden = True
1337
@display_command
1338
def run(self):
1339
wt = WorkingTree.open_containing(u'.')[0]
1340
basis_inv = wt.basis_tree().inventory
1341
inv = wt.inventory
1342
for file_id in inv:
1343
if file_id in basis_inv:
1344
continue
1345
if inv.is_root(file_id) and len(basis_inv) == 0:
1346
continue
1347
path = inv.id2path(file_id)
1348
if not os.access(osutils.abspath(path), os.F_OK):
1349
continue
1350
self.outf.write(path + '\n')
1351
1352
1353
class cmd_root(Command):
1354
"""Show the tree root directory.
1355
1356
The root is the nearest enclosing directory with a .bzr control
1357
directory."""
1358
takes_args = ['filename?']
1359
@display_command
1360
def run(self, filename=None):
1361
"""Print the branch root."""
1362
tree = WorkingTree.open_containing(filename)[0]
1363
self.outf.write(tree.basedir + '\n')
1364
1365
1366
class cmd_log(Command):
1367
"""Show log of a branch, file, or directory.
1368
1369
By default show the log of the branch containing the working directory.
1370
1371
To request a range of logs, you can use the command -r begin..end
1372
-r revision requests a specific revision, -r ..end or -r begin.. are
1373
also valid.
1374
1375
examples:
1376
bzr log
1377
bzr log foo.c
1378
bzr log -r -10.. http://server/branch
1379
"""
1380
1381
# TODO: Make --revision support uuid: and hash: [future tag:] notation.
1382
1383
takes_args = ['location?']
1384
takes_options = [Option('forward',
1385
help='show from oldest to newest'),
1386
'timezone',
1387
Option('verbose',
1388
short_name='v',
1389
help='show files changed in each revision'),
1390
'show-ids', 'revision',
1391
'log-format',
1392
'line', 'long',
1393
Option('message',
1394
short_name='m',
1395
help='show revisions whose message matches this regexp',
1396
type=str),
1397
'short',
1398
]
1399
encoding_type = 'replace'
1400
1401
@display_command
1402
def run(self, location=None, timezone='original',
1403
verbose=False,
1404
show_ids=False,
1405
forward=False,
1406
revision=None,
1407
log_format=None,
1408
message=None,
1409
long=False,
1410
short=False,
1411
line=False):
1412
from bzrlib.log import log_formatter, show_log
1413
assert message is None or isinstance(message, basestring), \
1414
"invalid message argument %r" % message
1415
direction = (forward and 'forward') or 'reverse'
1416
1417
# log everything
1418
file_id = None
1419
if location:
1420
# find the file id to log:
1421
1422
dir, fp = bzrdir.BzrDir.open_containing(location)
1423
b = dir.open_branch()
1424
if fp != '':
1425
try:
1426
# might be a tree:
1427
inv = dir.open_workingtree().inventory
1428
except (errors.NotBranchError, errors.NotLocalUrl):
1429
# either no tree, or is remote.
1430
inv = b.basis_tree().inventory
1431
file_id = inv.path2id(fp)
1432
if file_id is None:
1433
raise errors.BzrCommandError(
1434
"Path does not have any revision history: %s" %
1435
location)
1436
else:
1437
# local dir only
1438
# FIXME ? log the current subdir only RBC 20060203
1439
if revision is not None \
1440
and len(revision) > 0 and revision[0].get_branch():
1441
location = revision[0].get_branch()
1442
else:
1443
location = '.'
1444
dir, relpath = bzrdir.BzrDir.open_containing(location)
1445
b = dir.open_branch()
1446
1447
if revision is None:
1448
rev1 = None
1449
rev2 = None
1450
elif len(revision) == 1:
1451
rev1 = rev2 = revision[0].in_history(b).revno
1452
elif len(revision) == 2:
1453
if revision[1].get_branch() != revision[0].get_branch():
1454
# b is taken from revision[0].get_branch(), and
1455
# show_log will use its revision_history. Having
1456
# different branches will lead to weird behaviors.
1457
raise errors.BzrCommandError(
1458
"Log doesn't accept two revisions in different branches.")
1459
if revision[0].spec is None:
1460
# missing begin-range means first revision
1461
rev1 = 1
1462
else:
1463
rev1 = revision[0].in_history(b).revno
1464
1465
if revision[1].spec is None:
1466
# missing end-range means last known revision
1467
rev2 = b.revno()
1468
else:
1469
rev2 = revision[1].in_history(b).revno
1470
else:
1471
raise errors.BzrCommandError('bzr log --revision takes one or two values.')
1472
1473
# By this point, the revision numbers are converted to the +ve
1474
# form if they were supplied in the -ve form, so we can do
1475
# this comparison in relative safety
1476
if rev1 > rev2:
1477
(rev2, rev1) = (rev1, rev2)
1478
1479
if (log_format is None):
1480
default = b.get_config().log_format()
1481
log_format = get_log_format(long=long, short=short, line=line,
1482
default=default)
1483
lf = log_formatter(log_format,
1484
show_ids=show_ids,
1485
to_file=self.outf,
1486
show_timezone=timezone)
1487
1488
show_log(b,
1489
lf,
1490
file_id,
1491
verbose=verbose,
1492
direction=direction,
1493
start_revision=rev1,
1494
end_revision=rev2,
1495
search=message)
1496
1497
1498
def get_log_format(long=False, short=False, line=False, default='long'):
1499
log_format = default
1500
if long:
1501
log_format = 'long'
1502
if short:
1503
log_format = 'short'
1504
if line:
1505
log_format = 'line'
1506
return log_format
1507
1508
1509
class cmd_touching_revisions(Command):
1510
"""Return revision-ids which affected a particular file.
1511
1512
A more user-friendly interface is "bzr log FILE".
1513
"""
1514
1515
hidden = True
1516
takes_args = ["filename"]
1517
1518
@display_command
1519
def run(self, filename):
1520
tree, relpath = WorkingTree.open_containing(filename)
1521
b = tree.branch
1522
inv = tree.read_working_inventory()
1523
file_id = inv.path2id(relpath)
1524
for revno, revision_id, what in log.find_touching_revisions(b, file_id):
1525
self.outf.write("%6d %s\n" % (revno, what))
1526
1527
1528
class cmd_ls(Command):
1529
"""List files in a tree.
1530
"""
1531
1532
takes_args = ['path?']
1533
# TODO: Take a revision or remote path and list that tree instead.
1534
takes_options = ['verbose', 'revision',
1535
Option('non-recursive',
1536
help='don\'t recurse into sub-directories'),
1537
Option('from-root',
1538
help='Print all paths from the root of the branch.'),
1539
Option('unknown', help='Print unknown files'),
1540
Option('versioned', help='Print versioned files'),
1541
Option('ignored', help='Print ignored files'),
1542
1543
Option('null', help='Null separate the files'),
1544
'kind', 'show-ids'
1545
]
1546
@display_command
1547
def run(self, revision=None, verbose=False,
1548
non_recursive=False, from_root=False,
1549
unknown=False, versioned=False, ignored=False,
1550
null=False, kind=None, show_ids=False, path=None):
1551
1552
if kind and kind not in ('file', 'directory', 'symlink'):
1553
raise errors.BzrCommandError('invalid kind specified')
1554
1555
if verbose and null:
1556
raise errors.BzrCommandError('Cannot set both --verbose and --null')
1557
all = not (unknown or versioned or ignored)
1558
1559
selection = {'I':ignored, '?':unknown, 'V':versioned}
1560
1561
if path is None:
1562
fs_path = '.'
1563
prefix = ''
1564
else:
1565
if from_root:
1566
raise errors.BzrCommandError('cannot specify both --from-root'
1567
' and PATH')
1568
fs_path = path
1569
prefix = path
1570
tree, branch, relpath = bzrdir.BzrDir.open_containing_tree_or_branch(
1571
fs_path)
1572
if from_root:
1573
relpath = u''
1574
elif relpath:
1575
relpath += '/'
1576
if revision is not None:
1577
tree = branch.repository.revision_tree(
1578
revision[0].in_history(branch).rev_id)
1579
elif tree is None:
1580
tree = branch.basis_tree()
1581
1582
for fp, fc, fkind, fid, entry in tree.list_files(include_root=False):
1583
if fp.startswith(relpath):
1584
fp = osutils.pathjoin(prefix, fp[len(relpath):])
1585
if non_recursive and '/' in fp:
1586
continue
1587
if not all and not selection[fc]:
1588
continue
1589
if kind is not None and fkind != kind:
1590
continue
1591
if verbose:
1592
kindch = entry.kind_character()
1593
outstring = '%-8s %s%s' % (fc, fp, kindch)
1594
if show_ids and fid is not None:
1595
outstring = "%-50s %s" % (outstring, fid)
1596
self.outf.write(outstring + '\n')
1597
elif null:
1598
self.outf.write(fp + '\0')
1599
if show_ids:
1600
if fid is not None:
1601
self.outf.write(fid)
1602
self.outf.write('\0')
1603
self.outf.flush()
1604
else:
1605
if fid is not None:
1606
my_id = fid
1607
else:
1608
my_id = ''
1609
if show_ids:
1610
self.outf.write('%-50s %s\n' % (fp, my_id))
1611
else:
1612
self.outf.write(fp + '\n')
1613
1614
1615
class cmd_unknowns(Command):
1616
"""List unknown files."""
1617
@display_command
1618
def run(self):
1619
for f in WorkingTree.open_containing(u'.')[0].unknowns():
1620
self.outf.write(osutils.quotefn(f) + '\n')
1621
1622
1623
class cmd_ignore(Command):
1624
"""Ignore specified files or patterns.
1625
1626
To remove patterns from the ignore list, edit the .bzrignore file.
1627
1628
Trailing slashes on patterns are ignored.
1629
If the pattern contains a slash or is a regular expression, it is compared
1630
to the whole path from the branch root. Otherwise, it is compared to only
1631
the last component of the path. To match a file only in the root
1632
directory, prepend './'.
1633
1634
Ignore patterns specifying absolute paths are not allowed.
1635
1636
Ignore patterns may include globbing wildcards such as:
1637
? - Matches any single character except '/'
1638
* - Matches 0 or more characters except '/'
1639
/**/ - Matches 0 or more directories in a path
1640
[a-z] - Matches a single character from within a group of characters
1641
1642
Ignore patterns may also be Python regular expressions.
1643
Regular expression ignore patterns are identified by a 'RE:' prefix
1644
followed by the regular expression. Regular expression ignore patterns
1645
may not include named or numbered groups.
1646
1647
Note: ignore patterns containing shell wildcards must be quoted from
1648
the shell on Unix.
1649
1650
examples:
1651
bzr ignore ./Makefile
1652
bzr ignore '*.class'
1653
bzr ignore 'lib/**/*.o'
1654
bzr ignore 'RE:lib/.*\.o'
1655
"""
1656
takes_args = ['name_pattern*']
1657
takes_options = [
1658
Option('old-default-rules',
1659
help='Out the ignore rules bzr < 0.9 always used.')
1660
]
1661
1662
def run(self, name_pattern_list=None, old_default_rules=None):
1663
from bzrlib.atomicfile import AtomicFile
1664
if old_default_rules is not None:
1665
# dump the rules and exit
1666
for pattern in ignores.OLD_DEFAULTS:
1667
print pattern
1668
return
1669
if not name_pattern_list:
1670
raise errors.BzrCommandError("ignore requires at least one "
1671
"NAME_PATTERN or --old-default-rules")
1672
for name_pattern in name_pattern_list:
1673
if name_pattern[0] == '/':
1674
raise errors.BzrCommandError(
1675
"NAME_PATTERN should not be an absolute path")
1676
tree, relpath = WorkingTree.open_containing(u'.')
1677
ifn = tree.abspath('.bzrignore')
1678
if os.path.exists(ifn):
1679
f = open(ifn, 'rt')
1680
try:
1681
igns = f.read().decode('utf-8')
1682
finally:
1683
f.close()
1684
else:
1685
igns = ''
1686
1687
# TODO: If the file already uses crlf-style termination, maybe
1688
# we should use that for the newly added lines?
1689
1690
if igns and igns[-1] != '\n':
1691
igns += '\n'
1692
for name_pattern in name_pattern_list:
1693
igns += name_pattern.rstrip('/') + '\n'
1694
1695
f = AtomicFile(ifn, 'wb')
1696
try:
1697
f.write(igns.encode('utf-8'))
1698
f.commit()
1699
finally:
1700
f.close()
1701
1702
inv = tree.inventory
1703
if inv.path2id('.bzrignore'):
1704
mutter('.bzrignore is already versioned')
1705
else:
1706
mutter('need to make new .bzrignore file versioned')
1707
tree.add(['.bzrignore'])
1708
1709
1710
class cmd_ignored(Command):
1711
"""List ignored files and the patterns that matched them.
1712
1713
See also: bzr ignore"""
1714
@display_command
1715
def run(self):
1716
tree = WorkingTree.open_containing(u'.')[0]
1717
for path, file_class, kind, file_id, entry in tree.list_files():
1718
if file_class != 'I':
1719
continue
1720
## XXX: Slightly inefficient since this was already calculated
1721
pat = tree.is_ignored(path)
1722
print '%-50s %s' % (path, pat)
1723
1724
1725
class cmd_lookup_revision(Command):
1726
"""Lookup the revision-id from a revision-number
1727
1728
example:
1729
bzr lookup-revision 33
1730
"""
1731
hidden = True
1732
takes_args = ['revno']
1733
1734
@display_command
1735
def run(self, revno):
1736
try:
1737
revno = int(revno)
1738
except ValueError:
1739
raise errors.BzrCommandError("not a valid revision-number: %r" % revno)
1740
1741
print WorkingTree.open_containing(u'.')[0].branch.get_rev_id(revno)
1742
1743
1744
class cmd_export(Command):
1745
"""Export past revision to destination directory.
1746
1747
If no revision is specified this exports the last committed revision.
1748
1749
Format may be an "exporter" name, such as tar, tgz, tbz2. If none is
1750
given, try to find the format with the extension. If no extension
1751
is found exports to a directory (equivalent to --format=dir).
1752
1753
Root may be the top directory for tar, tgz and tbz2 formats. If none
1754
is given, the top directory will be the root name of the file.
1755
1756
If branch is omitted then the branch containing the CWD will be used.
1757
1758
Note: export of tree with non-ascii filenames to zip is not supported.
1759
1760
Supported formats Autodetected by extension
1761
----------------- -------------------------
1762
dir -
1763
tar .tar
1764
tbz2 .tar.bz2, .tbz2
1765
tgz .tar.gz, .tgz
1766
zip .zip
1767
"""
1768
takes_args = ['dest', 'branch?']
1769
takes_options = ['revision', 'format', 'root']
1770
def run(self, dest, branch=None, revision=None, format=None, root=None):
1771
from bzrlib.export import export
1772
1773
if branch is None:
1774
tree = WorkingTree.open_containing(u'.')[0]
1775
b = tree.branch
1776
else:
1777
b = Branch.open(branch)
1778
1779
if revision is None:
1780
# should be tree.last_revision FIXME
1781
rev_id = b.last_revision()
1782
else:
1783
if len(revision) != 1:
1784
raise errors.BzrCommandError('bzr export --revision takes exactly 1 argument')
1785
rev_id = revision[0].in_history(b).rev_id
1786
t = b.repository.revision_tree(rev_id)
1787
try:
1788
export(t, dest, format, root)
1789
except errors.NoSuchExportFormat, e:
1790
raise errors.BzrCommandError('Unsupported export format: %s' % e.format)
1791
1792
1793
class cmd_cat(Command):
1794
"""Write a file's text from a previous revision."""
1795
1796
takes_options = ['revision', 'name-from-revision']
1797
takes_args = ['filename']
1798
encoding_type = 'exact'
1799
1800
@display_command
1801
def run(self, filename, revision=None, name_from_revision=False):
1802
if revision is not None and len(revision) != 1:
1803
raise errors.BzrCommandError("bzr cat --revision takes exactly"
1804
" one number")
1805
1806
tree = None
1807
try:
1808
tree, relpath = WorkingTree.open_containing(filename)
1809
b = tree.branch
1810
except (errors.NotBranchError, errors.NotLocalUrl):
1811
pass
1812
1813
if revision is not None and revision[0].get_branch() is not None:
1814
b = Branch.open(revision[0].get_branch())
1815
if tree is None:
1816
b, relpath = Branch.open_containing(filename)
1817
tree = b.basis_tree()
1818
if revision is None:
1819
revision_id = b.last_revision()
1820
else:
1821
revision_id = revision[0].in_history(b).rev_id
1822
1823
cur_file_id = tree.path2id(relpath)
1824
rev_tree = b.repository.revision_tree(revision_id)
1825
old_file_id = rev_tree.path2id(relpath)
1826
1827
if name_from_revision:
1828
if old_file_id is None:
1829
raise errors.BzrCommandError("%r is not present in revision %s"
1830
% (filename, revision_id))
1831
else:
1832
rev_tree.print_file(old_file_id)
1833
elif cur_file_id is not None:
1834
rev_tree.print_file(cur_file_id)
1835
elif old_file_id is not None:
1836
rev_tree.print_file(old_file_id)
1837
else:
1838
raise errors.BzrCommandError("%r is not present in revision %s" %
1839
(filename, revision_id))
1840
1841
1842
class cmd_local_time_offset(Command):
1843
"""Show the offset in seconds from GMT to local time."""
1844
hidden = True
1845
@display_command
1846
def run(self):
1847
print osutils.local_time_offset()
1848
1849
1850
1851
class cmd_commit(Command):
1852
"""Commit changes into a new revision.
1853
1854
If no arguments are given, the entire tree is committed.
1855
1856
If selected files are specified, only changes to those files are
1857
committed. If a directory is specified then the directory and everything
1858
within it is committed.
1859
1860
A selected-file commit may fail in some cases where the committed
1861
tree would be invalid, such as trying to commit a file in a
1862
newly-added directory that is not itself committed.
1863
"""
1864
# TODO: Run hooks on tree to-be-committed, and after commit.
1865
1866
# TODO: Strict commit that fails if there are deleted files.
1867
# (what does "deleted files" mean ??)
1868
1869
# TODO: Give better message for -s, --summary, used by tla people
1870
1871
# XXX: verbose currently does nothing
1872
1873
takes_args = ['selected*']
1874
takes_options = ['message', 'verbose',
1875
Option('unchanged',
1876
help='commit even if nothing has changed'),
1877
Option('file', type=str,
1878
short_name='F',
1879
argname='msgfile',
1880
help='file containing commit message'),
1881
Option('strict',
1882
help="refuse to commit if there are unknown "
1883
"files in the working tree."),
1884
Option('local',
1885
help="perform a local only commit in a bound "
1886
"branch. Such commits are not pushed to "
1887
"the master branch until a normal commit "
1888
"is performed."
1889
),
1890
]
1891
aliases = ['ci', 'checkin']
1892
1893
def run(self, message=None, file=None, verbose=True, selected_list=None,
1894
unchanged=False, strict=False, local=False):
1895
from bzrlib.commit import (NullCommitReporter, ReportCommitToLog)
1896
from bzrlib.errors import (PointlessCommit, ConflictsInTree,
1897
StrictCommitFailed)
1898
from bzrlib.msgeditor import edit_commit_message, \
1899
make_commit_message_template
1900
1901
# TODO: Need a blackbox test for invoking the external editor; may be
1902
# slightly problematic to run this cross-platform.
1903
1904
# TODO: do more checks that the commit will succeed before
1905
# spending the user's valuable time typing a commit message.
1906
tree, selected_list = tree_files(selected_list)
1907
if selected_list == ['']:
1908
# workaround - commit of root of tree should be exactly the same
1909
# as just default commit in that tree, and succeed even though
1910
# selected-file merge commit is not done yet
1911
selected_list = []
1912
1913
if local and not tree.branch.get_bound_location():
1914
raise errors.LocalRequiresBoundBranch()
1915
1916
def get_message(commit_obj):
1917
"""Callback to get commit message"""
1918
my_message = message
1919
if my_message is None and not file:
1920
template = make_commit_message_template(tree, selected_list)
1921
my_message = edit_commit_message(template)
1922
if my_message is None:
1923
raise errors.BzrCommandError("please specify a commit"
1924
" message with either --message or --file")
1925
elif my_message and file:
1926
raise errors.BzrCommandError(
1927
"please specify either --message or --file")
1928
if file:
1929
my_message = codecs.open(file, 'rt',
1930
bzrlib.user_encoding).read()
1931
if my_message == "":
1932
raise errors.BzrCommandError("empty commit message specified")
1933
return my_message
1934
1935
if verbose:
1936
reporter = ReportCommitToLog()
1937
else:
1938
reporter = NullCommitReporter()
1939
1940
try:
1941
tree.commit(message_callback=get_message,
1942
specific_files=selected_list,
1943
allow_pointless=unchanged, strict=strict, local=local,
1944
reporter=reporter)
1945
except PointlessCommit:
1946
# FIXME: This should really happen before the file is read in;
1947
# perhaps prepare the commit; get the message; then actually commit
1948
raise errors.BzrCommandError("no changes to commit."
1949
" use --unchanged to commit anyhow")
1950
except ConflictsInTree:
1951
raise errors.BzrCommandError('Conflicts detected in working '
1952
'tree. Use "bzr conflicts" to list, "bzr resolve FILE" to'
1953
' resolve.')
1954
except StrictCommitFailed:
1955
raise errors.BzrCommandError("Commit refused because there are"
1956
" unknown files in the working tree.")
1957
except errors.BoundBranchOutOfDate, e:
1958
raise errors.BzrCommandError(str(e) + "\n"
1959
'To commit to master branch, run update and then commit.\n'
1960
'You can also pass --local to commit to continue working '
1961
'disconnected.')
1962
1963
1964
class cmd_check(Command):
1965
"""Validate consistency of branch history.
1966
1967
This command checks various invariants about the branch storage to
1968
detect data corruption or bzr bugs.
1969
"""
1970
takes_args = ['branch?']
1971
takes_options = ['verbose']
1972
1973
def run(self, branch=None, verbose=False):
1974
from bzrlib.check import check
1975
if branch is None:
1976
tree = WorkingTree.open_containing()[0]
1977
branch = tree.branch
1978
else:
1979
branch = Branch.open(branch)
1980
check(branch, verbose)
1981
1982
1983
class cmd_upgrade(Command):
1984
"""Upgrade branch storage to current format.
1985
1986
The check command or bzr developers may sometimes advise you to run
1987
this command. When the default format has changed you may also be warned
1988
during other operations to upgrade.
1989
"""
1990
takes_args = ['url?']
1991
takes_options = [
1992
RegistryOption('format',
1993
help='Upgrade to a specific format. Current formats'
1994
' are: default, knit, metaweave and weave.'
1995
' Default is knit; metaweave and weave are'
1996
' deprecated',
1997
registry=bzrdir.format_registry,
1998
converter=bzrdir.format_registry.make_bzrdir,
1999
value_switches=True),
2000
]
2001
2002
2003
def run(self, url='.', format=None):
2004
from bzrlib.upgrade import upgrade
2005
if format is None:
2006
format = bzrdir.format_registry.make_bzrdir('default')
2007
upgrade(url, format)
2008
2009
2010
class cmd_whoami(Command):
2011
"""Show or set bzr user id.
2012
2013
examples:
2014
bzr whoami --email
2015
bzr whoami 'Frank Chu <fchu@example.com>'
2016
"""
2017
takes_options = [ Option('email',
2018
help='display email address only'),
2019
Option('branch',
2020
help='set identity for the current branch instead of '
2021
'globally'),
2022
]
2023
takes_args = ['name?']
2024
encoding_type = 'replace'
2025
2026
@display_command
2027
def run(self, email=False, branch=False, name=None):
2028
if name is None:
2029
# use branch if we're inside one; otherwise global config
2030
try:
2031
c = Branch.open_containing('.')[0].get_config()
2032
except errors.NotBranchError:
2033
c = config.GlobalConfig()
2034
if email:
2035
self.outf.write(c.user_email() + '\n')
2036
else:
2037
self.outf.write(c.username() + '\n')
2038
return
2039
2040
# display a warning if an email address isn't included in the given name.
2041
try:
2042
config.extract_email_address(name)
2043
except errors.NoEmailInUsername, e:
2044
warning('"%s" does not seem to contain an email address. '
2045
'This is allowed, but not recommended.', name)
2046
2047
# use global config unless --branch given
2048
if branch:
2049
c = Branch.open_containing('.')[0].get_config()
2050
else:
2051
c = config.GlobalConfig()
2052
c.set_user_option('email', name)
2053
2054
2055
class cmd_nick(Command):
2056
"""Print or set the branch nickname.
2057
2058
If unset, the tree root directory name is used as the nickname
2059
To print the current nickname, execute with no argument.
2060
"""
2061
takes_args = ['nickname?']
2062
def run(self, nickname=None):
2063
branch = Branch.open_containing(u'.')[0]
2064
if nickname is None:
2065
self.printme(branch)
2066
else:
2067
branch.nick = nickname
2068
2069
@display_command
2070
def printme(self, branch):
2071
print branch.nick
2072
2073
2074
class cmd_selftest(Command):
2075
"""Run internal test suite.
2076
2077
This creates temporary test directories in the working directory, but not
2078
existing data is affected. These directories are deleted if the tests
2079
pass, or left behind to help in debugging if they fail and --keep-output
2080
is specified.
2081
2082
If arguments are given, they are regular expressions that say which tests
2083
should run. Tests matching any expression are run, and other tests are
2084
not run.
2085
2086
Alternatively if --first is given, matching tests are run first and then
2087
all other tests are run. This is useful if you have been working in a
2088
particular area, but want to make sure nothing else was broken.
2089
2090
If the global option '--no-plugins' is given, plugins are not loaded
2091
before running the selftests. This has two effects: features provided or
2092
modified by plugins will not be tested, and tests provided by plugins will
2093
not be run.
2094
2095
examples::
2096
bzr selftest ignore
2097
run only tests relating to 'ignore'
2098
bzr --no-plugins selftest -v
2099
disable plugins and list tests as they're run
2100
"""
2101
# TODO: --list should give a list of all available tests
2102
2103
# NB: this is used from the class without creating an instance, which is
2104
# why it does not have a self parameter.
2105
def get_transport_type(typestring):
2106
"""Parse and return a transport specifier."""
2107
if typestring == "sftp":
2108
from bzrlib.transport.sftp import SFTPAbsoluteServer
2109
return SFTPAbsoluteServer
2110
if typestring == "memory":
2111
from bzrlib.transport.memory import MemoryServer
2112
return MemoryServer
2113
if typestring == "fakenfs":
2114
from bzrlib.transport.fakenfs import FakeNFSServer
2115
return FakeNFSServer
2116
msg = "No known transport type %s. Supported types are: sftp\n" %\
2117
(typestring)
2118
raise errors.BzrCommandError(msg)
2119
2120
hidden = True
2121
takes_args = ['testspecs*']
2122
takes_options = ['verbose',
2123
Option('one', help='stop when one test fails'),
2124
Option('keep-output',
2125
help='keep output directories when tests fail'),
2126
Option('transport',
2127
help='Use a different transport by default '
2128
'throughout the test suite.',
2129
type=get_transport_type),
2130
Option('benchmark', help='run the bzr bencharks.'),
2131
Option('lsprof-timed',
2132
help='generate lsprof output for benchmarked'
2133
' sections of code.'),
2134
Option('cache-dir', type=str,
2135
help='a directory to cache intermediate'
2136
' benchmark steps'),
2137
Option('clean-output',
2138
help='clean temporary tests directories'
2139
' without running tests'),
2140
Option('first',
2141
help='run all tests, but run specified tests first',
2142
)
2143
]
2144
encoding_type = 'replace'
2145
2146
def run(self, testspecs_list=None, verbose=None, one=False,
2147
keep_output=False, transport=None, benchmark=None,
2148
lsprof_timed=None, cache_dir=None, clean_output=False,
2149
first=False):
2150
import bzrlib.ui
2151
from bzrlib.tests import selftest
2152
import bzrlib.benchmarks as benchmarks
2153
from bzrlib.benchmarks import tree_creator
2154
2155
if clean_output:
2156
from bzrlib.tests import clean_selftest_output
2157
clean_selftest_output()
2158
return 0
2159
2160
if cache_dir is not None:
2161
tree_creator.TreeCreator.CACHE_ROOT = osutils.abspath(cache_dir)
2162
print '%10s: %s' % ('bzr', osutils.realpath(sys.argv[0]))
2163
print '%10s: %s' % ('bzrlib', bzrlib.__path__[0])
2164
print
2165
if testspecs_list is not None:
2166
pattern = '|'.join(testspecs_list)
2167
else:
2168
pattern = ".*"
2169
if benchmark:
2170
test_suite_factory = benchmarks.test_suite
2171
if verbose is None:
2172
verbose = True
2173
# TODO: should possibly lock the history file...
2174
benchfile = open(".perf_history", "at", buffering=1)
2175
else:
2176
test_suite_factory = None
2177
if verbose is None:
2178
verbose = False
2179
benchfile = None
2180
try:
2181
result = selftest(verbose=verbose,
2182
pattern=pattern,
2183
stop_on_failure=one,
2184
keep_output=keep_output,
2185
transport=transport,
2186
test_suite_factory=test_suite_factory,
2187
lsprof_timed=lsprof_timed,
2188
bench_history=benchfile,
2189
matching_tests_first=first,
2190
)
2191
finally:
2192
if benchfile is not None:
2193
benchfile.close()
2194
if result:
2195
info('tests passed')
2196
else:
2197
info('tests failed')
2198
return int(not result)
2199
2200
2201
class cmd_version(Command):
2202
"""Show version of bzr."""
2203
2204
@display_command
2205
def run(self):
2206
from bzrlib.version import show_version
2207
show_version()
2208
2209
2210
class cmd_rocks(Command):
2211
"""Statement of optimism."""
2212
2213
hidden = True
2214
2215
@display_command
2216
def run(self):
2217
print "it sure does!"
2218
2219
2220
class cmd_find_merge_base(Command):
2221
"""Find and print a base revision for merging two branches."""
2222
# TODO: Options to specify revisions on either side, as if
2223
# merging only part of the history.
2224
takes_args = ['branch', 'other']
2225
hidden = True
2226
2227
@display_command
2228
def run(self, branch, other):
2229
from bzrlib.revision import MultipleRevisionSources
2230
2231
branch1 = Branch.open_containing(branch)[0]
2232
branch2 = Branch.open_containing(other)[0]
2233
2234
history_1 = branch1.revision_history()
2235
history_2 = branch2.revision_history()
2236
2237
last1 = branch1.last_revision()
2238
last2 = branch2.last_revision()
2239
2240
source = MultipleRevisionSources(branch1.repository,
2241
branch2.repository)
2242
2243
base_rev_id = common_ancestor(last1, last2, source)
2244
2245
print 'merge base is revision %s' % base_rev_id
2246
2247
2248
class cmd_merge(Command):
2249
"""Perform a three-way merge.
2250
2251
The branch is the branch you will merge from. By default, it will merge
2252
the latest revision. If you specify a revision, that revision will be
2253
merged. If you specify two revisions, the first will be used as a BASE,
2254
and the second one as OTHER. Revision numbers are always relative to the
2255
specified branch.
2256
2257
By default, bzr will try to merge in all new work from the other
2258
branch, automatically determining an appropriate base. If this
2259
fails, you may need to give an explicit base.
2260
2261
Merge will do its best to combine the changes in two branches, but there
2262
are some kinds of problems only a human can fix. When it encounters those,
2263
it will mark a conflict. A conflict means that you need to fix something,
2264
before you should commit.
2265
2266
Use bzr resolve when you have fixed a problem. See also bzr conflicts.
2267
2268
If there is no default branch set, the first merge will set it. After
2269
that, you can omit the branch to use the default. To change the
2270
default, use --remember. The value will only be saved if the remote
2271
location can be accessed.
2272
2273
Examples:
2274
2275
To merge the latest revision from bzr.dev
2276
bzr merge ../bzr.dev
2277
2278
To merge changes up to and including revision 82 from bzr.dev
2279
bzr merge -r 82 ../bzr.dev
2280
2281
To merge the changes introduced by 82, without previous changes:
2282
bzr merge -r 81..82 ../bzr.dev
2283
2284
merge refuses to run if there are any uncommitted changes, unless
2285
--force is given.
2286
2287
The following merge types are available:
2288
"""
2289
takes_args = ['branch?']
2290
takes_options = ['revision', 'force', 'merge-type', 'reprocess', 'remember',
2291
Option('show-base', help="Show base revision text in "
2292
"conflicts"),
2293
Option('uncommitted', help='Apply uncommitted changes'
2294
' from a working copy, instead of branch changes'),
2295
Option('pull', help='If the destination is already'
2296
' completely merged into the source, pull from the'
2297
' source rather than merging. When this happens,'
2298
' you do not need to commit the result.'),
2299
]
2300
2301
def help(self):
2302
from inspect import getdoc
2303
return getdoc(self) + '\n' + _mod_merge.merge_type_help()
2304
2305
def run(self, branch=None, revision=None, force=False, merge_type=None,
2306
show_base=False, reprocess=False, remember=False,
2307
uncommitted=False, pull=False):
2308
if merge_type is None:
2309
merge_type = _mod_merge.Merge3Merger
2310
2311
tree = WorkingTree.open_containing(u'.')[0]
2312
2313
if branch is not None:
2314
try:
2315
reader = bundle.read_bundle_from_url(branch)
2316
except errors.NotABundle:
2317
pass # Continue on considering this url a Branch
2318
else:
2319
conflicts = merge_bundle(reader, tree, not force, merge_type,
2320
reprocess, show_base)
2321
if conflicts == 0:
2322
return 0
2323
else:
2324
return 1
2325
2326
if revision is None \
2327
or len(revision) < 1 or revision[0].needs_branch():
2328
branch = self._get_remembered_parent(tree, branch, 'Merging from')
2329
2330
if revision is None or len(revision) < 1:
2331
if uncommitted:
2332
base = [branch, -1]
2333
other = [branch, None]
2334
else:
2335
base = [None, None]
2336
other = [branch, -1]
2337
other_branch, path = Branch.open_containing(branch)
2338
else:
2339
if uncommitted:
2340
raise errors.BzrCommandError('Cannot use --uncommitted and'
2341
' --revision at the same time.')
2342
branch = revision[0].get_branch() or branch
2343
if len(revision) == 1:
2344
base = [None, None]
2345
other_branch, path = Branch.open_containing(branch)
2346
revno = revision[0].in_history(other_branch).revno
2347
other = [branch, revno]
2348
else:
2349
assert len(revision) == 2
2350
if None in revision:
2351
raise errors.BzrCommandError(
2352
"Merge doesn't permit empty revision specifier.")
2353
base_branch, path = Branch.open_containing(branch)
2354
branch1 = revision[1].get_branch() or branch
2355
other_branch, path1 = Branch.open_containing(branch1)
2356
if revision[0].get_branch() is not None:
2357
# then path was obtained from it, and is None.
2358
path = path1
2359
2360
base = [branch, revision[0].in_history(base_branch).revno]
2361
other = [branch1, revision[1].in_history(other_branch).revno]
2362
2363
if tree.branch.get_parent() is None or remember:
2364
tree.branch.set_parent(other_branch.base)
2365
2366
if path != "":
2367
interesting_files = [path]
2368
else:
2369
interesting_files = None
2370
pb = ui.ui_factory.nested_progress_bar()
2371
try:
2372
try:
2373
conflict_count = _merge_helper(
2374
other, base, check_clean=(not force),
2375
merge_type=merge_type,
2376
reprocess=reprocess,
2377
show_base=show_base,
2378
pull=pull,
2379
pb=pb, file_list=interesting_files)
2380
finally:
2381
pb.finished()
2382
if conflict_count != 0:
2383
return 1
2384
else:
2385
return 0
2386
except errors.AmbiguousBase, e:
2387
m = ("sorry, bzr can't determine the right merge base yet\n"
2388
"candidates are:\n "
2389
+ "\n ".join(e.bases)
2390
+ "\n"
2391
"please specify an explicit base with -r,\n"
2392
"and (if you want) report this to the bzr developers\n")
2393
log_error(m)
2394
2395
# TODO: move up to common parent; this isn't merge-specific anymore.
2396
def _get_remembered_parent(self, tree, supplied_location, verb_string):
2397
"""Use tree.branch's parent if none was supplied.
2398
2399
Report if the remembered location was used.
2400
"""
2401
if supplied_location is not None:
2402
return supplied_location
2403
stored_location = tree.branch.get_parent()
2404
mutter("%s", stored_location)
2405
if stored_location is None:
2406
raise errors.BzrCommandError("No location specified or remembered")
2407
display_url = urlutils.unescape_for_display(stored_location, self.outf.encoding)
2408
self.outf.write("%s remembered location %s\n" % (verb_string, display_url))
2409
return stored_location
2410
2411
2412
class cmd_remerge(Command):
2413
"""Redo a merge.
2414
2415
Use this if you want to try a different merge technique while resolving
2416
conflicts. Some merge techniques are better than others, and remerge
2417
lets you try different ones on different files.
2418
2419
The options for remerge have the same meaning and defaults as the ones for
2420
merge. The difference is that remerge can (only) be run when there is a
2421
pending merge, and it lets you specify particular files.
2422
2423
Examples:
2424
$ bzr remerge --show-base
2425
Re-do the merge of all conflicted files, and show the base text in
2426
conflict regions, in addition to the usual THIS and OTHER texts.
2427
2428
$ bzr remerge --merge-type weave --reprocess foobar
2429
Re-do the merge of "foobar", using the weave merge algorithm, with
2430
additional processing to reduce the size of conflict regions.
2431
2432
The following merge types are available:"""
2433
takes_args = ['file*']
2434
takes_options = ['merge-type', 'reprocess',
2435
Option('show-base', help="Show base revision text in "
2436
"conflicts")]
2437
2438
def help(self):
2439
from inspect import getdoc
2440
return getdoc(self) + '\n' + _mod_merge.merge_type_help()
2441
2442
def run(self, file_list=None, merge_type=None, show_base=False,
2443
reprocess=False):
2444
if merge_type is None:
2445
merge_type = _mod_merge.Merge3Merger
2446
tree, file_list = tree_files(file_list)
2447
tree.lock_write()
2448
try:
2449
parents = tree.get_parent_ids()
2450
if len(parents) != 2:
2451
raise errors.BzrCommandError("Sorry, remerge only works after normal"
2452
" merges. Not cherrypicking or"
2453
" multi-merges.")
2454
repository = tree.branch.repository
2455
base_revision = common_ancestor(parents[0],
2456
parents[1], repository)
2457
base_tree = repository.revision_tree(base_revision)
2458
other_tree = repository.revision_tree(parents[1])
2459
interesting_ids = None
2460
new_conflicts = []
2461
conflicts = tree.conflicts()
2462
if file_list is not None:
2463
interesting_ids = set()
2464
for filename in file_list:
2465
file_id = tree.path2id(filename)
2466
if file_id is None:
2467
raise errors.NotVersionedError(filename)
2468
interesting_ids.add(file_id)
2469
if tree.kind(file_id) != "directory":
2470
continue
2471
2472
for name, ie in tree.inventory.iter_entries(file_id):
2473
interesting_ids.add(ie.file_id)
2474
new_conflicts = conflicts.select_conflicts(tree, file_list)[0]
2475
else:
2476
# Remerge only supports resolving contents conflicts
2477
allowed_conflicts = ('text conflict', 'contents conflict')
2478
restore_files = [c.path for c in conflicts
2479
if c.typestring in allowed_conflicts]
2480
_mod_merge.transform_tree(tree, tree.basis_tree(), interesting_ids)
2481
tree.set_conflicts(ConflictList(new_conflicts))
2482
if file_list is not None:
2483
restore_files = file_list
2484
for filename in restore_files:
2485
try:
2486
restore(tree.abspath(filename))
2487
except errors.NotConflicted:
2488
pass
2489
conflicts = _mod_merge.merge_inner(
2490
tree.branch, other_tree, base_tree,
2491
this_tree=tree,
2492
interesting_ids=interesting_ids,
2493
other_rev_id=parents[1],
2494
merge_type=merge_type,
2495
show_base=show_base,
2496
reprocess=reprocess)
2497
finally:
2498
tree.unlock()
2499
if conflicts > 0:
2500
return 1
2501
else:
2502
return 0
2503
2504
2505
class cmd_revert(Command):
2506
"""Revert files to a previous revision.
2507
2508
Giving a list of files will revert only those files. Otherwise, all files
2509
will be reverted. If the revision is not specified with '--revision', the
2510
last committed revision is used.
2511
2512
To remove only some changes, without reverting to a prior version, use
2513
merge instead. For example, "merge . --r-2..-3" will remove the changes
2514
introduced by -2, without affecting the changes introduced by -1. Or
2515
to remove certain changes on a hunk-by-hunk basis, see the Shelf plugin.
2516
2517
By default, any files that have been manually changed will be backed up
2518
first. (Files changed only by merge are not backed up.) Backup files have
2519
'.~#~' appended to their name, where # is a number.
2520
2521
When you provide files, you can use their current pathname or the pathname
2522
from the target revision. So you can use revert to "undelete" a file by
2523
name. If you name a directory, all the contents of that directory will be
2524
reverted.
2525
"""
2526
takes_options = ['revision', 'no-backup']
2527
takes_args = ['file*']
2528
aliases = ['merge-revert']
2529
2530
def run(self, revision=None, no_backup=False, file_list=None):
2531
if file_list is not None:
2532
if len(file_list) == 0:
2533
raise errors.BzrCommandError("No files specified")
2534
else:
2535
file_list = []
2536
2537
tree, file_list = tree_files(file_list)
2538
if revision is None:
2539
# FIXME should be tree.last_revision
2540
rev_id = tree.last_revision()
2541
elif len(revision) != 1:
2542
raise errors.BzrCommandError('bzr revert --revision takes exactly 1 argument')
2543
else:
2544
rev_id = revision[0].in_history(tree.branch).rev_id
2545
pb = ui.ui_factory.nested_progress_bar()
2546
try:
2547
tree.revert(file_list,
2548
tree.branch.repository.revision_tree(rev_id),
2549
not no_backup, pb, report_changes=True)
2550
finally:
2551
pb.finished()
2552
2553
2554
class cmd_assert_fail(Command):
2555
"""Test reporting of assertion failures"""
2556
# intended just for use in testing
2557
2558
hidden = True
2559
2560
def run(self):
2561
raise AssertionError("always fails")
2562
2563
2564
class cmd_help(Command):
2565
"""Show help on a command or other topic.
2566
2567
For a list of all available commands, say 'bzr help commands'.
2568
"""
2569
takes_options = [Option('long', 'show help on all commands')]
2570
takes_args = ['topic?']
2571
aliases = ['?', '--help', '-?', '-h']
2572
2573
@display_command
2574
def run(self, topic=None, long=False):
2575
import bzrlib.help
2576
if topic is None and long:
2577
topic = "commands"
2578
bzrlib.help.help(topic)
2579
2580
2581
class cmd_shell_complete(Command):
2582
"""Show appropriate completions for context.
2583
2584
For a list of all available commands, say 'bzr shell-complete'.
2585
"""
2586
takes_args = ['context?']
2587
aliases = ['s-c']
2588
hidden = True
2589
2590
@display_command
2591
def run(self, context=None):
2592
import shellcomplete
2593
shellcomplete.shellcomplete(context)
2594
2595
2596
class cmd_fetch(Command):
2597
"""Copy in history from another branch but don't merge it.
2598
2599
This is an internal method used for pull and merge.
2600
"""
2601
hidden = True
2602
takes_args = ['from_branch', 'to_branch']
2603
def run(self, from_branch, to_branch):
2604
from bzrlib.fetch import Fetcher
2605
from_b = Branch.open(from_branch)
2606
to_b = Branch.open(to_branch)
2607
Fetcher(to_b, from_b)
2608
2609
2610
class cmd_missing(Command):
2611
"""Show unmerged/unpulled revisions between two branches.
2612
2613
OTHER_BRANCH may be local or remote.
2614
"""
2615
takes_args = ['other_branch?']
2616
takes_options = [Option('reverse', 'Reverse the order of revisions'),
2617
Option('mine-only',
2618
'Display changes in the local branch only'),
2619
Option('theirs-only',
2620
'Display changes in the remote branch only'),
2621
'log-format',
2622
'line',
2623
'long',
2624
'short',
2625
'show-ids',
2626
'verbose'
2627
]
2628
encoding_type = 'replace'
2629
2630
@display_command
2631
def run(self, other_branch=None, reverse=False, mine_only=False,
2632
theirs_only=False, log_format=None, long=False, short=False, line=False,
2633
show_ids=False, verbose=False):
2634
from bzrlib.missing import find_unmerged, iter_log_data
2635
from bzrlib.log import log_formatter
2636
local_branch = Branch.open_containing(u".")[0]
2637
parent = local_branch.get_parent()
2638
if other_branch is None:
2639
other_branch = parent
2640
if other_branch is None:
2641
raise errors.BzrCommandError("No peer location known or specified.")
2642
display_url = urlutils.unescape_for_display(parent,
2643
self.outf.encoding)
2644
print "Using last location: " + display_url
2645
2646
remote_branch = Branch.open(other_branch)
2647
if remote_branch.base == local_branch.base:
2648
remote_branch = local_branch
2649
local_branch.lock_read()
2650
try:
2651
remote_branch.lock_read()
2652
try:
2653
local_extra, remote_extra = find_unmerged(local_branch, remote_branch)
2654
if (log_format is None):
2655
default = local_branch.get_config().log_format()
2656
log_format = get_log_format(long=long, short=short,
2657
line=line, default=default)
2658
lf = log_formatter(log_format,
2659
to_file=self.outf,
2660
show_ids=show_ids,
2661
show_timezone='original')
2662
if reverse is False:
2663
local_extra.reverse()
2664
remote_extra.reverse()
2665
if local_extra and not theirs_only:
2666
print "You have %d extra revision(s):" % len(local_extra)
2667
for data in iter_log_data(local_extra, local_branch.repository,
2668
verbose):
2669
lf.show(*data)
2670
printed_local = True
2671
else:
2672
printed_local = False
2673
if remote_extra and not mine_only:
2674
if printed_local is True:
2675
print "\n\n"
2676
print "You are missing %d revision(s):" % len(remote_extra)
2677
for data in iter_log_data(remote_extra, remote_branch.repository,
2678
verbose):
2679
lf.show(*data)
2680
if not remote_extra and not local_extra:
2681
status_code = 0
2682
print "Branches are up to date."
2683
else:
2684
status_code = 1
2685
finally:
2686
remote_branch.unlock()
2687
finally:
2688
local_branch.unlock()
2689
if not status_code and parent is None and other_branch is not None:
2690
local_branch.lock_write()
2691
try:
2692
# handle race conditions - a parent might be set while we run.
2693
if local_branch.get_parent() is None:
2694
local_branch.set_parent(remote_branch.base)
2695
finally:
2696
local_branch.unlock()
2697
return status_code
2698
2699
2700
class cmd_plugins(Command):
2701
"""List plugins"""
2702
hidden = True
2703
@display_command
2704
def run(self):
2705
import bzrlib.plugin
2706
from inspect import getdoc
2707
for name, plugin in bzrlib.plugin.all_plugins().items():
2708
if getattr(plugin, '__path__', None) is not None:
2709
print plugin.__path__[0]
2710
elif getattr(plugin, '__file__', None) is not None:
2711
print plugin.__file__
2712
else:
2713
print repr(plugin)
2714
2715
d = getdoc(plugin)
2716
if d:
2717
print '\t', d.split('\n')[0]
2718
2719
2720
class cmd_testament(Command):
2721
"""Show testament (signing-form) of a revision."""
2722
takes_options = ['revision',
2723
Option('long', help='Produce long-format testament'),
2724
Option('strict', help='Produce a strict-format'
2725
' testament')]
2726
takes_args = ['branch?']
2727
@display_command
2728
def run(self, branch=u'.', revision=None, long=False, strict=False):
2729
from bzrlib.testament import Testament, StrictTestament
2730
if strict is True:
2731
testament_class = StrictTestament
2732
else:
2733
testament_class = Testament
2734
b = WorkingTree.open_containing(branch)[0].branch
2735
b.lock_read()
2736
try:
2737
if revision is None:
2738
rev_id = b.last_revision()
2739
else:
2740
rev_id = revision[0].in_history(b).rev_id
2741
t = testament_class.from_revision(b.repository, rev_id)
2742
if long:
2743
sys.stdout.writelines(t.as_text_lines())
2744
else:
2745
sys.stdout.write(t.as_short_text())
2746
finally:
2747
b.unlock()
2748
2749
2750
class cmd_annotate(Command):
2751
"""Show the origin of each line in a file.
2752
2753
This prints out the given file with an annotation on the left side
2754
indicating which revision, author and date introduced the change.
2755
2756
If the origin is the same for a run of consecutive lines, it is
2757
shown only at the top, unless the --all option is given.
2758
"""
2759
# TODO: annotate directories; showing when each file was last changed
2760
# TODO: if the working copy is modified, show annotations on that
2761
# with new uncommitted lines marked
2762
aliases = ['ann', 'blame', 'praise']
2763
takes_args = ['filename']
2764
takes_options = [Option('all', help='show annotations on all lines'),
2765
Option('long', help='show date in annotations'),
2766
'revision',
2767
'show-ids',
2768
]
2769
2770
@display_command
2771
def run(self, filename, all=False, long=False, revision=None,
2772
show_ids=False):
2773
from bzrlib.annotate import annotate_file
2774
tree, relpath = WorkingTree.open_containing(filename)
2775
branch = tree.branch
2776
branch.lock_read()
2777
try:
2778
if revision is None:
2779
revision_id = branch.last_revision()
2780
elif len(revision) != 1:
2781
raise errors.BzrCommandError('bzr annotate --revision takes exactly 1 argument')
2782
else:
2783
revision_id = revision[0].in_history(branch).rev_id
2784
file_id = tree.inventory.path2id(relpath)
2785
tree = branch.repository.revision_tree(revision_id)
2786
file_version = tree.inventory[file_id].revision
2787
annotate_file(branch, file_version, file_id, long, all, sys.stdout,
2788
show_ids=show_ids)
2789
finally:
2790
branch.unlock()
2791
2792
2793
class cmd_re_sign(Command):
2794
"""Create a digital signature for an existing revision."""
2795
# TODO be able to replace existing ones.
2796
2797
hidden = True # is this right ?
2798
takes_args = ['revision_id*']
2799
takes_options = ['revision']
2800
2801
def run(self, revision_id_list=None, revision=None):
2802
import bzrlib.gpg as gpg
2803
if revision_id_list is not None and revision is not None:
2804
raise errors.BzrCommandError('You can only supply one of revision_id or --revision')
2805
if revision_id_list is None and revision is None:
2806
raise errors.BzrCommandError('You must supply either --revision or a revision_id')
2807
b = WorkingTree.open_containing(u'.')[0].branch
2808
gpg_strategy = gpg.GPGStrategy(b.get_config())
2809
if revision_id_list is not None:
2810
for revision_id in revision_id_list:
2811
b.repository.sign_revision(revision_id, gpg_strategy)
2812
elif revision is not None:
2813
if len(revision) == 1:
2814
revno, rev_id = revision[0].in_history(b)
2815
b.repository.sign_revision(rev_id, gpg_strategy)
2816
elif len(revision) == 2:
2817
# are they both on rh- if so we can walk between them
2818
# might be nice to have a range helper for arbitrary
2819
# revision paths. hmm.
2820
from_revno, from_revid = revision[0].in_history(b)
2821
to_revno, to_revid = revision[1].in_history(b)
2822
if to_revid is None:
2823
to_revno = b.revno()
2824
if from_revno is None or to_revno is None:
2825
raise errors.BzrCommandError('Cannot sign a range of non-revision-history revisions')
2826
for revno in range(from_revno, to_revno + 1):
2827
b.repository.sign_revision(b.get_rev_id(revno),
2828
gpg_strategy)
2829
else:
2830
raise errors.BzrCommandError('Please supply either one revision, or a range.')
2831
2832
2833
class cmd_bind(Command):
2834
"""Bind the current branch to a master branch.
2835
2836
After binding, commits must succeed on the master branch
2837
before they are executed on the local one.
2838
"""
2839
2840
takes_args = ['location']
2841
takes_options = []
2842
2843
def run(self, location=None):
2844
b, relpath = Branch.open_containing(u'.')
2845
b_other = Branch.open(location)
2846
try:
2847
b.bind(b_other)
2848
except errors.DivergedBranches:
2849
raise errors.BzrCommandError('These branches have diverged.'
2850
' Try merging, and then bind again.')
2851
2852
2853
class cmd_unbind(Command):
2854
"""Unbind the current branch from its master branch.
2855
2856
After unbinding, the local branch is considered independent.
2857
All subsequent commits will be local.
2858
"""
2859
2860
takes_args = []
2861
takes_options = []
2862
2863
def run(self):
2864
b, relpath = Branch.open_containing(u'.')
2865
if not b.unbind():
2866
raise errors.BzrCommandError('Local branch is not bound')
2867
2868
2869
class cmd_uncommit(Command):
2870
"""Remove the last committed revision.
2871
2872
--verbose will print out what is being removed.
2873
--dry-run will go through all the motions, but not actually
2874
remove anything.
2875
2876
In the future, uncommit will create a revision bundle, which can then
2877
be re-applied.
2878
"""
2879
2880
# TODO: jam 20060108 Add an option to allow uncommit to remove
2881
# unreferenced information in 'branch-as-repository' branches.
2882
# TODO: jam 20060108 Add the ability for uncommit to remove unreferenced
2883
# information in shared branches as well.
2884
takes_options = ['verbose', 'revision',
2885
Option('dry-run', help='Don\'t actually make changes'),
2886
Option('force', help='Say yes to all questions.')]
2887
takes_args = ['location?']
2888
aliases = []
2889
2890
def run(self, location=None,
2891
dry_run=False, verbose=False,
2892
revision=None, force=False):
2893
from bzrlib.log import log_formatter, show_log
2894
import sys
2895
from bzrlib.uncommit import uncommit
2896
2897
if location is None:
2898
location = u'.'
2899
control, relpath = bzrdir.BzrDir.open_containing(location)
2900
try:
2901
tree = control.open_workingtree()
2902
b = tree.branch
2903
except (errors.NoWorkingTree, errors.NotLocalUrl):
2904
tree = None
2905
b = control.open_branch()
2906
2907
rev_id = None
2908
if revision is None:
2909
revno = b.revno()
2910
else:
2911
# 'bzr uncommit -r 10' actually means uncommit
2912
# so that the final tree is at revno 10.
2913
# but bzrlib.uncommit.uncommit() actually uncommits
2914
# the revisions that are supplied.
2915
# So we need to offset it by one
2916
revno = revision[0].in_history(b).revno+1
2917
2918
if revno <= b.revno():
2919
rev_id = b.get_rev_id(revno)
2920
if rev_id is None:
2921
self.outf.write('No revisions to uncommit.\n')
2922
return 1
2923
2924
lf = log_formatter('short',
2925
to_file=self.outf,
2926
show_timezone='original')
2927
2928
show_log(b,
2929
lf,
2930
verbose=False,
2931
direction='forward',
2932
start_revision=revno,
2933
end_revision=b.revno())
2934
2935
if dry_run:
2936
print 'Dry-run, pretending to remove the above revisions.'
2937
if not force:
2938
val = raw_input('Press <enter> to continue')
2939
else:
2940
print 'The above revision(s) will be removed.'
2941
if not force:
2942
val = raw_input('Are you sure [y/N]? ')
2943
if val.lower() not in ('y', 'yes'):
2944
print 'Canceled'
2945
return 0
2946
2947
uncommit(b, tree=tree, dry_run=dry_run, verbose=verbose,
2948
revno=revno)
2949
2950
2951
class cmd_break_lock(Command):
2952
"""Break a dead lock on a repository, branch or working directory.
2953
2954
CAUTION: Locks should only be broken when you are sure that the process
2955
holding the lock has been stopped.
2956
2957
You can get information on what locks are open via the 'bzr info' command.
2958
2959
example:
2960
bzr break-lock
2961
"""
2962
takes_args = ['location?']
2963
2964
def run(self, location=None, show=False):
2965
if location is None:
2966
location = u'.'
2967
control, relpath = bzrdir.BzrDir.open_containing(location)
2968
try:
2969
control.break_lock()
2970
except NotImplementedError:
2971
pass
2972
2973
2974
class cmd_wait_until_signalled(Command):
2975
"""Test helper for test_start_and_stop_bzr_subprocess_send_signal.
2976
2977
This just prints a line to signal when it is ready, then blocks on stdin.
2978
"""
2979
2980
hidden = True
2981
2982
def run(self):
2983
sys.stdout.write("running\n")
2984
sys.stdout.flush()
2985
sys.stdin.readline()
2986
2987
2988
class cmd_serve(Command):
2989
"""Run the bzr server."""
2990
2991
aliases = ['server']
2992
2993
takes_options = [
2994
Option('inet',
2995
help='serve on stdin/out for use from inetd or sshd'),
2996
Option('port',
2997
help='listen for connections on nominated port of the form '
2998
'[hostname:]portnumber. Passing 0 as the port number will '
2999
'result in a dynamically allocated port.',
3000
type=str),
3001
Option('directory',
3002
help='serve contents of directory',
3003
type=unicode),
3004
Option('allow-writes',
3005
help='By default the server is a readonly server. Supplying '
3006
'--allow-writes enables write access to the contents of '
3007
'the served directory and below. '
3008
),
3009
]
3010
3011
def run(self, port=None, inet=False, directory=None, allow_writes=False):
3012
from bzrlib.transport import smart
3013
from bzrlib.transport import get_transport
3014
if directory is None:
3015
directory = os.getcwd()
3016
url = urlutils.local_path_to_url(directory)
3017
if not allow_writes:
3018
url = 'readonly+' + url
3019
t = get_transport(url)
3020
if inet:
3021
server = smart.SmartServerPipeStreamMedium(sys.stdin, sys.stdout, t)
3022
elif port is not None:
3023
if ':' in port:
3024
host, port = port.split(':')
3025
else:
3026
host = '127.0.0.1'
3027
server = smart.SmartTCPServer(t, host=host, port=int(port))
3028
print 'listening on port: ', server.port
3029
sys.stdout.flush()
3030
else:
3031
raise errors.BzrCommandError("bzr serve requires one of --inet or --port")
3032
server.serve()
3033
3034
3035
# command-line interpretation helper for merge-related commands
3036
def _merge_helper(other_revision, base_revision,
3037
check_clean=True, ignore_zero=False,
3038
this_dir=None, backup_files=False,
3039
merge_type=None,
3040
file_list=None, show_base=False, reprocess=False,
3041
pull=False,
3042
pb=DummyProgress()):
3043
"""Merge changes into a tree.
3044
3045
base_revision
3046
list(path, revno) Base for three-way merge.
3047
If [None, None] then a base will be automatically determined.
3048
other_revision
3049
list(path, revno) Other revision for three-way merge.
3050
this_dir
3051
Directory to merge changes into; '.' by default.
3052
check_clean
3053
If true, this_dir must have no uncommitted changes before the
3054
merge begins.
3055
ignore_zero - If true, suppress the "zero conflicts" message when
3056
there are no conflicts; should be set when doing something we expect
3057
to complete perfectly.
3058
file_list - If supplied, merge only changes to selected files.
3059
3060
All available ancestors of other_revision and base_revision are
3061
automatically pulled into the branch.
3062
3063
The revno may be -1 to indicate the last revision on the branch, which is
3064
the typical case.
3065
3066
This function is intended for use from the command line; programmatic
3067
clients might prefer to call merge.merge_inner(), which has less magic
3068
behavior.
3069
"""
3070
# Loading it late, so that we don't always have to import bzrlib.merge
3071
if merge_type is None:
3072
merge_type = _mod_merge.Merge3Merger
3073
if this_dir is None:
3074
this_dir = u'.'
3075
this_tree = WorkingTree.open_containing(this_dir)[0]
3076
if show_base and not merge_type is _mod_merge.Merge3Merger:
3077
raise errors.BzrCommandError("Show-base is not supported for this merge"
3078
" type. %s" % merge_type)
3079
if reprocess and not merge_type.supports_reprocess:
3080
raise errors.BzrCommandError("Conflict reduction is not supported for merge"
3081
" type %s." % merge_type)
3082
if reprocess and show_base:
3083
raise errors.BzrCommandError("Cannot do conflict reduction and show base.")
3084
try:
3085
merger = _mod_merge.Merger(this_tree.branch, this_tree=this_tree,
3086
pb=pb)
3087
merger.pp = ProgressPhase("Merge phase", 5, pb)
3088
merger.pp.next_phase()
3089
merger.check_basis(check_clean)
3090
merger.set_other(other_revision)
3091
merger.pp.next_phase()
3092
merger.set_base(base_revision)
3093
if merger.base_rev_id == merger.other_rev_id:
3094
note('Nothing to do.')
3095
return 0
3096
if file_list is None:
3097
if pull and merger.base_rev_id == merger.this_rev_id:
3098
count = merger.this_tree.pull(merger.this_branch,
3099
False, merger.other_rev_id)
3100
note('%d revision(s) pulled.' % (count,))
3101
return 0
3102
merger.backup_files = backup_files
3103
merger.merge_type = merge_type
3104
merger.set_interesting_files(file_list)
3105
merger.show_base = show_base
3106
merger.reprocess = reprocess
3107
conflicts = merger.do_merge()
3108
if file_list is None:
3109
merger.set_pending()
3110
finally:
3111
pb.clear()
3112
return conflicts
3113
3114
3115
# Compatibility
3116
merge = _merge_helper
3117
3118
3119
# these get imported and then picked up by the scan for cmd_*
3120
# TODO: Some more consistent way to split command definitions across files;
3121
# we do need to load at least some information about them to know of
3122
# aliases. ideally we would avoid loading the implementation until the
3123
# details were needed.
3124
from bzrlib.cmd_version_info import cmd_version_info
3125
from bzrlib.conflicts import cmd_resolve, cmd_conflicts, restore
3126
from bzrlib.bundle.commands import cmd_bundle_revisions
3127
from bzrlib.sign_my_commits import cmd_sign_my_commits
3128
from bzrlib.weave_commands import cmd_weave_list, cmd_weave_join, \
3129
cmd_weave_plan_merge, cmd_weave_merge_text
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0