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