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