« back to all changes in this revision
Viewing changes to bzrlib/builtins.py
- browse files at revision 2256.1.1
- compare with another revision
- download diff
- download tarball
- view history from revision 2256.1.1
- Committer: Robert Collins
- Date: 2007-02-02 09:17:23 UTC
- mfrom: (2249.4.2 tip.info)
- mto: This revision was merged to the branch mainline in revision 2257.
- Revision ID: robertc@robertcollins.net-20070202091723-xtak1zzhe2ylwksa
(robertc) Merge new Branch.last_revision_info method.
- files added:
- BRANCH.TODO
- 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/version_info_formats
- contrib/emacs
- tools
- tools/doc_generate
- tools/win32
- files removed:
- bzrlib/mdiff.py
- notes
- patches
- urlgrabber
- files renamed:
- bzrlib/changeset.py => bzrlib/bundle/__init__.py
- bzrlib/store.py => bzrlib/store/__init__.py
- elementtree/ => bzrlib/util/elementtree/
- bzrlib/xml.py => bzrlib/xml_serializer.py
- contrib/bash/bzr => contrib/bash/bzr.simple
- bzrlib/newinventory.py => contrib/newinventory.py
- files modified:
- .bzrignore
- bzr *
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 = br_to.last_revision_info()[0]
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
last1 = branch1.last_revision()
2235
last2 = branch2.last_revision()
2236
2237
source = MultipleRevisionSources(branch1.repository,
2238
branch2.repository)
2239
2240
base_rev_id = common_ancestor(last1, last2, source)
2241
2242
print 'merge base is revision %s' % base_rev_id
2243
2244
2245
class cmd_merge(Command):
2246
"""Perform a three-way merge.
2247
2248
The branch is the branch you will merge from. By default, it will merge
2249
the latest revision. If you specify a revision, that revision will be
2250
merged. If you specify two revisions, the first will be used as a BASE,
2251
and the second one as OTHER. Revision numbers are always relative to the
2252
specified branch.
2253
2254
By default, bzr will try to merge in all new work from the other
2255
branch, automatically determining an appropriate base. If this
2256
fails, you may need to give an explicit base.
2257
2258
Merge will do its best to combine the changes in two branches, but there
2259
are some kinds of problems only a human can fix. When it encounters those,
2260
it will mark a conflict. A conflict means that you need to fix something,
2261
before you should commit.
2262
2263
Use bzr resolve when you have fixed a problem. See also bzr conflicts.
2264
2265
If there is no default branch set, the first merge will set it. After
2266
that, you can omit the branch to use the default. To change the
2267
default, use --remember. The value will only be saved if the remote
2268
location can be accessed.
2269
2270
Examples:
2271
2272
To merge the latest revision from bzr.dev
2273
bzr merge ../bzr.dev
2274
2275
To merge changes up to and including revision 82 from bzr.dev
2276
bzr merge -r 82 ../bzr.dev
2277
2278
To merge the changes introduced by 82, without previous changes:
2279
bzr merge -r 81..82 ../bzr.dev
2280
2281
merge refuses to run if there are any uncommitted changes, unless
2282
--force is given.
2283
2284
The following merge types are available:
2285
"""
2286
takes_args = ['branch?']
2287
takes_options = ['revision', 'force', 'merge-type', 'reprocess', 'remember',
2288
Option('show-base', help="Show base revision text in "
2289
"conflicts"),
2290
Option('uncommitted', help='Apply uncommitted changes'
2291
' from a working copy, instead of branch changes'),
2292
Option('pull', help='If the destination is already'
2293
' completely merged into the source, pull from the'
2294
' source rather than merging. When this happens,'
2295
' you do not need to commit the result.'),
2296
]
2297
2298
def help(self):
2299
from inspect import getdoc
2300
return getdoc(self) + '\n' + _mod_merge.merge_type_help()
2301
2302
def run(self, branch=None, revision=None, force=False, merge_type=None,
2303
show_base=False, reprocess=False, remember=False,
2304
uncommitted=False, pull=False):
2305
if merge_type is None:
2306
merge_type = _mod_merge.Merge3Merger
2307
2308
tree = WorkingTree.open_containing(u'.')[0]
2309
2310
if branch is not None:
2311
try:
2312
reader = bundle.read_bundle_from_url(branch)
2313
except errors.NotABundle:
2314
pass # Continue on considering this url a Branch
2315
else:
2316
conflicts = merge_bundle(reader, tree, not force, merge_type,
2317
reprocess, show_base)
2318
if conflicts == 0:
2319
return 0
2320
else:
2321
return 1
2322
2323
if revision is None \
2324
or len(revision) < 1 or revision[0].needs_branch():
2325
branch = self._get_remembered_parent(tree, branch, 'Merging from')
2326
2327
if revision is None or len(revision) < 1:
2328
if uncommitted:
2329
base = [branch, -1]
2330
other = [branch, None]
2331
else:
2332
base = [None, None]
2333
other = [branch, -1]
2334
other_branch, path = Branch.open_containing(branch)
2335
else:
2336
if uncommitted:
2337
raise errors.BzrCommandError('Cannot use --uncommitted and'
2338
' --revision at the same time.')
2339
branch = revision[0].get_branch() or branch
2340
if len(revision) == 1:
2341
base = [None, None]
2342
other_branch, path = Branch.open_containing(branch)
2343
revno = revision[0].in_history(other_branch).revno
2344
other = [branch, revno]
2345
else:
2346
assert len(revision) == 2
2347
if None in revision:
2348
raise errors.BzrCommandError(
2349
"Merge doesn't permit empty revision specifier.")
2350
base_branch, path = Branch.open_containing(branch)
2351
branch1 = revision[1].get_branch() or branch
2352
other_branch, path1 = Branch.open_containing(branch1)
2353
if revision[0].get_branch() is not None:
2354
# then path was obtained from it, and is None.
2355
path = path1
2356
2357
base = [branch, revision[0].in_history(base_branch).revno]
2358
other = [branch1, revision[1].in_history(other_branch).revno]
2359
2360
if tree.branch.get_parent() is None or remember:
2361
tree.branch.set_parent(other_branch.base)
2362
2363
if path != "":
2364
interesting_files = [path]
2365
else:
2366
interesting_files = None
2367
pb = ui.ui_factory.nested_progress_bar()
2368
try:
2369
try:
2370
conflict_count = _merge_helper(
2371
other, base, check_clean=(not force),
2372
merge_type=merge_type,
2373
reprocess=reprocess,
2374
show_base=show_base,
2375
pull=pull,
2376
pb=pb, file_list=interesting_files)
2377
finally:
2378
pb.finished()
2379
if conflict_count != 0:
2380
return 1
2381
else:
2382
return 0
2383
except errors.AmbiguousBase, e:
2384
m = ("sorry, bzr can't determine the right merge base yet\n"
2385
"candidates are:\n "
2386
+ "\n ".join(e.bases)
2387
+ "\n"
2388
"please specify an explicit base with -r,\n"
2389
"and (if you want) report this to the bzr developers\n")
2390
log_error(m)
2391
2392
# TODO: move up to common parent; this isn't merge-specific anymore.
2393
def _get_remembered_parent(self, tree, supplied_location, verb_string):
2394
"""Use tree.branch's parent if none was supplied.
2395
2396
Report if the remembered location was used.
2397
"""
2398
if supplied_location is not None:
2399
return supplied_location
2400
stored_location = tree.branch.get_parent()
2401
mutter("%s", stored_location)
2402
if stored_location is None:
2403
raise errors.BzrCommandError("No location specified or remembered")
2404
display_url = urlutils.unescape_for_display(stored_location, self.outf.encoding)
2405
self.outf.write("%s remembered location %s\n" % (verb_string, display_url))
2406
return stored_location
2407
2408
2409
class cmd_remerge(Command):
2410
"""Redo a merge.
2411
2412
Use this if you want to try a different merge technique while resolving
2413
conflicts. Some merge techniques are better than others, and remerge
2414
lets you try different ones on different files.
2415
2416
The options for remerge have the same meaning and defaults as the ones for
2417
merge. The difference is that remerge can (only) be run when there is a
2418
pending merge, and it lets you specify particular files.
2419
2420
Examples:
2421
$ bzr remerge --show-base
2422
Re-do the merge of all conflicted files, and show the base text in
2423
conflict regions, in addition to the usual THIS and OTHER texts.
2424
2425
$ bzr remerge --merge-type weave --reprocess foobar
2426
Re-do the merge of "foobar", using the weave merge algorithm, with
2427
additional processing to reduce the size of conflict regions.
2428
2429
The following merge types are available:"""
2430
takes_args = ['file*']
2431
takes_options = ['merge-type', 'reprocess',
2432
Option('show-base', help="Show base revision text in "
2433
"conflicts")]
2434
2435
def help(self):
2436
from inspect import getdoc
2437
return getdoc(self) + '\n' + _mod_merge.merge_type_help()
2438
2439
def run(self, file_list=None, merge_type=None, show_base=False,
2440
reprocess=False):
2441
if merge_type is None:
2442
merge_type = _mod_merge.Merge3Merger
2443
tree, file_list = tree_files(file_list)
2444
tree.lock_write()
2445
try:
2446
parents = tree.get_parent_ids()
2447
if len(parents) != 2:
2448
raise errors.BzrCommandError("Sorry, remerge only works after normal"
2449
" merges. Not cherrypicking or"
2450
" multi-merges.")
2451
repository = tree.branch.repository
2452
base_revision = common_ancestor(parents[0],
2453
parents[1], repository)
2454
base_tree = repository.revision_tree(base_revision)
2455
other_tree = repository.revision_tree(parents[1])
2456
interesting_ids = None
2457
new_conflicts = []
2458
conflicts = tree.conflicts()
2459
if file_list is not None:
2460
interesting_ids = set()
2461
for filename in file_list:
2462
file_id = tree.path2id(filename)
2463
if file_id is None:
2464
raise errors.NotVersionedError(filename)
2465
interesting_ids.add(file_id)
2466
if tree.kind(file_id) != "directory":
2467
continue
2468
2469
for name, ie in tree.inventory.iter_entries(file_id):
2470
interesting_ids.add(ie.file_id)
2471
new_conflicts = conflicts.select_conflicts(tree, file_list)[0]
2472
else:
2473
# Remerge only supports resolving contents conflicts
2474
allowed_conflicts = ('text conflict', 'contents conflict')
2475
restore_files = [c.path for c in conflicts
2476
if c.typestring in allowed_conflicts]
2477
_mod_merge.transform_tree(tree, tree.basis_tree(), interesting_ids)
2478
tree.set_conflicts(ConflictList(new_conflicts))
2479
if file_list is not None:
2480
restore_files = file_list
2481
for filename in restore_files:
2482
try:
2483
restore(tree.abspath(filename))
2484
except errors.NotConflicted:
2485
pass
2486
conflicts = _mod_merge.merge_inner(
2487
tree.branch, other_tree, base_tree,
2488
this_tree=tree,
2489
interesting_ids=interesting_ids,
2490
other_rev_id=parents[1],
2491
merge_type=merge_type,
2492
show_base=show_base,
2493
reprocess=reprocess)
2494
finally:
2495
tree.unlock()
2496
if conflicts > 0:
2497
return 1
2498
else:
2499
return 0
2500
2501
2502
class cmd_revert(Command):
2503
"""Revert files to a previous revision.
2504
2505
Giving a list of files will revert only those files. Otherwise, all files
2506
will be reverted. If the revision is not specified with '--revision', the
2507
last committed revision is used.
2508
2509
To remove only some changes, without reverting to a prior version, use
2510
merge instead. For example, "merge . --r-2..-3" will remove the changes
2511
introduced by -2, without affecting the changes introduced by -1. Or
2512
to remove certain changes on a hunk-by-hunk basis, see the Shelf plugin.
2513
2514
By default, any files that have been manually changed will be backed up
2515
first. (Files changed only by merge are not backed up.) Backup files have
2516
'.~#~' appended to their name, where # is a number.
2517
2518
When you provide files, you can use their current pathname or the pathname
2519
from the target revision. So you can use revert to "undelete" a file by
2520
name. If you name a directory, all the contents of that directory will be
2521
reverted.
2522
"""
2523
takes_options = ['revision', 'no-backup']
2524
takes_args = ['file*']
2525
aliases = ['merge-revert']
2526
2527
def run(self, revision=None, no_backup=False, file_list=None):
2528
if file_list is not None:
2529
if len(file_list) == 0:
2530
raise errors.BzrCommandError("No files specified")
2531
else:
2532
file_list = []
2533
2534
tree, file_list = tree_files(file_list)
2535
if revision is None:
2536
# FIXME should be tree.last_revision
2537
rev_id = tree.last_revision()
2538
elif len(revision) != 1:
2539
raise errors.BzrCommandError('bzr revert --revision takes exactly 1 argument')
2540
else:
2541
rev_id = revision[0].in_history(tree.branch).rev_id
2542
pb = ui.ui_factory.nested_progress_bar()
2543
try:
2544
tree.revert(file_list,
2545
tree.branch.repository.revision_tree(rev_id),
2546
not no_backup, pb, report_changes=True)
2547
finally:
2548
pb.finished()
2549
2550
2551
class cmd_assert_fail(Command):
2552
"""Test reporting of assertion failures"""
2553
# intended just for use in testing
2554
2555
hidden = True
2556
2557
def run(self):
2558
raise AssertionError("always fails")
2559
2560
2561
class cmd_help(Command):
2562
"""Show help on a command or other topic.
2563
2564
For a list of all available commands, say 'bzr help commands'.
2565
"""
2566
takes_options = [Option('long', 'show help on all commands')]
2567
takes_args = ['topic?']
2568
aliases = ['?', '--help', '-?', '-h']
2569
2570
@display_command
2571
def run(self, topic=None, long=False):
2572
import bzrlib.help
2573
if topic is None and long:
2574
topic = "commands"
2575
bzrlib.help.help(topic)
2576
2577
2578
class cmd_shell_complete(Command):
2579
"""Show appropriate completions for context.
2580
2581
For a list of all available commands, say 'bzr shell-complete'.
2582
"""
2583
takes_args = ['context?']
2584
aliases = ['s-c']
2585
hidden = True
2586
2587
@display_command
2588
def run(self, context=None):
2589
import shellcomplete
2590
shellcomplete.shellcomplete(context)
2591
2592
2593
class cmd_fetch(Command):
2594
"""Copy in history from another branch but don't merge it.
2595
2596
This is an internal method used for pull and merge.
2597
"""
2598
hidden = True
2599
takes_args = ['from_branch', 'to_branch']
2600
def run(self, from_branch, to_branch):
2601
from bzrlib.fetch import Fetcher
2602
from_b = Branch.open(from_branch)
2603
to_b = Branch.open(to_branch)
2604
Fetcher(to_b, from_b)
2605
2606
2607
class cmd_missing(Command):
2608
"""Show unmerged/unpulled revisions between two branches.
2609
2610
OTHER_BRANCH may be local or remote.
2611
"""
2612
takes_args = ['other_branch?']
2613
takes_options = [Option('reverse', 'Reverse the order of revisions'),
2614
Option('mine-only',
2615
'Display changes in the local branch only'),
2616
Option('theirs-only',
2617
'Display changes in the remote branch only'),
2618
'log-format',
2619
'line',
2620
'long',
2621
'short',
2622
'show-ids',
2623
'verbose'
2624
]
2625
encoding_type = 'replace'
2626
2627
@display_command
2628
def run(self, other_branch=None, reverse=False, mine_only=False,
2629
theirs_only=False, log_format=None, long=False, short=False, line=False,
2630
show_ids=False, verbose=False):
2631
from bzrlib.missing import find_unmerged, iter_log_data
2632
from bzrlib.log import log_formatter
2633
local_branch = Branch.open_containing(u".")[0]
2634
parent = local_branch.get_parent()
2635
if other_branch is None:
2636
other_branch = parent
2637
if other_branch is None:
2638
raise errors.BzrCommandError("No peer location known or specified.")
2639
display_url = urlutils.unescape_for_display(parent,
2640
self.outf.encoding)
2641
print "Using last location: " + display_url
2642
2643
remote_branch = Branch.open(other_branch)
2644
if remote_branch.base == local_branch.base:
2645
remote_branch = local_branch
2646
local_branch.lock_read()
2647
try:
2648
remote_branch.lock_read()
2649
try:
2650
local_extra, remote_extra = find_unmerged(local_branch, remote_branch)
2651
if (log_format is None):
2652
default = local_branch.get_config().log_format()
2653
log_format = get_log_format(long=long, short=short,
2654
line=line, default=default)
2655
lf = log_formatter(log_format,
2656
to_file=self.outf,
2657
show_ids=show_ids,
2658
show_timezone='original')
2659
if reverse is False:
2660
local_extra.reverse()
2661
remote_extra.reverse()
2662
if local_extra and not theirs_only:
2663
print "You have %d extra revision(s):" % len(local_extra)
2664
for data in iter_log_data(local_extra, local_branch.repository,
2665
verbose):
2666
lf.show(*data)
2667
printed_local = True
2668
else:
2669
printed_local = False
2670
if remote_extra and not mine_only:
2671
if printed_local is True:
2672
print "\n\n"
2673
print "You are missing %d revision(s):" % len(remote_extra)
2674
for data in iter_log_data(remote_extra, remote_branch.repository,
2675
verbose):
2676
lf.show(*data)
2677
if not remote_extra and not local_extra:
2678
status_code = 0
2679
print "Branches are up to date."
2680
else:
2681
status_code = 1
2682
finally:
2683
remote_branch.unlock()
2684
finally:
2685
local_branch.unlock()
2686
if not status_code and parent is None and other_branch is not None:
2687
local_branch.lock_write()
2688
try:
2689
# handle race conditions - a parent might be set while we run.
2690
if local_branch.get_parent() is None:
2691
local_branch.set_parent(remote_branch.base)
2692
finally:
2693
local_branch.unlock()
2694
return status_code
2695
2696
2697
class cmd_plugins(Command):
2698
"""List plugins"""
2699
hidden = True
2700
@display_command
2701
def run(self):
2702
import bzrlib.plugin
2703
from inspect import getdoc
2704
for name, plugin in bzrlib.plugin.all_plugins().items():
2705
if getattr(plugin, '__path__', None) is not None:
2706
print plugin.__path__[0]
2707
elif getattr(plugin, '__file__', None) is not None:
2708
print plugin.__file__
2709
else:
2710
print repr(plugin)
2711
2712
d = getdoc(plugin)
2713
if d:
2714
print '\t', d.split('\n')[0]
2715
2716
2717
class cmd_testament(Command):
2718
"""Show testament (signing-form) of a revision."""
2719
takes_options = ['revision',
2720
Option('long', help='Produce long-format testament'),
2721
Option('strict', help='Produce a strict-format'
2722
' testament')]
2723
takes_args = ['branch?']
2724
@display_command
2725
def run(self, branch=u'.', revision=None, long=False, strict=False):
2726
from bzrlib.testament import Testament, StrictTestament
2727
if strict is True:
2728
testament_class = StrictTestament
2729
else:
2730
testament_class = Testament
2731
b = WorkingTree.open_containing(branch)[0].branch
2732
b.lock_read()
2733
try:
2734
if revision is None:
2735
rev_id = b.last_revision()
2736
else:
2737
rev_id = revision[0].in_history(b).rev_id
2738
t = testament_class.from_revision(b.repository, rev_id)
2739
if long:
2740
sys.stdout.writelines(t.as_text_lines())
2741
else:
2742
sys.stdout.write(t.as_short_text())
2743
finally:
2744
b.unlock()
2745
2746
2747
class cmd_annotate(Command):
2748
"""Show the origin of each line in a file.
2749
2750
This prints out the given file with an annotation on the left side
2751
indicating which revision, author and date introduced the change.
2752
2753
If the origin is the same for a run of consecutive lines, it is
2754
shown only at the top, unless the --all option is given.
2755
"""
2756
# TODO: annotate directories; showing when each file was last changed
2757
# TODO: if the working copy is modified, show annotations on that
2758
# with new uncommitted lines marked
2759
aliases = ['ann', 'blame', 'praise']
2760
takes_args = ['filename']
2761
takes_options = [Option('all', help='show annotations on all lines'),
2762
Option('long', help='show date in annotations'),
2763
'revision',
2764
'show-ids',
2765
]
2766
2767
@display_command
2768
def run(self, filename, all=False, long=False, revision=None,
2769
show_ids=False):
2770
from bzrlib.annotate import annotate_file
2771
tree, relpath = WorkingTree.open_containing(filename)
2772
branch = tree.branch
2773
branch.lock_read()
2774
try:
2775
if revision is None:
2776
revision_id = branch.last_revision()
2777
elif len(revision) != 1:
2778
raise errors.BzrCommandError('bzr annotate --revision takes exactly 1 argument')
2779
else:
2780
revision_id = revision[0].in_history(branch).rev_id
2781
file_id = tree.inventory.path2id(relpath)
2782
tree = branch.repository.revision_tree(revision_id)
2783
file_version = tree.inventory[file_id].revision
2784
annotate_file(branch, file_version, file_id, long, all, sys.stdout,
2785
show_ids=show_ids)
2786
finally:
2787
branch.unlock()
2788
2789
2790
class cmd_re_sign(Command):
2791
"""Create a digital signature for an existing revision."""
2792
# TODO be able to replace existing ones.
2793
2794
hidden = True # is this right ?
2795
takes_args = ['revision_id*']
2796
takes_options = ['revision']
2797
2798
def run(self, revision_id_list=None, revision=None):
2799
import bzrlib.gpg as gpg
2800
if revision_id_list is not None and revision is not None:
2801
raise errors.BzrCommandError('You can only supply one of revision_id or --revision')
2802
if revision_id_list is None and revision is None:
2803
raise errors.BzrCommandError('You must supply either --revision or a revision_id')
2804
b = WorkingTree.open_containing(u'.')[0].branch
2805
gpg_strategy = gpg.GPGStrategy(b.get_config())
2806
if revision_id_list is not None:
2807
for revision_id in revision_id_list:
2808
b.repository.sign_revision(revision_id, gpg_strategy)
2809
elif revision is not None:
2810
if len(revision) == 1:
2811
revno, rev_id = revision[0].in_history(b)
2812
b.repository.sign_revision(rev_id, gpg_strategy)
2813
elif len(revision) == 2:
2814
# are they both on rh- if so we can walk between them
2815
# might be nice to have a range helper for arbitrary
2816
# revision paths. hmm.
2817
from_revno, from_revid = revision[0].in_history(b)
2818
to_revno, to_revid = revision[1].in_history(b)
2819
if to_revid is None:
2820
to_revno = b.revno()
2821
if from_revno is None or to_revno is None:
2822
raise errors.BzrCommandError('Cannot sign a range of non-revision-history revisions')
2823
for revno in range(from_revno, to_revno + 1):
2824
b.repository.sign_revision(b.get_rev_id(revno),
2825
gpg_strategy)
2826
else:
2827
raise errors.BzrCommandError('Please supply either one revision, or a range.')
2828
2829
2830
class cmd_bind(Command):
2831
"""Bind the current branch to a master branch.
2832
2833
After binding, commits must succeed on the master branch
2834
before they are executed on the local one.
2835
"""
2836
2837
takes_args = ['location']
2838
takes_options = []
2839
2840
def run(self, location=None):
2841
b, relpath = Branch.open_containing(u'.')
2842
b_other = Branch.open(location)
2843
try:
2844
b.bind(b_other)
2845
except errors.DivergedBranches:
2846
raise errors.BzrCommandError('These branches have diverged.'
2847
' Try merging, and then bind again.')
2848
2849
2850
class cmd_unbind(Command):
2851
"""Unbind the current branch from its master branch.
2852
2853
After unbinding, the local branch is considered independent.
2854
All subsequent commits will be local.
2855
"""
2856
2857
takes_args = []
2858
takes_options = []
2859
2860
def run(self):
2861
b, relpath = Branch.open_containing(u'.')
2862
if not b.unbind():
2863
raise errors.BzrCommandError('Local branch is not bound')
2864
2865
2866
class cmd_uncommit(Command):
2867
"""Remove the last committed revision.
2868
2869
--verbose will print out what is being removed.
2870
--dry-run will go through all the motions, but not actually
2871
remove anything.
2872
2873
In the future, uncommit will create a revision bundle, which can then
2874
be re-applied.
2875
"""
2876
2877
# TODO: jam 20060108 Add an option to allow uncommit to remove
2878
# unreferenced information in 'branch-as-repository' branches.
2879
# TODO: jam 20060108 Add the ability for uncommit to remove unreferenced
2880
# information in shared branches as well.
2881
takes_options = ['verbose', 'revision',
2882
Option('dry-run', help='Don\'t actually make changes'),
2883
Option('force', help='Say yes to all questions.')]
2884
takes_args = ['location?']
2885
aliases = []
2886
2887
def run(self, location=None,
2888
dry_run=False, verbose=False,
2889
revision=None, force=False):
2890
from bzrlib.log import log_formatter, show_log
2891
import sys
2892
from bzrlib.uncommit import uncommit
2893
2894
if location is None:
2895
location = u'.'
2896
control, relpath = bzrdir.BzrDir.open_containing(location)
2897
try:
2898
tree = control.open_workingtree()
2899
b = tree.branch
2900
except (errors.NoWorkingTree, errors.NotLocalUrl):
2901
tree = None
2902
b = control.open_branch()
2903
2904
rev_id = None
2905
if revision is None:
2906
revno = b.revno()
2907
else:
2908
# 'bzr uncommit -r 10' actually means uncommit
2909
# so that the final tree is at revno 10.
2910
# but bzrlib.uncommit.uncommit() actually uncommits
2911
# the revisions that are supplied.
2912
# So we need to offset it by one
2913
revno = revision[0].in_history(b).revno+1
2914
2915
if revno <= b.revno():
2916
rev_id = b.get_rev_id(revno)
2917
if rev_id is None:
2918
self.outf.write('No revisions to uncommit.\n')
2919
return 1
2920
2921
lf = log_formatter('short',
2922
to_file=self.outf,
2923
show_timezone='original')
2924
2925
show_log(b,
2926
lf,
2927
verbose=False,
2928
direction='forward',
2929
start_revision=revno,
2930
end_revision=b.revno())
2931
2932
if dry_run:
2933
print 'Dry-run, pretending to remove the above revisions.'
2934
if not force:
2935
val = raw_input('Press <enter> to continue')
2936
else:
2937
print 'The above revision(s) will be removed.'
2938
if not force:
2939
val = raw_input('Are you sure [y/N]? ')
2940
if val.lower() not in ('y', 'yes'):
2941
print 'Canceled'
2942
return 0
2943
2944
uncommit(b, tree=tree, dry_run=dry_run, verbose=verbose,
2945
revno=revno)
2946
2947
2948
class cmd_break_lock(Command):
2949
"""Break a dead lock on a repository, branch or working directory.
2950
2951
CAUTION: Locks should only be broken when you are sure that the process
2952
holding the lock has been stopped.
2953
2954
You can get information on what locks are open via the 'bzr info' command.
2955
2956
example:
2957
bzr break-lock
2958
"""
2959
takes_args = ['location?']
2960
2961
def run(self, location=None, show=False):
2962
if location is None:
2963
location = u'.'
2964
control, relpath = bzrdir.BzrDir.open_containing(location)
2965
try:
2966
control.break_lock()
2967
except NotImplementedError:
2968
pass
2969
2970
2971
class cmd_wait_until_signalled(Command):
2972
"""Test helper for test_start_and_stop_bzr_subprocess_send_signal.
2973
2974
This just prints a line to signal when it is ready, then blocks on stdin.
2975
"""
2976
2977
hidden = True
2978
2979
def run(self):
2980
sys.stdout.write("running\n")
2981
sys.stdout.flush()
2982
sys.stdin.readline()
2983
2984
2985
class cmd_serve(Command):
2986
"""Run the bzr server."""
2987
2988
aliases = ['server']
2989
2990
takes_options = [
2991
Option('inet',
2992
help='serve on stdin/out for use from inetd or sshd'),
2993
Option('port',
2994
help='listen for connections on nominated port of the form '
2995
'[hostname:]portnumber. Passing 0 as the port number will '
2996
'result in a dynamically allocated port.',
2997
type=str),
2998
Option('directory',
2999
help='serve contents of directory',
3000
type=unicode),
3001
Option('allow-writes',
3002
help='By default the server is a readonly server. Supplying '
3003
'--allow-writes enables write access to the contents of '
3004
'the served directory and below. '
3005
),
3006
]
3007
3008
def run(self, port=None, inet=False, directory=None, allow_writes=False):
3009
from bzrlib.transport import smart
3010
from bzrlib.transport import get_transport
3011
if directory is None:
3012
directory = os.getcwd()
3013
url = urlutils.local_path_to_url(directory)
3014
if not allow_writes:
3015
url = 'readonly+' + url
3016
t = get_transport(url)
3017
if inet:
3018
server = smart.SmartServerPipeStreamMedium(sys.stdin, sys.stdout, t)
3019
elif port is not None:
3020
if ':' in port:
3021
host, port = port.split(':')
3022
else:
3023
host = '127.0.0.1'
3024
server = smart.SmartTCPServer(t, host=host, port=int(port))
3025
print 'listening on port: ', server.port
3026
sys.stdout.flush()
3027
else:
3028
raise errors.BzrCommandError("bzr serve requires one of --inet or --port")
3029
server.serve()
3030
3031
3032
# command-line interpretation helper for merge-related commands
3033
def _merge_helper(other_revision, base_revision,
3034
check_clean=True, ignore_zero=False,
3035
this_dir=None, backup_files=False,
3036
merge_type=None,
3037
file_list=None, show_base=False, reprocess=False,
3038
pull=False,
3039
pb=DummyProgress()):
3040
"""Merge changes into a tree.
3041
3042
base_revision
3043
list(path, revno) Base for three-way merge.
3044
If [None, None] then a base will be automatically determined.
3045
other_revision
3046
list(path, revno) Other revision for three-way merge.
3047
this_dir
3048
Directory to merge changes into; '.' by default.
3049
check_clean
3050
If true, this_dir must have no uncommitted changes before the
3051
merge begins.
3052
ignore_zero - If true, suppress the "zero conflicts" message when
3053
there are no conflicts; should be set when doing something we expect
3054
to complete perfectly.
3055
file_list - If supplied, merge only changes to selected files.
3056
3057
All available ancestors of other_revision and base_revision are
3058
automatically pulled into the branch.
3059
3060
The revno may be -1 to indicate the last revision on the branch, which is
3061
the typical case.
3062
3063
This function is intended for use from the command line; programmatic
3064
clients might prefer to call merge.merge_inner(), which has less magic
3065
behavior.
3066
"""
3067
# Loading it late, so that we don't always have to import bzrlib.merge
3068
if merge_type is None:
3069
merge_type = _mod_merge.Merge3Merger
3070
if this_dir is None:
3071
this_dir = u'.'
3072
this_tree = WorkingTree.open_containing(this_dir)[0]
3073
if show_base and not merge_type is _mod_merge.Merge3Merger:
3074
raise errors.BzrCommandError("Show-base is not supported for this merge"
3075
" type. %s" % merge_type)
3076
if reprocess and not merge_type.supports_reprocess:
3077
raise errors.BzrCommandError("Conflict reduction is not supported for merge"
3078
" type %s." % merge_type)
3079
if reprocess and show_base:
3080
raise errors.BzrCommandError("Cannot do conflict reduction and show base.")
3081
try:
3082
merger = _mod_merge.Merger(this_tree.branch, this_tree=this_tree,
3083
pb=pb)
3084
merger.pp = ProgressPhase("Merge phase", 5, pb)
3085
merger.pp.next_phase()
3086
merger.check_basis(check_clean)
3087
merger.set_other(other_revision)
3088
merger.pp.next_phase()
3089
merger.set_base(base_revision)
3090
if merger.base_rev_id == merger.other_rev_id:
3091
note('Nothing to do.')
3092
return 0
3093
if file_list is None:
3094
if pull and merger.base_rev_id == merger.this_rev_id:
3095
count = merger.this_tree.pull(merger.this_branch,
3096
False, merger.other_rev_id)
3097
note('%d revision(s) pulled.' % (count,))
3098
return 0
3099
merger.backup_files = backup_files
3100
merger.merge_type = merge_type
3101
merger.set_interesting_files(file_list)
3102
merger.show_base = show_base
3103
merger.reprocess = reprocess
3104
conflicts = merger.do_merge()
3105
if file_list is None:
3106
merger.set_pending()
3107
finally:
3108
pb.clear()
3109
return conflicts
3110
3111
3112
# Compatibility
3113
merge = _merge_helper
3114
3115
3116
# these get imported and then picked up by the scan for cmd_*
3117
# TODO: Some more consistent way to split command definitions across files;
3118
# we do need to load at least some information about them to know of
3119
# aliases. ideally we would avoid loading the implementation until the
3120
# details were needed.
3121
from bzrlib.cmd_version_info import cmd_version_info
3122
from bzrlib.conflicts import cmd_resolve, cmd_conflicts, restore
3123
from bzrlib.bundle.commands import cmd_bundle_revisions
3124
from bzrlib.sign_my_commits import cmd_sign_my_commits
3125
from bzrlib.weave_commands import cmd_weave_list, cmd_weave_join, \
3126
cmd_weave_plan_merge, cmd_weave_merge_text
Loggerhead is a web-based interface for Breezy
Version: 2.0.1