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