(root)/brz/remove-bazaar
» Revision
1908.11.7
(compared to revision 0.200.1036)
: bzrlib/builtins.py
To get this branch, use:
bzr branch
http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar
« back to all changes in this revision
Viewing changes to bzrlib/builtins.py
- browse files at revision 1908.11.7
- compare with another revision
- download diff
- download tarball
- view history from revision 1908.11.7
- Committer: John Arbash Meinel
- Date: 2007-02-02 04:23:24 UTC
- mfrom: (2255 +trunk)
- mto: (1852.16.5 Tree.walkdirs)
- mto: This revision was merged to the branch mainline in revision 2322.
- Revision ID: john@arbash-meinel.com-20070202042324-n50b1g3l37mlj86k
[merge] bzr.dev 2255
- files added:
- .bzrignore
- bzrlib
- bzrlib/benchmarks
- bzrlib/benchmarks/tree_creator
- bzrlib/bundle
- bzrlib/bundle/old
- bzrlib/bundle/serializer
- bzrlib/doc
- bzrlib/doc/api
- bzrlib/export
- bzrlib/plugins
- bzrlib/plugins/launchpad
- bzrlib/repofmt
- bzrlib/store
- bzrlib/store/revision
- bzrlib/store/versioned
- bzrlib/tests
- bzrlib/tests/blackbox
- bzrlib/tests/branch_implementations
- bzrlib/tests/bzrdir_implementations
- bzrlib/tests/interrepository_implementations
- bzrlib/tests/intertree_implementations
- bzrlib/tests/interversionedfile_implementations
- bzrlib/tests/repository_implementations
- bzrlib/tests/revisionstore_implementations
- bzrlib/tests/test_patches_data
- bzrlib/tests/tree_implementations
- bzrlib/tests/workingtree_implementations
- bzrlib/transport
- bzrlib/transport/http
- bzrlib/ui
- bzrlib/util
- bzrlib/util/configobj
- bzrlib/util/configobj/docs
- bzrlib/util/effbot
- bzrlib/util/effbot/org
- bzrlib/util/elementtree
- bzrlib/version_info_formats
- contrib
- contrib/bash
- contrib/emacs
- contrib/zsh
- doc
- tools
- tools/doc_generate
- tools/win32
- files removed:
- .bzrignore
- notes
- tests
added
removed
bzrlib/builtins.py
1
# Copyright (C) 2004, 2005, 2006 Canonical Ltd
2
#
3
# This program is free software; you can redistribute it and/or modify
4
# it under the terms of the GNU General Public License as published by
5
# the Free Software Foundation; either version 2 of the License, or
6
# (at your option) any later version.
7
#
8
# This program is distributed in the hope that it will be useful,
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11
# GNU General Public License for more details.
12
#
13
# You should have received a copy of the GNU General Public License
14
# along with this program; if not, write to the Free Software
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
16
17
"""builtin bzr commands"""
18
19
import os
20
21
from bzrlib.lazy_import import lazy_import
22
lazy_import(globals(), """
23
import codecs
24
import errno
25
import sys
26
import tempfile
27
28
import bzrlib
29
from bzrlib import (
30
branch,
31
bundle,
32
bzrdir,
33
delta,
34
config,
35
errors,
36
ignores,
37
log,
38
merge as _mod_merge,
39
osutils,
40
repository,
41
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
for fp, fc, fkind, fid, entry in tree.list_files(include_root=False):
1581
if fp.startswith(relpath):
1582
fp = osutils.pathjoin(prefix, fp[len(relpath):])
1583
if non_recursive and '/' in fp:
1584
continue
1585
if not all and not selection[fc]:
1586
continue
1587
if kind is not None and fkind != kind:
1588
continue
1589
if verbose:
1590
kindch = entry.kind_character()
1591
outstring = '%-8s %s%s' % (fc, fp, kindch)
1592
if show_ids and fid is not None:
1593
outstring = "%-50s %s" % (outstring, fid)
1594
self.outf.write(outstring + '\n')
1595
elif null:
1596
self.outf.write(fp + '\0')
1597
if show_ids:
1598
if fid is not None:
1599
self.outf.write(fid)
1600
self.outf.write('\0')
1601
self.outf.flush()
1602
else:
1603
if fid is not None:
1604
my_id = fid
1605
else:
1606
my_id = ''
1607
if show_ids:
1608
self.outf.write('%-50s %s\n' % (fp, my_id))
1609
else:
1610
self.outf.write(fp + '\n')
1611
1612
1613
class cmd_unknowns(Command):
1614
"""List unknown files."""
1615
@display_command
1616
def run(self):
1617
for f in WorkingTree.open_containing(u'.')[0].unknowns():
1618
self.outf.write(osutils.quotefn(f) + '\n')
1619
1620
1621
class cmd_ignore(Command):
1622
"""Ignore specified files or patterns.
1623
1624
To remove patterns from the ignore list, edit the .bzrignore file.
1625
1626
Trailing slashes on patterns are ignored.
1627
If the pattern contains a slash or is a regular expression, it is compared
1628
to the whole path from the branch root. Otherwise, it is compared to only
1629
the last component of the path. To match a file only in the root
1630
directory, prepend './'.
1631
1632
Ignore patterns specifying absolute paths are not allowed.
1633
1634
Ignore patterns may include globbing wildcards such as:
1635
? - Matches any single character except '/'
1636
* - Matches 0 or more characters except '/'
1637
/**/ - Matches 0 or more directories in a path
1638
[a-z] - Matches a single character from within a group of characters
1639
1640
Ignore patterns may also be Python regular expressions.
1641
Regular expression ignore patterns are identified by a 'RE:' prefix
1642
followed by the regular expression. Regular expression ignore patterns
1643
may not include named or numbered groups.
1644
1645
Note: ignore patterns containing shell wildcards must be quoted from
1646
the shell on Unix.
1647
1648
examples:
1649
bzr ignore ./Makefile
1650
bzr ignore '*.class'
1651
bzr ignore 'lib/**/*.o'
1652
bzr ignore 'RE:lib/.*\.o'
1653
"""
1654
takes_args = ['name_pattern*']
1655
takes_options = [
1656
Option('old-default-rules',
1657
help='Out the ignore rules bzr < 0.9 always used.')
1658
]
1659
1660
def run(self, name_pattern_list=None, old_default_rules=None):
1661
from bzrlib.atomicfile import AtomicFile
1662
if old_default_rules is not None:
1663
# dump the rules and exit
1664
for pattern in ignores.OLD_DEFAULTS:
1665
print pattern
1666
return
1667
if not name_pattern_list:
1668
raise errors.BzrCommandError("ignore requires at least one "
1669
"NAME_PATTERN or --old-default-rules")
1670
for name_pattern in name_pattern_list:
1671
if name_pattern[0] == '/':
1672
raise errors.BzrCommandError(
1673
"NAME_PATTERN should not be an absolute path")
1674
tree, relpath = WorkingTree.open_containing(u'.')
1675
ifn = tree.abspath('.bzrignore')
1676
if os.path.exists(ifn):
1677
f = open(ifn, 'rt')
1678
try:
1679
igns = f.read().decode('utf-8')
1680
finally:
1681
f.close()
1682
else:
1683
igns = ''
1684
1685
# TODO: If the file already uses crlf-style termination, maybe
1686
# we should use that for the newly added lines?
1687
1688
if igns and igns[-1] != '\n':
1689
igns += '\n'
1690
for name_pattern in name_pattern_list:
1691
igns += name_pattern.rstrip('/') + '\n'
1692
1693
f = AtomicFile(ifn, 'wb')
1694
try:
1695
f.write(igns.encode('utf-8'))
1696
f.commit()
1697
finally:
1698
f.close()
1699
1700
inv = tree.inventory
1701
if inv.path2id('.bzrignore'):
1702
mutter('.bzrignore is already versioned')
1703
else:
1704
mutter('need to make new .bzrignore file versioned')
1705
tree.add(['.bzrignore'])
1706
1707
1708
class cmd_ignored(Command):
1709
"""List ignored files and the patterns that matched them.
1710
1711
See also: bzr ignore"""
1712
@display_command
1713
def run(self):
1714
tree = WorkingTree.open_containing(u'.')[0]
1715
for path, file_class, kind, file_id, entry in tree.list_files():
1716
if file_class != 'I':
1717
continue
1718
## XXX: Slightly inefficient since this was already calculated
1719
pat = tree.is_ignored(path)
1720
print '%-50s %s' % (path, pat)
1721
1722
1723
class cmd_lookup_revision(Command):
1724
"""Lookup the revision-id from a revision-number
1725
1726
example:
1727
bzr lookup-revision 33
1728
"""
1729
hidden = True
1730
takes_args = ['revno']
1731
1732
@display_command
1733
def run(self, revno):
1734
try:
1735
revno = int(revno)
1736
except ValueError:
1737
raise errors.BzrCommandError("not a valid revision-number: %r" % revno)
1738
1739
print WorkingTree.open_containing(u'.')[0].branch.get_rev_id(revno)
1740
1741
1742
class cmd_export(Command):
1743
"""Export past revision to destination directory.
1744
1745
If no revision is specified this exports the last committed revision.
1746
1747
Format may be an "exporter" name, such as tar, tgz, tbz2. If none is
1748
given, try to find the format with the extension. If no extension
1749
is found exports to a directory (equivalent to --format=dir).
1750
1751
Root may be the top directory for tar, tgz and tbz2 formats. If none
1752
is given, the top directory will be the root name of the file.
1753
1754
If branch is omitted then the branch containing the CWD will be used.
1755
1756
Note: export of tree with non-ascii filenames to zip is not supported.
1757
1758
Supported formats Autodetected by extension
1759
----------------- -------------------------
1760
dir -
1761
tar .tar
1762
tbz2 .tar.bz2, .tbz2
1763
tgz .tar.gz, .tgz
1764
zip .zip
1765
"""
1766
takes_args = ['dest', 'branch?']
1767
takes_options = ['revision', 'format', 'root']
1768
def run(self, dest, branch=None, revision=None, format=None, root=None):
1769
from bzrlib.export import export
1770
1771
if branch is None:
1772
tree = WorkingTree.open_containing(u'.')[0]
1773
b = tree.branch
1774
else:
1775
b = Branch.open(branch)
1776
1777
if revision is None:
1778
# should be tree.last_revision FIXME
1779
rev_id = b.last_revision()
1780
else:
1781
if len(revision) != 1:
1782
raise errors.BzrCommandError('bzr export --revision takes exactly 1 argument')
1783
rev_id = revision[0].in_history(b).rev_id
1784
t = b.repository.revision_tree(rev_id)
1785
try:
1786
export(t, dest, format, root)
1787
except errors.NoSuchExportFormat, e:
1788
raise errors.BzrCommandError('Unsupported export format: %s' % e.format)
1789
1790
1791
class cmd_cat(Command):
1792
"""Write a file's text from a previous revision."""
1793
1794
takes_options = ['revision', 'name-from-revision']
1795
takes_args = ['filename']
1796
encoding_type = 'exact'
1797
1798
@display_command
1799
def run(self, filename, revision=None, name_from_revision=False):
1800
if revision is not None and len(revision) != 1:
1801
raise errors.BzrCommandError("bzr cat --revision takes exactly"
1802
" one number")
1803
1804
tree = None
1805
try:
1806
tree, relpath = WorkingTree.open_containing(filename)
1807
b = tree.branch
1808
except (errors.NotBranchError, errors.NotLocalUrl):
1809
pass
1810
1811
if revision is not None and revision[0].get_branch() is not None:
1812
b = Branch.open(revision[0].get_branch())
1813
if tree is None:
1814
b, relpath = Branch.open_containing(filename)
1815
tree = b.basis_tree()
1816
if revision is None:
1817
revision_id = b.last_revision()
1818
else:
1819
revision_id = revision[0].in_history(b).rev_id
1820
1821
cur_file_id = tree.path2id(relpath)
1822
rev_tree = b.repository.revision_tree(revision_id)
1823
old_file_id = rev_tree.path2id(relpath)
1824
1825
if name_from_revision:
1826
if old_file_id is None:
1827
raise errors.BzrCommandError("%r is not present in revision %s"
1828
% (filename, revision_id))
1829
else:
1830
rev_tree.print_file(old_file_id)
1831
elif cur_file_id is not None:
1832
rev_tree.print_file(cur_file_id)
1833
elif old_file_id is not None:
1834
rev_tree.print_file(old_file_id)
1835
else:
1836
raise errors.BzrCommandError("%r is not present in revision %s" %
1837
(filename, revision_id))
1838
1839
1840
class cmd_local_time_offset(Command):
1841
"""Show the offset in seconds from GMT to local time."""
1842
hidden = True
1843
@display_command
1844
def run(self):
1845
print osutils.local_time_offset()
1846
1847
1848
1849
class cmd_commit(Command):
1850
"""Commit changes into a new revision.
1851
1852
If no arguments are given, the entire tree is committed.
1853
1854
If selected files are specified, only changes to those files are
1855
committed. If a directory is specified then the directory and everything
1856
within it is committed.
1857
1858
A selected-file commit may fail in some cases where the committed
1859
tree would be invalid, such as trying to commit a file in a
1860
newly-added directory that is not itself committed.
1861
"""
1862
# TODO: Run hooks on tree to-be-committed, and after commit.
1863
1864
# TODO: Strict commit that fails if there are deleted files.
1865
# (what does "deleted files" mean ??)
1866
1867
# TODO: Give better message for -s, --summary, used by tla people
1868
1869
# XXX: verbose currently does nothing
1870
1871
takes_args = ['selected*']
1872
takes_options = ['message', 'verbose',
1873
Option('unchanged',
1874
help='commit even if nothing has changed'),
1875
Option('file', type=str,
1876
short_name='F',
1877
argname='msgfile',
1878
help='file containing commit message'),
1879
Option('strict',
1880
help="refuse to commit if there are unknown "
1881
"files in the working tree."),
1882
Option('local',
1883
help="perform a local only commit in a bound "
1884
"branch. Such commits are not pushed to "
1885
"the master branch until a normal commit "
1886
"is performed."
1887
),
1888
]
1889
aliases = ['ci', 'checkin']
1890
1891
def run(self, message=None, file=None, verbose=True, selected_list=None,
1892
unchanged=False, strict=False, local=False):
1893
from bzrlib.commit import (NullCommitReporter, ReportCommitToLog)
1894
from bzrlib.errors import (PointlessCommit, ConflictsInTree,
1895
StrictCommitFailed)
1896
from bzrlib.msgeditor import edit_commit_message, \
1897
make_commit_message_template
1898
1899
# TODO: Need a blackbox test for invoking the external editor; may be
1900
# slightly problematic to run this cross-platform.
1901
1902
# TODO: do more checks that the commit will succeed before
1903
# spending the user's valuable time typing a commit message.
1904
tree, selected_list = tree_files(selected_list)
1905
if selected_list == ['']:
1906
# workaround - commit of root of tree should be exactly the same
1907
# as just default commit in that tree, and succeed even though
1908
# selected-file merge commit is not done yet
1909
selected_list = []
1910
1911
if local and not tree.branch.get_bound_location():
1912
raise errors.LocalRequiresBoundBranch()
1913
1914
def get_message(commit_obj):
1915
"""Callback to get commit message"""
1916
my_message = message
1917
if my_message is None and not file:
1918
template = make_commit_message_template(tree, selected_list)
1919
my_message = edit_commit_message(template)
1920
if my_message is None:
1921
raise errors.BzrCommandError("please specify a commit"
1922
" message with either --message or --file")
1923
elif my_message and file:
1924
raise errors.BzrCommandError(
1925
"please specify either --message or --file")
1926
if file:
1927
my_message = codecs.open(file, 'rt',
1928
bzrlib.user_encoding).read()
1929
if my_message == "":
1930
raise errors.BzrCommandError("empty commit message specified")
1931
return my_message
1932
1933
if verbose:
1934
reporter = ReportCommitToLog()
1935
else:
1936
reporter = NullCommitReporter()
1937
1938
try:
1939
tree.commit(message_callback=get_message,
1940
specific_files=selected_list,
1941
allow_pointless=unchanged, strict=strict, local=local,
1942
reporter=reporter)
1943
except PointlessCommit:
1944
# FIXME: This should really happen before the file is read in;
1945
# perhaps prepare the commit; get the message; then actually commit
1946
raise errors.BzrCommandError("no changes to commit."
1947
" use --unchanged to commit anyhow")
1948
except ConflictsInTree:
1949
raise errors.BzrCommandError('Conflicts detected in working '
1950
'tree. Use "bzr conflicts" to list, "bzr resolve FILE" to'
1951
' resolve.')
1952
except StrictCommitFailed:
1953
raise errors.BzrCommandError("Commit refused because there are"
1954
" unknown files in the working tree.")
1955
except errors.BoundBranchOutOfDate, e:
1956
raise errors.BzrCommandError(str(e) + "\n"
1957
'To commit to master branch, run update and then commit.\n'
1958
'You can also pass --local to commit to continue working '
1959
'disconnected.')
1960
1961
1962
class cmd_check(Command):
1963
"""Validate consistency of branch history.
1964
1965
This command checks various invariants about the branch storage to
1966
detect data corruption or bzr bugs.
1967
"""
1968
takes_args = ['branch?']
1969
takes_options = ['verbose']
1970
1971
def run(self, branch=None, verbose=False):
1972
from bzrlib.check import check
1973
if branch is None:
1974
tree = WorkingTree.open_containing()[0]
1975
branch = tree.branch
1976
else:
1977
branch = Branch.open(branch)
1978
check(branch, verbose)
1979
1980
1981
class cmd_upgrade(Command):
1982
"""Upgrade branch storage to current format.
1983
1984
The check command or bzr developers may sometimes advise you to run
1985
this command. When the default format has changed you may also be warned
1986
during other operations to upgrade.
1987
"""
1988
takes_args = ['url?']
1989
takes_options = [
1990
RegistryOption('format',
1991
help='Upgrade to a specific format. Current formats'
1992
' are: default, knit, metaweave and weave.'
1993
' Default is knit; metaweave and weave are'
1994
' deprecated',
1995
registry=bzrdir.format_registry,
1996
converter=get_format_type,
1997
value_switches=True),
1998
]
1999
2000
2001
def run(self, url='.', format=None):
2002
from bzrlib.upgrade import upgrade
2003
if format is None:
2004
format = get_format_type('default')
2005
upgrade(url, format)
2006
2007
2008
class cmd_whoami(Command):
2009
"""Show or set bzr user id.
2010
2011
examples:
2012
bzr whoami --email
2013
bzr whoami 'Frank Chu <fchu@example.com>'
2014
"""
2015
takes_options = [ Option('email',
2016
help='display email address only'),
2017
Option('branch',
2018
help='set identity for the current branch instead of '
2019
'globally'),
2020
]
2021
takes_args = ['name?']
2022
encoding_type = 'replace'
2023
2024
@display_command
2025
def run(self, email=False, branch=False, name=None):
2026
if name is None:
2027
# use branch if we're inside one; otherwise global config
2028
try:
2029
c = Branch.open_containing('.')[0].get_config()
2030
except errors.NotBranchError:
2031
c = config.GlobalConfig()
2032
if email:
2033
self.outf.write(c.user_email() + '\n')
2034
else:
2035
self.outf.write(c.username() + '\n')
2036
return
2037
2038
# display a warning if an email address isn't included in the given name.
2039
try:
2040
config.extract_email_address(name)
2041
except errors.NoEmailInUsername, e:
2042
warning('"%s" does not seem to contain an email address. '
2043
'This is allowed, but not recommended.', name)
2044
2045
# use global config unless --branch given
2046
if branch:
2047
c = Branch.open_containing('.')[0].get_config()
2048
else:
2049
c = config.GlobalConfig()
2050
c.set_user_option('email', name)
2051
2052
2053
class cmd_nick(Command):
2054
"""Print or set the branch nickname.
2055
2056
If unset, the tree root directory name is used as the nickname
2057
To print the current nickname, execute with no argument.
2058
"""
2059
takes_args = ['nickname?']
2060
def run(self, nickname=None):
2061
branch = Branch.open_containing(u'.')[0]
2062
if nickname is None:
2063
self.printme(branch)
2064
else:
2065
branch.nick = nickname
2066
2067
@display_command
2068
def printme(self, branch):
2069
print branch.nick
2070
2071
2072
class cmd_selftest(Command):
2073
"""Run internal test suite.
2074
2075
This creates temporary test directories in the working directory, but not
2076
existing data is affected. These directories are deleted if the tests
2077
pass, or left behind to help in debugging if they fail and --keep-output
2078
is specified.
2079
2080
If arguments are given, they are regular expressions that say which tests
2081
should run. Tests matching any expression are run, and other tests are
2082
not run.
2083
2084
Alternatively if --first is given, matching tests are run first and then
2085
all other tests are run. This is useful if you have been working in a
2086
particular area, but want to make sure nothing else was broken.
2087
2088
If the global option '--no-plugins' is given, plugins are not loaded
2089
before running the selftests. This has two effects: features provided or
2090
modified by plugins will not be tested, and tests provided by plugins will
2091
not be run.
2092
2093
examples::
2094
bzr selftest ignore
2095
run only tests relating to 'ignore'
2096
bzr --no-plugins selftest -v
2097
disable plugins and list tests as they're run
2098
"""
2099
# TODO: --list should give a list of all available tests
2100
2101
# NB: this is used from the class without creating an instance, which is
2102
# why it does not have a self parameter.
2103
def get_transport_type(typestring):
2104
"""Parse and return a transport specifier."""
2105
if typestring == "sftp":
2106
from bzrlib.transport.sftp import SFTPAbsoluteServer
2107
return SFTPAbsoluteServer
2108
if typestring == "memory":
2109
from bzrlib.transport.memory import MemoryServer
2110
return MemoryServer
2111
if typestring == "fakenfs":
2112
from bzrlib.transport.fakenfs import FakeNFSServer
2113
return FakeNFSServer
2114
msg = "No known transport type %s. Supported types are: sftp\n" %\
2115
(typestring)
2116
raise errors.BzrCommandError(msg)
2117
2118
hidden = True
2119
takes_args = ['testspecs*']
2120
takes_options = ['verbose',
2121
Option('one', help='stop when one test fails'),
2122
Option('keep-output',
2123
help='keep output directories when tests fail'),
2124
Option('transport',
2125
help='Use a different transport by default '
2126
'throughout the test suite.',
2127
type=get_transport_type),
2128
Option('benchmark', help='run the bzr bencharks.'),
2129
Option('lsprof-timed',
2130
help='generate lsprof output for benchmarked'
2131
' sections of code.'),
2132
Option('cache-dir', type=str,
2133
help='a directory to cache intermediate'
2134
' benchmark steps'),
2135
Option('clean-output',
2136
help='clean temporary tests directories'
2137
' without running tests'),
2138
Option('first',
2139
help='run all tests, but run specified tests first',
2140
)
2141
]
2142
encoding_type = 'replace'
2143
2144
def run(self, testspecs_list=None, verbose=None, one=False,
2145
keep_output=False, transport=None, benchmark=None,
2146
lsprof_timed=None, cache_dir=None, clean_output=False,
2147
first=False):
2148
import bzrlib.ui
2149
from bzrlib.tests import selftest
2150
import bzrlib.benchmarks as benchmarks
2151
from bzrlib.benchmarks import tree_creator
2152
2153
if clean_output:
2154
from bzrlib.tests import clean_selftest_output
2155
clean_selftest_output()
2156
return 0
2157
2158
if cache_dir is not None:
2159
tree_creator.TreeCreator.CACHE_ROOT = osutils.abspath(cache_dir)
2160
print '%10s: %s' % ('bzr', osutils.realpath(sys.argv[0]))
2161
print '%10s: %s' % ('bzrlib', bzrlib.__path__[0])
2162
print
2163
if testspecs_list is not None:
2164
pattern = '|'.join(testspecs_list)
2165
else:
2166
pattern = ".*"
2167
if benchmark:
2168
test_suite_factory = benchmarks.test_suite
2169
if verbose is None:
2170
verbose = True
2171
# TODO: should possibly lock the history file...
2172
benchfile = open(".perf_history", "at", buffering=1)
2173
else:
2174
test_suite_factory = None
2175
if verbose is None:
2176
verbose = False
2177
benchfile = None
2178
try:
2179
result = selftest(verbose=verbose,
2180
pattern=pattern,
2181
stop_on_failure=one,
2182
keep_output=keep_output,
2183
transport=transport,
2184
test_suite_factory=test_suite_factory,
2185
lsprof_timed=lsprof_timed,
2186
bench_history=benchfile,
2187
matching_tests_first=first,
2188
)
2189
finally:
2190
if benchfile is not None:
2191
benchfile.close()
2192
if result:
2193
info('tests passed')
2194
else:
2195
info('tests failed')
2196
return int(not result)
2197
2198
2199
class cmd_version(Command):
2200
"""Show version of bzr."""
2201
2202
@display_command
2203
def run(self):
2204
from bzrlib.version import show_version
2205
show_version()
2206
2207
2208
class cmd_rocks(Command):
2209
"""Statement of optimism."""
2210
2211
hidden = True
2212
2213
@display_command
2214
def run(self):
2215
print "it sure does!"
2216
2217
2218
class cmd_find_merge_base(Command):
2219
"""Find and print a base revision for merging two branches."""
2220
# TODO: Options to specify revisions on either side, as if
2221
# merging only part of the history.
2222
takes_args = ['branch', 'other']
2223
hidden = True
2224
2225
@display_command
2226
def run(self, branch, other):
2227
from bzrlib.revision import MultipleRevisionSources
2228
2229
branch1 = Branch.open_containing(branch)[0]
2230
branch2 = Branch.open_containing(other)[0]
2231
2232
history_1 = branch1.revision_history()
2233
history_2 = branch2.revision_history()
2234
2235
last1 = branch1.last_revision()
2236
last2 = branch2.last_revision()
2237
2238
source = MultipleRevisionSources(branch1.repository,
2239
branch2.repository)
2240
2241
base_rev_id = common_ancestor(last1, last2, source)
2242
2243
print 'merge base is revision %s' % base_rev_id
2244
2245
2246
class cmd_merge(Command):
2247
"""Perform a three-way merge.
2248
2249
The branch is the branch you will merge from. By default, it will merge
2250
the latest revision. If you specify a revision, that revision will be
2251
merged. If you specify two revisions, the first will be used as a BASE,
2252
and the second one as OTHER. Revision numbers are always relative to the
2253
specified branch.
2254
2255
By default, bzr will try to merge in all new work from the other
2256
branch, automatically determining an appropriate base. If this
2257
fails, you may need to give an explicit base.
2258
2259
Merge will do its best to combine the changes in two branches, but there
2260
are some kinds of problems only a human can fix. When it encounters those,
2261
it will mark a conflict. A conflict means that you need to fix something,
2262
before you should commit.
2263
2264
Use bzr resolve when you have fixed a problem. See also bzr conflicts.
2265
2266
If there is no default branch set, the first merge will set it. After
2267
that, you can omit the branch to use the default. To change the
2268
default, use --remember. The value will only be saved if the remote
2269
location can be accessed.
2270
2271
Examples:
2272
2273
To merge the latest revision from bzr.dev
2274
bzr merge ../bzr.dev
2275
2276
To merge changes up to and including revision 82 from bzr.dev
2277
bzr merge -r 82 ../bzr.dev
2278
2279
To merge the changes introduced by 82, without previous changes:
2280
bzr merge -r 81..82 ../bzr.dev
2281
2282
merge refuses to run if there are any uncommitted changes, unless
2283
--force is given.
2284
2285
The following merge types are available:
2286
"""
2287
takes_args = ['branch?']
2288
takes_options = ['revision', 'force', 'merge-type', 'reprocess', 'remember',
2289
Option('show-base', help="Show base revision text in "
2290
"conflicts"),
2291
Option('uncommitted', help='Apply uncommitted changes'
2292
' from a working copy, instead of branch changes'),
2293
Option('pull', help='If the destination is already'
2294
' completely merged into the source, pull from the'
2295
' source rather than merging. When this happens,'
2296
' you do not need to commit the result.'),
2297
]
2298
2299
def help(self):
2300
from inspect import getdoc
2301
return getdoc(self) + '\n' + _mod_merge.merge_type_help()
2302
2303
def run(self, branch=None, revision=None, force=False, merge_type=None,
2304
show_base=False, reprocess=False, remember=False,
2305
uncommitted=False, pull=False):
2306
if merge_type is None:
2307
merge_type = _mod_merge.Merge3Merger
2308
2309
tree = WorkingTree.open_containing(u'.')[0]
2310
2311
if branch is not None:
2312
try:
2313
reader = bundle.read_bundle_from_url(branch)
2314
except errors.NotABundle:
2315
pass # Continue on considering this url a Branch
2316
else:
2317
conflicts = merge_bundle(reader, tree, not force, merge_type,
2318
reprocess, show_base)
2319
if conflicts == 0:
2320
return 0
2321
else:
2322
return 1
2323
2324
if revision is None \
2325
or len(revision) < 1 or revision[0].needs_branch():
2326
branch = self._get_remembered_parent(tree, branch, 'Merging from')
2327
2328
if revision is None or len(revision) < 1:
2329
if uncommitted:
2330
base = [branch, -1]
2331
other = [branch, None]
2332
else:
2333
base = [None, None]
2334
other = [branch, -1]
2335
other_branch, path = Branch.open_containing(branch)
2336
else:
2337
if uncommitted:
2338
raise errors.BzrCommandError('Cannot use --uncommitted and'
2339
' --revision at the same time.')
2340
branch = revision[0].get_branch() or branch
2341
if len(revision) == 1:
2342
base = [None, None]
2343
other_branch, path = Branch.open_containing(branch)
2344
revno = revision[0].in_history(other_branch).revno
2345
other = [branch, revno]
2346
else:
2347
assert len(revision) == 2
2348
if None in revision:
2349
raise errors.BzrCommandError(
2350
"Merge doesn't permit empty revision specifier.")
2351
base_branch, path = Branch.open_containing(branch)
2352
branch1 = revision[1].get_branch() or branch
2353
other_branch, path1 = Branch.open_containing(branch1)
2354
if revision[0].get_branch() is not None:
2355
# then path was obtained from it, and is None.
2356
path = path1
2357
2358
base = [branch, revision[0].in_history(base_branch).revno]
2359
other = [branch1, revision[1].in_history(other_branch).revno]
2360
2361
if tree.branch.get_parent() is None or remember:
2362
tree.branch.set_parent(other_branch.base)
2363
2364
if path != "":
2365
interesting_files = [path]
2366
else:
2367
interesting_files = None
2368
pb = ui.ui_factory.nested_progress_bar()
2369
try:
2370
try:
2371
conflict_count = _merge_helper(
2372
other, base, check_clean=(not force),
2373
merge_type=merge_type,
2374
reprocess=reprocess,
2375
show_base=show_base,
2376
pull=pull,
2377
pb=pb, file_list=interesting_files)
2378
finally:
2379
pb.finished()
2380
if conflict_count != 0:
2381
return 1
2382
else:
2383
return 0
2384
except errors.AmbiguousBase, e:
2385
m = ("sorry, bzr can't determine the right merge base yet\n"
2386
"candidates are:\n "
2387
+ "\n ".join(e.bases)
2388
+ "\n"
2389
"please specify an explicit base with -r,\n"
2390
"and (if you want) report this to the bzr developers\n")
2391
log_error(m)
2392
2393
# TODO: move up to common parent; this isn't merge-specific anymore.
2394
def _get_remembered_parent(self, tree, supplied_location, verb_string):
2395
"""Use tree.branch's parent if none was supplied.
2396
2397
Report if the remembered location was used.
2398
"""
2399
if supplied_location is not None:
2400
return supplied_location
2401
stored_location = tree.branch.get_parent()
2402
mutter("%s", stored_location)
2403
if stored_location is None:
2404
raise errors.BzrCommandError("No location specified or remembered")
2405
display_url = urlutils.unescape_for_display(stored_location, self.outf.encoding)
2406
self.outf.write("%s remembered location %s\n" % (verb_string, display_url))
2407
return stored_location
2408
2409
2410
class cmd_remerge(Command):
2411
"""Redo a merge.
2412
2413
Use this if you want to try a different merge technique while resolving
2414
conflicts. Some merge techniques are better than others, and remerge
2415
lets you try different ones on different files.
2416
2417
The options for remerge have the same meaning and defaults as the ones for
2418
merge. The difference is that remerge can (only) be run when there is a
2419
pending merge, and it lets you specify particular files.
2420
2421
Examples:
2422
$ bzr remerge --show-base
2423
Re-do the merge of all conflicted files, and show the base text in
2424
conflict regions, in addition to the usual THIS and OTHER texts.
2425
2426
$ bzr remerge --merge-type weave --reprocess foobar
2427
Re-do the merge of "foobar", using the weave merge algorithm, with
2428
additional processing to reduce the size of conflict regions.
2429
2430
The following merge types are available:"""
2431
takes_args = ['file*']
2432
takes_options = ['merge-type', 'reprocess',
2433
Option('show-base', help="Show base revision text in "
2434
"conflicts")]
2435
2436
def help(self):
2437
from inspect import getdoc
2438
return getdoc(self) + '\n' + _mod_merge.merge_type_help()
2439
2440
def run(self, file_list=None, merge_type=None, show_base=False,
2441
reprocess=False):
2442
if merge_type is None:
2443
merge_type = _mod_merge.Merge3Merger
2444
tree, file_list = tree_files(file_list)
2445
tree.lock_write()
2446
try:
2447
parents = tree.get_parent_ids()
2448
if len(parents) != 2:
2449
raise errors.BzrCommandError("Sorry, remerge only works after normal"
2450
" merges. Not cherrypicking or"
2451
" multi-merges.")
2452
repository = tree.branch.repository
2453
base_revision = common_ancestor(parents[0],
2454
parents[1], repository)
2455
base_tree = repository.revision_tree(base_revision)
2456
other_tree = repository.revision_tree(parents[1])
2457
interesting_ids = None
2458
new_conflicts = []
2459
conflicts = tree.conflicts()
2460
if file_list is not None:
2461
interesting_ids = set()
2462
for filename in file_list:
2463
file_id = tree.path2id(filename)
2464
if file_id is None:
2465
raise errors.NotVersionedError(filename)
2466
interesting_ids.add(file_id)
2467
if tree.kind(file_id) != "directory":
2468
continue
2469
2470
for name, ie in tree.inventory.iter_entries(file_id):
2471
interesting_ids.add(ie.file_id)
2472
new_conflicts = conflicts.select_conflicts(tree, file_list)[0]
2473
else:
2474
# Remerge only supports resolving contents conflicts
2475
allowed_conflicts = ('text conflict', 'contents conflict')
2476
restore_files = [c.path for c in conflicts
2477
if c.typestring in allowed_conflicts]
2478
_mod_merge.transform_tree(tree, tree.basis_tree(), interesting_ids)
2479
tree.set_conflicts(ConflictList(new_conflicts))
2480
if file_list is not None:
2481
restore_files = file_list
2482
for filename in restore_files:
2483
try:
2484
restore(tree.abspath(filename))
2485
except errors.NotConflicted:
2486
pass
2487
conflicts = _mod_merge.merge_inner(
2488
tree.branch, other_tree, base_tree,
2489
this_tree=tree,
2490
interesting_ids=interesting_ids,
2491
other_rev_id=parents[1],
2492
merge_type=merge_type,
2493
show_base=show_base,
2494
reprocess=reprocess)
2495
finally:
2496
tree.unlock()
2497
if conflicts > 0:
2498
return 1
2499
else:
2500
return 0
2501
2502
2503
class cmd_revert(Command):
2504
"""Revert files to a previous revision.
2505
2506
Giving a list of files will revert only those files. Otherwise, all files
2507
will be reverted. If the revision is not specified with '--revision', the
2508
last committed revision is used.
2509
2510
To remove only some changes, without reverting to a prior version, use
2511
merge instead. For example, "merge . --r-2..-3" will remove the changes
2512
introduced by -2, without affecting the changes introduced by -1. Or
2513
to remove certain changes on a hunk-by-hunk basis, see the Shelf plugin.
2514
2515
By default, any files that have been manually changed will be backed up
2516
first. (Files changed only by merge are not backed up.) Backup files have
2517
'.~#~' appended to their name, where # is a number.
2518
2519
When you provide files, you can use their current pathname or the pathname
2520
from the target revision. So you can use revert to "undelete" a file by
2521
name. If you name a directory, all the contents of that directory will be
2522
reverted.
2523
"""
2524
takes_options = ['revision', 'no-backup']
2525
takes_args = ['file*']
2526
aliases = ['merge-revert']
2527
2528
def run(self, revision=None, no_backup=False, file_list=None):
2529
if file_list is not None:
2530
if len(file_list) == 0:
2531
raise errors.BzrCommandError("No files specified")
2532
else:
2533
file_list = []
2534
2535
tree, file_list = tree_files(file_list)
2536
if revision is None:
2537
# FIXME should be tree.last_revision
2538
rev_id = tree.last_revision()
2539
elif len(revision) != 1:
2540
raise errors.BzrCommandError('bzr revert --revision takes exactly 1 argument')
2541
else:
2542
rev_id = revision[0].in_history(tree.branch).rev_id
2543
pb = ui.ui_factory.nested_progress_bar()
2544
try:
2545
tree.revert(file_list,
2546
tree.branch.repository.revision_tree(rev_id),
2547
not no_backup, pb, report_changes=True)
2548
finally:
2549
pb.finished()
2550
2551
2552
class cmd_assert_fail(Command):
2553
"""Test reporting of assertion failures"""
2554
# intended just for use in testing
2555
2556
hidden = True
2557
2558
def run(self):
2559
raise AssertionError("always fails")
2560
2561
2562
class cmd_help(Command):
2563
"""Show help on a command or other topic.
2564
2565
For a list of all available commands, say 'bzr help commands'.
2566
"""
2567
takes_options = [Option('long', 'show help on all commands')]
2568
takes_args = ['topic?']
2569
aliases = ['?', '--help', '-?', '-h']
2570
2571
@display_command
2572
def run(self, topic=None, long=False):
2573
import bzrlib.help
2574
if topic is None and long:
2575
topic = "commands"
2576
bzrlib.help.help(topic)
2577
2578
2579
class cmd_shell_complete(Command):
2580
"""Show appropriate completions for context.
2581
2582
For a list of all available commands, say 'bzr shell-complete'.
2583
"""
2584
takes_args = ['context?']
2585
aliases = ['s-c']
2586
hidden = True
2587
2588
@display_command
2589
def run(self, context=None):
2590
import shellcomplete
2591
shellcomplete.shellcomplete(context)
2592
2593
2594
class cmd_fetch(Command):
2595
"""Copy in history from another branch but don't merge it.
2596
2597
This is an internal method used for pull and merge.
2598
"""
2599
hidden = True
2600
takes_args = ['from_branch', 'to_branch']
2601
def run(self, from_branch, to_branch):
2602
from bzrlib.fetch import Fetcher
2603
from_b = Branch.open(from_branch)
2604
to_b = Branch.open(to_branch)
2605
Fetcher(to_b, from_b)
2606
2607
2608
class cmd_missing(Command):
2609
"""Show unmerged/unpulled revisions between two branches.
2610
2611
OTHER_BRANCH may be local or remote.
2612
"""
2613
takes_args = ['other_branch?']
2614
takes_options = [Option('reverse', 'Reverse the order of revisions'),
2615
Option('mine-only',
2616
'Display changes in the local branch only'),
2617
Option('theirs-only',
2618
'Display changes in the remote branch only'),
2619
'log-format',
2620
'line',
2621
'long',
2622
'short',
2623
'show-ids',
2624
'verbose'
2625
]
2626
encoding_type = 'replace'
2627
2628
@display_command
2629
def run(self, other_branch=None, reverse=False, mine_only=False,
2630
theirs_only=False, log_format=None, long=False, short=False, line=False,
2631
show_ids=False, verbose=False):
2632
from bzrlib.missing import find_unmerged, iter_log_data
2633
from bzrlib.log import log_formatter
2634
local_branch = Branch.open_containing(u".")[0]
2635
parent = local_branch.get_parent()
2636
if other_branch is None:
2637
other_branch = parent
2638
if other_branch is None:
2639
raise errors.BzrCommandError("No peer location known or specified.")
2640
display_url = urlutils.unescape_for_display(parent,
2641
self.outf.encoding)
2642
print "Using last location: " + display_url
2643
2644
remote_branch = Branch.open(other_branch)
2645
if remote_branch.base == local_branch.base:
2646
remote_branch = local_branch
2647
local_branch.lock_read()
2648
try:
2649
remote_branch.lock_read()
2650
try:
2651
local_extra, remote_extra = find_unmerged(local_branch, remote_branch)
2652
if (log_format is None):
2653
default = local_branch.get_config().log_format()
2654
log_format = get_log_format(long=long, short=short,
2655
line=line, default=default)
2656
lf = log_formatter(log_format,
2657
to_file=self.outf,
2658
show_ids=show_ids,
2659
show_timezone='original')
2660
if reverse is False:
2661
local_extra.reverse()
2662
remote_extra.reverse()
2663
if local_extra and not theirs_only:
2664
print "You have %d extra revision(s):" % len(local_extra)
2665
for data in iter_log_data(local_extra, local_branch.repository,
2666
verbose):
2667
lf.show(*data)
2668
printed_local = True
2669
else:
2670
printed_local = False
2671
if remote_extra and not mine_only:
2672
if printed_local is True:
2673
print "\n\n"
2674
print "You are missing %d revision(s):" % len(remote_extra)
2675
for data in iter_log_data(remote_extra, remote_branch.repository,
2676
verbose):
2677
lf.show(*data)
2678
if not remote_extra and not local_extra:
2679
status_code = 0
2680
print "Branches are up to date."
2681
else:
2682
status_code = 1
2683
finally:
2684
remote_branch.unlock()
2685
finally:
2686
local_branch.unlock()
2687
if not status_code and parent is None and other_branch is not None:
2688
local_branch.lock_write()
2689
try:
2690
# handle race conditions - a parent might be set while we run.
2691
if local_branch.get_parent() is None:
2692
local_branch.set_parent(remote_branch.base)
2693
finally:
2694
local_branch.unlock()
2695
return status_code
2696
2697
2698
class cmd_plugins(Command):
2699
"""List plugins"""
2700
hidden = True
2701
@display_command
2702
def run(self):
2703
import bzrlib.plugin
2704
from inspect import getdoc
2705
for name, plugin in bzrlib.plugin.all_plugins().items():
2706
if getattr(plugin, '__path__', None) is not None:
2707
print plugin.__path__[0]
2708
elif getattr(plugin, '__file__', None) is not None:
2709
print plugin.__file__
2710
else:
2711
print repr(plugin)
2712
2713
d = getdoc(plugin)
2714
if d:
2715
print '\t', d.split('\n')[0]
2716
2717
2718
class cmd_testament(Command):
2719
"""Show testament (signing-form) of a revision."""
2720
takes_options = ['revision',
2721
Option('long', help='Produce long-format testament'),
2722
Option('strict', help='Produce a strict-format'
2723
' testament')]
2724
takes_args = ['branch?']
2725
@display_command
2726
def run(self, branch=u'.', revision=None, long=False, strict=False):
2727
from bzrlib.testament import Testament, StrictTestament
2728
if strict is True:
2729
testament_class = StrictTestament
2730
else:
2731
testament_class = Testament
2732
b = WorkingTree.open_containing(branch)[0].branch
2733
b.lock_read()
2734
try:
2735
if revision is None:
2736
rev_id = b.last_revision()
2737
else:
2738
rev_id = revision[0].in_history(b).rev_id
2739
t = testament_class.from_revision(b.repository, rev_id)
2740
if long:
2741
sys.stdout.writelines(t.as_text_lines())
2742
else:
2743
sys.stdout.write(t.as_short_text())
2744
finally:
2745
b.unlock()
2746
2747
2748
class cmd_annotate(Command):
2749
"""Show the origin of each line in a file.
2750
2751
This prints out the given file with an annotation on the left side
2752
indicating which revision, author and date introduced the change.
2753
2754
If the origin is the same for a run of consecutive lines, it is
2755
shown only at the top, unless the --all option is given.
2756
"""
2757
# TODO: annotate directories; showing when each file was last changed
2758
# TODO: if the working copy is modified, show annotations on that
2759
# with new uncommitted lines marked
2760
aliases = ['ann', 'blame', 'praise']
2761
takes_args = ['filename']
2762
takes_options = [Option('all', help='show annotations on all lines'),
2763
Option('long', help='show date in annotations'),
2764
'revision',
2765
'show-ids',
2766
]
2767
2768
@display_command
2769
def run(self, filename, all=False, long=False, revision=None,
2770
show_ids=False):
2771
from bzrlib.annotate import annotate_file
2772
tree, relpath = WorkingTree.open_containing(filename)
2773
branch = tree.branch
2774
branch.lock_read()
2775
try:
2776
if revision is None:
2777
revision_id = branch.last_revision()
2778
elif len(revision) != 1:
2779
raise errors.BzrCommandError('bzr annotate --revision takes exactly 1 argument')
2780
else:
2781
revision_id = revision[0].in_history(branch).rev_id
2782
file_id = tree.inventory.path2id(relpath)
2783
tree = branch.repository.revision_tree(revision_id)
2784
file_version = tree.inventory[file_id].revision
2785
annotate_file(branch, file_version, file_id, long, all, sys.stdout,
2786
show_ids=show_ids)
2787
finally:
2788
branch.unlock()
2789
2790
2791
class cmd_re_sign(Command):
2792
"""Create a digital signature for an existing revision."""
2793
# TODO be able to replace existing ones.
2794
2795
hidden = True # is this right ?
2796
takes_args = ['revision_id*']
2797
takes_options = ['revision']
2798
2799
def run(self, revision_id_list=None, revision=None):
2800
import bzrlib.gpg as gpg
2801
if revision_id_list is not None and revision is not None:
2802
raise errors.BzrCommandError('You can only supply one of revision_id or --revision')
2803
if revision_id_list is None and revision is None:
2804
raise errors.BzrCommandError('You must supply either --revision or a revision_id')
2805
b = WorkingTree.open_containing(u'.')[0].branch
2806
gpg_strategy = gpg.GPGStrategy(b.get_config())
2807
if revision_id_list is not None:
2808
for revision_id in revision_id_list:
2809
b.repository.sign_revision(revision_id, gpg_strategy)
2810
elif revision is not None:
2811
if len(revision) == 1:
2812
revno, rev_id = revision[0].in_history(b)
2813
b.repository.sign_revision(rev_id, gpg_strategy)
2814
elif len(revision) == 2:
2815
# are they both on rh- if so we can walk between them
2816
# might be nice to have a range helper for arbitrary
2817
# revision paths. hmm.
2818
from_revno, from_revid = revision[0].in_history(b)
2819
to_revno, to_revid = revision[1].in_history(b)
2820
if to_revid is None:
2821
to_revno = b.revno()
2822
if from_revno is None or to_revno is None:
2823
raise errors.BzrCommandError('Cannot sign a range of non-revision-history revisions')
2824
for revno in range(from_revno, to_revno + 1):
2825
b.repository.sign_revision(b.get_rev_id(revno),
2826
gpg_strategy)
2827
else:
2828
raise errors.BzrCommandError('Please supply either one revision, or a range.')
2829
2830
2831
class cmd_bind(Command):
2832
"""Bind the current branch to a master branch.
2833
2834
After binding, commits must succeed on the master branch
2835
before they are executed on the local one.
2836
"""
2837
2838
takes_args = ['location']
2839
takes_options = []
2840
2841
def run(self, location=None):
2842
b, relpath = Branch.open_containing(u'.')
2843
b_other = Branch.open(location)
2844
try:
2845
b.bind(b_other)
2846
except errors.DivergedBranches:
2847
raise errors.BzrCommandError('These branches have diverged.'
2848
' Try merging, and then bind again.')
2849
2850
2851
class cmd_unbind(Command):
2852
"""Unbind the current branch from its master branch.
2853
2854
After unbinding, the local branch is considered independent.
2855
All subsequent commits will be local.
2856
"""
2857
2858
takes_args = []
2859
takes_options = []
2860
2861
def run(self):
2862
b, relpath = Branch.open_containing(u'.')
2863
if not b.unbind():
2864
raise errors.BzrCommandError('Local branch is not bound')
2865
2866
2867
class cmd_uncommit(Command):
2868
"""Remove the last committed revision.
2869
2870
--verbose will print out what is being removed.
2871
--dry-run will go through all the motions, but not actually
2872
remove anything.
2873
2874
In the future, uncommit will create a revision bundle, which can then
2875
be re-applied.
2876
"""
2877
2878
# TODO: jam 20060108 Add an option to allow uncommit to remove
2879
# unreferenced information in 'branch-as-repository' branches.
2880
# TODO: jam 20060108 Add the ability for uncommit to remove unreferenced
2881
# information in shared branches as well.
2882
takes_options = ['verbose', 'revision',
2883
Option('dry-run', help='Don\'t actually make changes'),
2884
Option('force', help='Say yes to all questions.')]
2885
takes_args = ['location?']
2886
aliases = []
2887
2888
def run(self, location=None,
2889
dry_run=False, verbose=False,
2890
revision=None, force=False):
2891
from bzrlib.log import log_formatter, show_log
2892
import sys
2893
from bzrlib.uncommit import uncommit
2894
2895
if location is None:
2896
location = u'.'
2897
control, relpath = bzrdir.BzrDir.open_containing(location)
2898
try:
2899
tree = control.open_workingtree()
2900
b = tree.branch
2901
except (errors.NoWorkingTree, errors.NotLocalUrl):
2902
tree = None
2903
b = control.open_branch()
2904
2905
rev_id = None
2906
if revision is None:
2907
revno = b.revno()
2908
else:
2909
# 'bzr uncommit -r 10' actually means uncommit
2910
# so that the final tree is at revno 10.
2911
# but bzrlib.uncommit.uncommit() actually uncommits
2912
# the revisions that are supplied.
2913
# So we need to offset it by one
2914
revno = revision[0].in_history(b).revno+1
2915
2916
if revno <= b.revno():
2917
rev_id = b.get_rev_id(revno)
2918
if rev_id is None:
2919
self.outf.write('No revisions to uncommit.\n')
2920
return 1
2921
2922
lf = log_formatter('short',
2923
to_file=self.outf,
2924
show_timezone='original')
2925
2926
show_log(b,
2927
lf,
2928
verbose=False,
2929
direction='forward',
2930
start_revision=revno,
2931
end_revision=b.revno())
2932
2933
if dry_run:
2934
print 'Dry-run, pretending to remove the above revisions.'
2935
if not force:
2936
val = raw_input('Press <enter> to continue')
2937
else:
2938
print 'The above revision(s) will be removed.'
2939
if not force:
2940
val = raw_input('Are you sure [y/N]? ')
2941
if val.lower() not in ('y', 'yes'):
2942
print 'Canceled'
2943
return 0
2944
2945
uncommit(b, tree=tree, dry_run=dry_run, verbose=verbose,
2946
revno=revno)
2947
2948
2949
class cmd_break_lock(Command):
2950
"""Break a dead lock on a repository, branch or working directory.
2951
2952
CAUTION: Locks should only be broken when you are sure that the process
2953
holding the lock has been stopped.
2954
2955
You can get information on what locks are open via the 'bzr info' command.
2956
2957
example:
2958
bzr break-lock
2959
"""
2960
takes_args = ['location?']
2961
2962
def run(self, location=None, show=False):
2963
if location is None:
2964
location = u'.'
2965
control, relpath = bzrdir.BzrDir.open_containing(location)
2966
try:
2967
control.break_lock()
2968
except NotImplementedError:
2969
pass
2970
2971
2972
class cmd_wait_until_signalled(Command):
2973
"""Test helper for test_start_and_stop_bzr_subprocess_send_signal.
2974
2975
This just prints a line to signal when it is ready, then blocks on stdin.
2976
"""
2977
2978
hidden = True
2979
2980
def run(self):
2981
sys.stdout.write("running\n")
2982
sys.stdout.flush()
2983
sys.stdin.readline()
2984
2985
2986
class cmd_serve(Command):
2987
"""Run the bzr server."""
2988
2989
aliases = ['server']
2990
2991
takes_options = [
2992
Option('inet',
2993
help='serve on stdin/out for use from inetd or sshd'),
2994
Option('port',
2995
help='listen for connections on nominated port of the form '
2996
'[hostname:]portnumber. Passing 0 as the port number will '
2997
'result in a dynamically allocated port.',
2998
type=str),
2999
Option('directory',
3000
help='serve contents of directory',
3001
type=unicode),
3002
Option('allow-writes',
3003
help='By default the server is a readonly server. Supplying '
3004
'--allow-writes enables write access to the contents of '
3005
'the served directory and below. '
3006
),
3007
]
3008
3009
def run(self, port=None, inet=False, directory=None, allow_writes=False):
3010
from bzrlib.transport import smart
3011
from bzrlib.transport import get_transport
3012
if directory is None:
3013
directory = os.getcwd()
3014
url = urlutils.local_path_to_url(directory)
3015
if not allow_writes:
3016
url = 'readonly+' + url
3017
t = get_transport(url)
3018
if inet:
3019
server = smart.SmartServerPipeStreamMedium(sys.stdin, sys.stdout, t)
3020
elif port is not None:
3021
if ':' in port:
3022
host, port = port.split(':')
3023
else:
3024
host = '127.0.0.1'
3025
server = smart.SmartTCPServer(t, host=host, port=int(port))
3026
print 'listening on port: ', server.port
3027
sys.stdout.flush()
3028
else:
3029
raise errors.BzrCommandError("bzr serve requires one of --inet or --port")
3030
server.serve()
3031
3032
3033
# command-line interpretation helper for merge-related commands
3034
def _merge_helper(other_revision, base_revision,
3035
check_clean=True, ignore_zero=False,
3036
this_dir=None, backup_files=False,
3037
merge_type=None,
3038
file_list=None, show_base=False, reprocess=False,
3039
pull=False,
3040
pb=DummyProgress()):
3041
"""Merge changes into a tree.
3042
3043
base_revision
3044
list(path, revno) Base for three-way merge.
3045
If [None, None] then a base will be automatically determined.
3046
other_revision
3047
list(path, revno) Other revision for three-way merge.
3048
this_dir
3049
Directory to merge changes into; '.' by default.
3050
check_clean
3051
If true, this_dir must have no uncommitted changes before the
3052
merge begins.
3053
ignore_zero - If true, suppress the "zero conflicts" message when
3054
there are no conflicts; should be set when doing something we expect
3055
to complete perfectly.
3056
file_list - If supplied, merge only changes to selected files.
3057
3058
All available ancestors of other_revision and base_revision are
3059
automatically pulled into the branch.
3060
3061
The revno may be -1 to indicate the last revision on the branch, which is
3062
the typical case.
3063
3064
This function is intended for use from the command line; programmatic
3065
clients might prefer to call merge.merge_inner(), which has less magic
3066
behavior.
3067
"""
3068
# Loading it late, so that we don't always have to import bzrlib.merge
3069
if merge_type is None:
3070
merge_type = _mod_merge.Merge3Merger
3071
if this_dir is None:
3072
this_dir = u'.'
3073
this_tree = WorkingTree.open_containing(this_dir)[0]
3074
if show_base and not merge_type is _mod_merge.Merge3Merger:
3075
raise errors.BzrCommandError("Show-base is not supported for this merge"
3076
" type. %s" % merge_type)
3077
if reprocess and not merge_type.supports_reprocess:
3078
raise errors.BzrCommandError("Conflict reduction is not supported for merge"
3079
" type %s." % merge_type)
3080
if reprocess and show_base:
3081
raise errors.BzrCommandError("Cannot do conflict reduction and show base.")
3082
try:
3083
merger = _mod_merge.Merger(this_tree.branch, this_tree=this_tree,
3084
pb=pb)
3085
merger.pp = ProgressPhase("Merge phase", 5, pb)
3086
merger.pp.next_phase()
3087
merger.check_basis(check_clean)
3088
merger.set_other(other_revision)
3089
merger.pp.next_phase()
3090
merger.set_base(base_revision)
3091
if merger.base_rev_id == merger.other_rev_id:
3092
note('Nothing to do.')
3093
return 0
3094
if file_list is None:
3095
if pull and merger.base_rev_id == merger.this_rev_id:
3096
count = merger.this_tree.pull(merger.this_branch,
3097
False, merger.other_rev_id)
3098
note('%d revision(s) pulled.' % (count,))
3099
return 0
3100
merger.backup_files = backup_files
3101
merger.merge_type = merge_type
3102
merger.set_interesting_files(file_list)
3103
merger.show_base = show_base
3104
merger.reprocess = reprocess
3105
conflicts = merger.do_merge()
3106
if file_list is None:
3107
merger.set_pending()
3108
finally:
3109
pb.clear()
3110
return conflicts
3111
3112
3113
# Compatibility
3114
merge = _merge_helper
3115
3116
3117
# these get imported and then picked up by the scan for cmd_*
3118
# TODO: Some more consistent way to split command definitions across files;
3119
# we do need to load at least some information about them to know of
3120
# aliases. ideally we would avoid loading the implementation until the
3121
# details were needed.
3122
from bzrlib.cmd_version_info import cmd_version_info
3123
from bzrlib.conflicts import cmd_resolve, cmd_conflicts, restore
3124
from bzrlib.bundle.commands import cmd_bundle_revisions
3125
from bzrlib.sign_my_commits import cmd_sign_my_commits
3126
from bzrlib.weave_commands import cmd_weave_list, cmd_weave_join, \
3127
cmd_weave_plan_merge, cmd_weave_merge_text
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0