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