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