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