« back to all changes in this revision
Viewing changes to bzrlib/builtins.py
- browse files at revision 2485.8.58
- compare with another revision
- download diff
- download tarball
- view history from revision 2485.8.58
- Committer: Vincent Ladeuil
- Date: 2007-07-15 11:24:18 UTC
- mfrom: (2617 +trunk)
- mto: This revision was merged to the branch mainline in revision 2646.
- Revision ID: v.ladeuil+lp@free.fr-20070715112418-9nn4n6esxv60ny4b
merge bzr.dev@1617
- files added:
- COPYING.txt
- bzrlib/benchmarks/tree_creator
- bzrlib/repofmt
- bzrlib/smart
- bzrlib/tests/commands
- bzrlib/tests/intertree_implementations
- bzrlib/tests/per_lock
- bzrlib/tests/tree_implementations
- bzrlib/version_info_formats
- doc/developers
- man1
- tools/win32
- files removed:
- NEWS.developers
- bzrlib/util/urlgrabber
- files renamed:
- bzrlib/graph.py => bzrlib/deprecated_graph.py
- bzrlib/tests/test_revprops.py => bzrlib/tests/repository_implementations/test_revision.py
- bzrlib/tests/test_command.py => bzrlib/tests/test_commands.py
- bzrlib/tests/test_graph.py => bzrlib/tests/test_deprecated_graph.py
- bzrlib/tests/test_delta.py => bzrlib/tests/workingtree_implementations/test_changes_from.py
- bzrlib/win32console.py => bzrlib/win32utils.py
- HACKING => doc/developers/HACKING
- files modified:
- .bzrignore
added
removed
bzrlib/builtins.py
1
# Copyright (C) 2004, 2005, 2006 by Canonical Ltd
2
1
# Copyright (C) 2004, 2005, 2006, 2007 Canonical Ltd
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
5
5
# the Free Software Foundation; either version 2 of the License, or
6
6
# (at your option) any later version.
7
7
#
8
8
# This program is distributed in the hope that it will be useful,
9
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
10
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11
11
# GNU General Public License for more details.
12
12
#
13
13
# You should have received a copy of the GNU General Public License
14
14
# along with this program; if not, write to the Free Software
15
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
16
16
17
17
"""builtin bzr commands"""
18
18
19
import os
20
from StringIO import StringIO
19
21
22
from bzrlib.lazy_import import lazy_import
23
lazy_import(globals(), """
20
24
import codecs
21
25
import errno
22
import os
23
import os.path
24
26
import sys
27
import tempfile
28
import time
25
29
26
30
import bzrlib
27
31
from bzrlib import (
28
32
branch,
33
bugtracker,
29
34
bundle,
30
35
bzrdir,
36
delta,
31
37
config,
32
38
errors,
39
globbing,
33
40
ignores,
34
41
log,
42
merge as _mod_merge,
43
merge_directive,
35
44
osutils,
45
registry,
36
46
repository,
47
revision as _mod_revision,
48
revisionspec,
49
symbol_versioning,
37
50
transport,
51
tree as _mod_tree,
38
52
ui,
39
53
urlutils,
40
54
)
41
from bzrlib.branch import Branch, BranchReferenceFormat
42
from bzrlib.bundle import read_bundle_from_url
55
from bzrlib.branch import Branch
43
56
from bzrlib.bundle.apply_bundle import install_bundle, merge_bundle
44
57
from bzrlib.conflicts import ConflictList
58
from bzrlib.revisionspec import RevisionSpec
59
from bzrlib.smtp_connection import SMTPConnection
60
from bzrlib.workingtree import WorkingTree
61
""")
62
45
63
from bzrlib.commands import Command, display_command
46
from bzrlib.errors import (BzrError, BzrCheckError, BzrCommandError,
47
NotBranchError, DivergedBranches, NotConflicted,
48
NoSuchFile, NoWorkingTree, FileInWrongBranch,
49
NotVersionedError, NotABundle)
50
from bzrlib.merge import Merge3Merger
51
from bzrlib.option import Option
64
from bzrlib.option import ListOption, Option, RegistryOption
52
65
from bzrlib.progress import DummyProgress, ProgressPhase
53
from bzrlib.revision import common_ancestor
54
from bzrlib.revisionspec import RevisionSpec
55
66
from bzrlib.trace import mutter, note, log_error, warning, is_quiet, info
56
from bzrlib.transport.local import LocalTransport
57
from bzrlib.workingtree import WorkingTree
58
67
59
68
60
69
def tree_files(file_list, default_branch=u'.'):
61
70
try:
62
71
return internal_tree_files(file_list, default_branch)
63
except FileInWrongBranch, e:
64
raise BzrCommandError("%s is not in the same branch as %s" %
65
(e.path, file_list[0]))
72
except errors.FileInWrongBranch, e:
73
raise errors.BzrCommandError("%s is not in the same branch as %s" %
74
(e.path, file_list[0]))
66
75
67
76
68
77
# XXX: Bad function name; should possibly also be a class method of
77
86
78
87
:param file_list: Filenames to convert.
79
88
80
:param default_branch: Fallback tree path to use if file_list is empty or None.
89
:param default_branch: Fallback tree path to use if file_list is empty or
90
None.
81
91
82
92
:return: workingtree, [relative_paths]
83
93
"""
84
94
if file_list is None or len(file_list) == 0:
85
95
return WorkingTree.open_containing(default_branch)[0], file_list
86
tree = WorkingTree.open_containing(file_list[0])[0]
96
tree = WorkingTree.open_containing(osutils.realpath(file_list[0]))[0]
87
97
new_list = []
88
98
for filename in file_list:
89
99
try:
90
new_list.append(tree.relpath(filename))
100
new_list.append(tree.relpath(osutils.dereference_path(filename)))
91
101
except errors.PathNotChild:
92
raise FileInWrongBranch(tree.branch, filename)
102
raise errors.FileInWrongBranch(tree.branch, filename)
93
103
return tree, new_list
94
104
95
105
106
@symbol_versioning.deprecated_function(symbol_versioning.zero_fifteen)
96
107
def get_format_type(typestring):
97
108
"""Parse and return a format specifier."""
98
if typestring == "weave":
99
return bzrdir.BzrDirFormat6()
109
# Have to use BzrDirMetaFormat1 directly, so that
110
# RepositoryFormat.set_default_format works
100
111
if typestring == "default":
101
112
return bzrdir.BzrDirMetaFormat1()
102
if typestring == "metaweave":
103
format = bzrdir.BzrDirMetaFormat1()
104
format.repository_format = repository.RepositoryFormat7()
105
return format
106
if typestring == "knit":
107
format = bzrdir.BzrDirMetaFormat1()
108
format.repository_format = repository.RepositoryFormatKnit1()
109
return format
110
msg = "Unknown bzr format %s. Current formats are: default, knit,\n" \
111
"metaweave and weave" % typestring
112
raise BzrCommandError(msg)
113
try:
114
return bzrdir.format_registry.make_bzrdir(typestring)
115
except KeyError:
116
msg = 'Unknown bzr format "%s". See "bzr help formats".' % typestring
117
raise errors.BzrCommandError(msg)
113
118
114
119
115
120
# TODO: Make sure no commands unconditionally use the working directory as a
139
144
modified
140
145
Text has changed since the previous revision.
141
146
147
kind changed
148
File kind has been changed (e.g. from file to directory).
149
142
150
unknown
143
151
Not versioned and not matching an ignore pattern.
144
152
145
To see ignored files use 'bzr ignored'. For details in the
153
To see ignored files use 'bzr ignored'. For details on the
146
154
changes to file texts, use 'bzr diff'.
155
156
--short gives a status flags for each item, similar to the SVN's status
157
command.
147
158
148
159
If no arguments are specified, the status of the entire working
149
160
directory is shown. Otherwise, only the status of the specified
157
168
# TODO: --no-recurse, --recurse options
158
169
159
170
takes_args = ['file*']
160
takes_options = ['show-ids', 'revision']
171
takes_options = ['show-ids', 'revision',
172
Option('short', help='Give short SVN-style status lines.'),
173
Option('versioned', help='Only show versioned files.')]
161
174
aliases = ['st', 'stat']
162
175
163
176
encoding_type = 'replace'
177
_see_also = ['diff', 'revert', 'status-flags']
164
178
165
179
@display_command
166
def run(self, show_ids=False, file_list=None, revision=None):
180
def run(self, show_ids=False, file_list=None, revision=None, short=False,
181
versioned=False):
167
182
from bzrlib.status import show_tree_status
168
183
169
184
tree, file_list = tree_files(file_list)
170
185
171
186
show_tree_status(tree, show_ids=show_ids,
172
187
specific_files=file_list, revision=revision,
173
to_file=self.outf)
188
to_file=self.outf, short=short, versioned=versioned)
174
189
175
190
176
191
class cmd_cat_revision(Command):
189
204
@display_command
190
205
def run(self, revision_id=None, revision=None):
191
206
207
revision_id = osutils.safe_revision_id(revision_id, warn=False)
192
208
if revision_id is not None and revision is not None:
193
raise BzrCommandError('You can only supply one of revision_id or --revision')
209
raise errors.BzrCommandError('You can only supply one of'
210
' revision_id or --revision')
194
211
if revision_id is None and revision is None:
195
raise BzrCommandError('You must supply either --revision or a revision_id')
212
raise errors.BzrCommandError('You must supply either'
213
' --revision or a revision_id')
196
214
b = WorkingTree.open_containing(u'.')[0].branch
197
215
198
216
# TODO: jam 20060112 should cat-revision always output utf-8?
201
219
elif revision is not None:
202
220
for rev in revision:
203
221
if rev is None:
204
raise BzrCommandError('You cannot specify a NULL revision.')
222
raise errors.BzrCommandError('You cannot specify a NULL'
223
' revision.')
205
224
revno, rev_id = rev.in_history(b)
206
225
self.outf.write(b.repository.get_revision_xml(rev_id).decode('utf-8'))
207
226
208
227
228
class cmd_remove_tree(Command):
229
"""Remove the working tree from a given branch/checkout.
230
231
Since a lightweight checkout is little more than a working tree
232
this will refuse to run against one.
233
234
To re-create the working tree, use "bzr checkout".
235
"""
236
_see_also = ['checkout', 'working-trees']
237
238
takes_args = ['location?']
239
240
def run(self, location='.'):
241
d = bzrdir.BzrDir.open(location)
242
243
try:
244
working = d.open_workingtree()
245
except errors.NoWorkingTree:
246
raise errors.BzrCommandError("No working tree to remove")
247
except errors.NotLocalUrl:
248
raise errors.BzrCommandError("You cannot remove the working tree of a "
249
"remote path")
250
251
working_path = working.bzrdir.root_transport.base
252
branch_path = working.branch.bzrdir.root_transport.base
253
if working_path != branch_path:
254
raise errors.BzrCommandError("You cannot remove the working tree from "
255
"a lightweight checkout")
256
257
d.destroy_workingtree()
258
259
209
260
class cmd_revno(Command):
210
261
"""Show current revision number.
211
262
212
263
This is equal to the number of revisions on this branch.
213
264
"""
214
265
266
_see_also = ['info']
215
267
takes_args = ['location?']
216
268
217
269
@display_command
235
287
revs.extend(revision)
236
288
if revision_info_list is not None:
237
289
for rev in revision_info_list:
238
revs.append(RevisionSpec(rev))
290
revs.append(RevisionSpec.from_string(rev))
291
292
b = Branch.open_containing(u'.')[0]
293
239
294
if len(revs) == 0:
240
raise BzrCommandError('You must supply a revision identifier')
241
242
b = WorkingTree.open_containing(u'.')[0].branch
295
revs.append(RevisionSpec.from_string('-1'))
243
296
244
297
for rev in revs:
245
298
revinfo = rev.in_history(b)
246
299
if revinfo.revno is None:
247
print ' %s' % revinfo.rev_id
300
dotted_map = b.get_revision_id_to_revno_map()
301
revno = '.'.join(str(i) for i in dotted_map[revinfo.rev_id])
302
print '%s %s' % (revno, revinfo.rev_id)
248
303
else:
249
304
print '%4d %s' % (revinfo.revno, revinfo.rev_id)
250
305
274
329
275
330
--dry-run will show which files would be added, but not actually
276
331
add them.
332
333
--file-ids-from will try to use the file ids from the supplied path.
334
It looks up ids trying to find a matching parent directory with the
335
same filename, and then by pure path. This option is rarely needed
336
but can be useful when adding the same logical file into two
337
branches that will be merged later (without showing the two different
338
adds as a conflict). It is also useful when merging another project
339
into a subdirectory of this one.
277
340
"""
278
341
takes_args = ['file*']
279
takes_options = ['no-recurse', 'dry-run', 'verbose']
342
takes_options = [
343
Option('no-recurse',
344
help="Don't recursively add the contents of directories."),
345
Option('dry-run',
346
help="Show what would be done, but don't actually do anything."),
347
'verbose',
348
Option('file-ids-from',
349
type=unicode,
350
help='Lookup file ids from this tree.'),
351
]
280
352
encoding_type = 'replace'
353
_see_also = ['remove']
281
354
282
def run(self, file_list, no_recurse=False, dry_run=False, verbose=False):
355
def run(self, file_list, no_recurse=False, dry_run=False, verbose=False,
356
file_ids_from=None):
283
357
import bzrlib.add
284
358
285
action = bzrlib.add.AddAction(to_file=self.outf,
286
should_print=(not is_quiet()))
287
288
added, ignored = bzrlib.add.smart_add(file_list, not no_recurse,
289
action=action, save=not dry_run)
359
base_tree = None
360
if file_ids_from is not None:
361
try:
362
base_tree, base_path = WorkingTree.open_containing(
363
file_ids_from)
364
except errors.NoWorkingTree:
365
base_branch, base_path = Branch.open_containing(
366
file_ids_from)
367
base_tree = base_branch.basis_tree()
368
369
action = bzrlib.add.AddFromBaseAction(base_tree, base_path,
370
to_file=self.outf, should_print=(not is_quiet()))
371
else:
372
action = bzrlib.add.AddAction(to_file=self.outf,
373
should_print=(not is_quiet()))
374
375
if base_tree:
376
base_tree.lock_read()
377
try:
378
file_list = self._maybe_expand_globs(file_list)
379
if file_list:
380
tree = WorkingTree.open_containing(file_list[0])[0]
381
else:
382
tree = WorkingTree.open_containing(u'.')[0]
383
added, ignored = tree.smart_add(file_list, not
384
no_recurse, action=action, save=not dry_run)
385
finally:
386
if base_tree is not None:
387
base_tree.unlock()
290
388
if len(ignored) > 0:
291
389
if verbose:
292
390
for glob in sorted(ignored.keys()):
338
436
"""Show inventory of the current working copy or a revision.
339
437
340
438
It is possible to limit the output to a particular entry
341
type using the --kind option. For example; --kind file.
439
type using the --kind option. For example: --kind file.
440
441
It is also possible to restrict the list of files to a specific
442
set. For example: bzr inventory --show-ids this/file
342
443
"""
343
444
344
takes_options = ['revision', 'show-ids', 'kind']
345
445
hidden = True
446
_see_also = ['ls']
447
takes_options = [
448
'revision',
449
'show-ids',
450
Option('kind',
451
help='List entries of a particular kind: file, directory, symlink.',
452
type=unicode),
453
]
454
takes_args = ['file*']
455
346
456
@display_command
347
def run(self, revision=None, show_ids=False, kind=None):
457
def run(self, revision=None, show_ids=False, kind=None, file_list=None):
348
458
if kind and kind not in ['file', 'directory', 'symlink']:
349
raise BzrCommandError('invalid kind specified')
350
tree = WorkingTree.open_containing(u'.')[0]
351
if revision is None:
352
inv = tree.read_working_inventory()
353
else:
354
if len(revision) > 1:
355
raise BzrCommandError('bzr inventory --revision takes'
356
' exactly one revision identifier')
357
inv = tree.branch.repository.get_revision_inventory(
358
revision[0].in_history(tree.branch).rev_id)
359
360
for path, entry in inv.entries():
459
raise errors.BzrCommandError('invalid kind %r specified' % (kind,))
460
461
work_tree, file_list = tree_files(file_list)
462
work_tree.lock_read()
463
try:
464
if revision is not None:
465
if len(revision) > 1:
466
raise errors.BzrCommandError(
467
'bzr inventory --revision takes exactly one revision'
468
' identifier')
469
revision_id = revision[0].in_history(work_tree.branch).rev_id
470
tree = work_tree.branch.repository.revision_tree(revision_id)
471
472
extra_trees = [work_tree]
473
tree.lock_read()
474
else:
475
tree = work_tree
476
extra_trees = []
477
478
if file_list is not None:
479
file_ids = tree.paths2ids(file_list, trees=extra_trees,
480
require_versioned=True)
481
# find_ids_across_trees may include some paths that don't
482
# exist in 'tree'.
483
entries = sorted((tree.id2path(file_id), tree.inventory[file_id])
484
for file_id in file_ids if file_id in tree)
485
else:
486
entries = tree.inventory.entries()
487
finally:
488
tree.unlock()
489
if tree is not work_tree:
490
work_tree.unlock()
491
492
for path, entry in entries:
361
493
if kind and kind != entry.kind:
362
494
continue
363
495
if show_ids:
376
508
377
509
If the last argument is a versioned directory, all the other names
378
510
are moved into it. Otherwise, there must be exactly two arguments
379
and the file is changed to a new name, which must not already exist.
511
and the file is changed to a new name.
512
513
If OLDNAME does not exist on the filesystem but is versioned and
514
NEWNAME does exist on the filesystem but is not versioned, mv
515
assumes that the file has been manually moved and only updates
516
its internal inventory to reflect that change.
517
The same is valid when moving many SOURCE files to a DESTINATION.
380
518
381
519
Files cannot be moved between branches.
382
520
"""
383
521
384
522
takes_args = ['names*']
523
takes_options = [Option("after", help="Move only the bzr identifier"
524
" of the file, because the file has already been moved."),
525
]
385
526
aliases = ['move', 'rename']
386
527
encoding_type = 'replace'
387
528
388
def run(self, names_list):
529
def run(self, names_list, after=False):
389
530
if names_list is None:
390
531
names_list = []
391
532
392
533
if len(names_list) < 2:
393
raise BzrCommandError("missing file argument")
534
raise errors.BzrCommandError("missing file argument")
394
535
tree, rel_names = tree_files(names_list)
395
536
396
537
if os.path.isdir(names_list[-1]):
397
538
# move into existing directory
398
for pair in tree.move(rel_names[:-1], rel_names[-1]):
539
for pair in tree.move(rel_names[:-1], rel_names[-1], after=after):
399
540
self.outf.write("%s => %s\n" % pair)
400
541
else:
401
542
if len(names_list) != 2:
402
raise BzrCommandError('to mv multiple files the destination '
403
'must be a versioned directory')
404
tree.rename_one(rel_names[0], rel_names[1])
543
raise errors.BzrCommandError('to mv multiple files the'
544
' destination must be a versioned'
545
' directory')
546
tree.rename_one(rel_names[0], rel_names[1], after=after)
405
547
self.outf.write("%s => %s\n" % (rel_names[0], rel_names[1]))
406
548
407
549
425
567
location can be accessed.
426
568
"""
427
569
428
takes_options = ['remember', 'overwrite', 'revision', 'verbose']
570
_see_also = ['push', 'update', 'status-flags']
571
takes_options = ['remember', 'overwrite', 'revision', 'verbose',
572
Option('directory',
573
help='Branch to pull into, '
574
'rather than the one containing the working directory.',
575
short_name='d',
576
type=unicode,
577
),
578
]
429
579
takes_args = ['location?']
430
580
encoding_type = 'replace'
431
581
432
def run(self, location=None, remember=False, overwrite=False, revision=None, verbose=False):
582
def run(self, location=None, remember=False, overwrite=False,
583
revision=None, verbose=False,
584
directory=None):
585
from bzrlib.tag import _merge_tags_if_possible
433
586
# FIXME: too much stuff is in the command class
587
revision_id = None
588
mergeable = None
589
if directory is None:
590
directory = u'.'
434
591
try:
435
tree_to = WorkingTree.open_containing(u'.')[0]
592
tree_to = WorkingTree.open_containing(directory)[0]
436
593
branch_to = tree_to.branch
437
except NoWorkingTree:
594
except errors.NoWorkingTree:
438
595
tree_to = None
439
branch_to = Branch.open_containing(u'.')[0]
596
branch_to = Branch.open_containing(directory)[0]
440
597
441
598
reader = None
599
# The user may provide a bundle or branch as 'location' We first try to
600
# identify a bundle, if it's not, we try to preserve connection used by
601
# the transport to access the branch.
442
602
if location is not None:
443
try:
444
reader = bundle.read_bundle_from_url(location)
445
except NotABundle:
446
pass # Continue on considering this url a Branch
603
url = urlutils.normalize_url(location)
604
url, filename = urlutils.split(url, exclude_trailing_slash=False)
605
location_transport = transport.get_transport(url)
606
if filename:
607
try:
608
read_bundle = bundle.read_mergeable_from_transport
609
# There may be redirections but we ignore the intermediate
610
# and final transports used
611
mergeable, t = read_bundle(location_transport, filename)
612
except errors.NotABundle:
613
# Continue on considering this url a Branch but adjust the
614
# location_transport
615
location_transport = location_transport.clone(filename)
616
else:
617
# A directory was provided, location_transport is correct
618
pass
447
619
448
620
stored_loc = branch_to.get_parent()
449
621
if location is None:
450
622
if stored_loc is None:
451
raise BzrCommandError("No pull location known or specified.")
623
raise errors.BzrCommandError("No pull location known or"
624
" specified.")
452
625
else:
453
626
display_url = urlutils.unescape_for_display(stored_loc,
454
627
self.outf.encoding)
455
628
self.outf.write("Using saved location: %s\n" % display_url)
456
629
location = stored_loc
457
458
459
if reader is not None:
460
install_bundle(branch_to.repository, reader)
630
location_transport = transport.get_transport(location)
631
632
if mergeable is not None:
633
if revision is not None:
634
raise errors.BzrCommandError(
635
'Cannot use -r with merge directives or bundles')
636
revision_id = mergeable.install_revisions(branch_to.repository)
461
637
branch_from = branch_to
462
638
else:
463
branch_from = Branch.open(location)
639
branch_from = Branch.open_from_transport(location_transport)
464
640
465
641
if branch_to.get_parent() is None or remember:
466
642
branch_to.set_parent(branch_from.base)
467
643
468
rev_id = None
469
if revision is None:
470
if reader is not None:
471
rev_id = reader.target
472
elif len(revision) == 1:
473
rev_id = revision[0].in_history(branch_from).rev_id
474
else:
475
raise BzrCommandError('bzr pull --revision takes one value.')
644
if revision is not None:
645
if len(revision) == 1:
646
revision_id = revision[0].in_history(branch_from).rev_id
647
else:
648
raise errors.BzrCommandError(
649
'bzr pull --revision takes one value.')
476
650
477
651
old_rh = branch_to.revision_history()
478
652
if tree_to is not None:
479
count = tree_to.pull(branch_from, overwrite, rev_id)
653
result = tree_to.pull(branch_from, overwrite, revision_id,
654
delta._ChangeReporter(unversioned_filter=tree_to.is_ignored))
480
655
else:
481
count = branch_to.pull(branch_from, overwrite, rev_id)
482
note('%d revision(s) pulled.' % (count,))
656
result = branch_to.pull(branch_from, overwrite, revision_id)
483
657
658
result.report(self.outf)
484
659
if verbose:
660
from bzrlib.log import show_changed_revisions
485
661
new_rh = branch_to.revision_history()
486
if old_rh != new_rh:
487
# Something changed
488
from bzrlib.log import show_changed_revisions
489
show_changed_revisions(branch_to, old_rh, new_rh,
490
to_file=self.outf)
662
show_changed_revisions(branch_to, old_rh, new_rh,
663
to_file=self.outf)
491
664
492
665
493
666
class cmd_push(Command):
516
689
location can be accessed.
517
690
"""
518
691
692
_see_also = ['pull', 'update', 'working-trees']
519
693
takes_options = ['remember', 'overwrite', 'verbose',
520
Option('create-prefix',
521
help='Create the path leading up to the branch '
522
'if it does not already exist')]
694
Option('create-prefix',
695
help='Create the path leading up to the branch '
696
'if it does not already exist.'),
697
Option('directory',
698
help='Branch to push from, '
699
'rather than the one containing the working directory.',
700
short_name='d',
701
type=unicode,
702
),
703
Option('use-existing-dir',
704
help='By default push will fail if the target'
705
' directory exists, but does not already'
706
' have a control directory. This flag will'
707
' allow push to proceed.'),
708
]
523
709
takes_args = ['location?']
524
710
encoding_type = 'replace'
525
711
526
712
def run(self, location=None, remember=False, overwrite=False,
527
create_prefix=False, verbose=False):
713
create_prefix=False, verbose=False,
714
use_existing_dir=False,
715
directory=None):
528
716
# FIXME: Way too big! Put this into a function called from the
529
717
# command.
530
531
br_from = Branch.open_containing('.')[0]
718
if directory is None:
719
directory = '.'
720
br_from = Branch.open_containing(directory)[0]
532
721
stored_loc = br_from.get_push_location()
533
722
if location is None:
534
723
if stored_loc is None:
535
raise BzrCommandError("No push location known or specified.")
724
raise errors.BzrCommandError("No push location known or specified.")
536
725
else:
537
726
display_url = urlutils.unescape_for_display(stored_loc,
538
727
self.outf.encoding)
540
729
location = stored_loc
541
730
542
731
to_transport = transport.get_transport(location)
543
location_url = to_transport.base
544
732
733
br_to = repository_to = dir_to = None
734
try:
735
dir_to = bzrdir.BzrDir.open_from_transport(to_transport)
736
except errors.NotBranchError:
737
pass # Didn't find anything
738
else:
739
# If we can open a branch, use its direct repository, otherwise see
740
# if there is a repository without a branch.
741
try:
742
br_to = dir_to.open_branch()
743
except errors.NotBranchError:
744
# Didn't find a branch, can we find a repository?
745
try:
746
repository_to = dir_to.find_repository()
747
except errors.NoRepositoryPresent:
748
pass
749
else:
750
# Found a branch, so we must have found a repository
751
repository_to = br_to.repository
752
push_result = None
545
753
old_rh = []
546
try:
547
dir_to = bzrdir.BzrDir.open(location_url)
548
br_to = dir_to.open_branch()
549
except NotBranchError:
550
# create a branch.
551
to_transport = to_transport.clone('..')
552
if not create_prefix:
553
try:
554
relurl = to_transport.relpath(location_url)
555
mutter('creating directory %s => %s', location_url, relurl)
556
to_transport.mkdir(relurl)
557
except NoSuchFile:
558
raise BzrCommandError("Parent directory of %s "
559
"does not exist." % location)
560
else:
561
current = to_transport.base
562
needed = [(to_transport, to_transport.relpath(location_url))]
563
while needed:
564
try:
565
to_transport, relpath = needed[-1]
566
to_transport.mkdir(relpath)
567
needed.pop()
568
except NoSuchFile:
569
new_transport = to_transport.clone('..')
570
needed.append((new_transport,
571
new_transport.relpath(to_transport.base)))
572
if new_transport.base == to_transport.base:
573
raise BzrCommandError("Could not create "
574
"path prefix.")
575
dir_to = br_from.bzrdir.clone(location_url,
754
if dir_to is None:
755
# The destination doesn't exist; create it.
756
# XXX: Refactor the create_prefix/no_create_prefix code into a
757
# common helper function
758
try:
759
to_transport.mkdir('.')
760
except errors.FileExists:
761
if not use_existing_dir:
762
raise errors.BzrCommandError("Target directory %s"
763
" already exists, but does not have a valid .bzr"
764
" directory. Supply --use-existing-dir to push"
765
" there anyway." % location)
766
except errors.NoSuchFile:
767
if not create_prefix:
768
raise errors.BzrCommandError("Parent directory of %s"
769
" does not exist."
770
"\nYou may supply --create-prefix to create all"
771
" leading parent directories."
772
% location)
773
_create_prefix(to_transport)
774
775
# Now the target directory exists, but doesn't have a .bzr
776
# directory. So we need to create it, along with any work to create
777
# all of the dependent branches, etc.
778
dir_to = br_from.bzrdir.clone_on_transport(to_transport,
576
779
revision_id=br_from.last_revision())
577
780
br_to = dir_to.open_branch()
578
count = len(br_to.revision_history())
781
# TODO: Some more useful message about what was copied
782
note('Created new branch.')
579
783
# We successfully created the target, remember it
580
784
if br_from.get_push_location() is None or remember:
581
785
br_from.set_push_location(br_to.base)
582
else:
786
elif repository_to is None:
787
# we have a bzrdir but no branch or repository
788
# XXX: Figure out what to do other than complain.
789
raise errors.BzrCommandError("At %s you have a valid .bzr control"
790
" directory, but not a branch or repository. This is an"
791
" unsupported configuration. Please move the target directory"
792
" out of the way and try again."
793
% location)
794
elif br_to is None:
795
# We have a repository but no branch, copy the revisions, and then
796
# create a branch.
797
last_revision_id = br_from.last_revision()
798
repository_to.fetch(br_from.repository,
799
revision_id=last_revision_id)
800
br_to = br_from.clone(dir_to, revision_id=last_revision_id)
801
note('Created new branch.')
802
if br_from.get_push_location() is None or remember:
803
br_from.set_push_location(br_to.base)
804
else: # We have a valid to branch
583
805
# We were able to connect to the remote location, so remember it
584
806
# we don't need to successfully push because of possible divergence.
585
807
if br_from.get_push_location() is None or remember:
589
811
try:
590
812
tree_to = dir_to.open_workingtree()
591
813
except errors.NotLocalUrl:
592
warning('This transport does not update the working '
593
'tree of: %s' % (br_to.base,))
594
count = br_to.pull(br_from, overwrite)
595
except NoWorkingTree:
596
count = br_to.pull(br_from, overwrite)
814
warning("This transport does not update the working "
815
"tree of: %s. See 'bzr help working-trees' for "
816
"more information." % br_to.base)
817
push_result = br_from.push(br_to, overwrite)
818
except errors.NoWorkingTree:
819
push_result = br_from.push(br_to, overwrite)
597
820
else:
598
count = tree_to.pull(br_from, overwrite)
599
except DivergedBranches:
600
raise BzrCommandError("These branches have diverged."
601
" Try a merge then push with overwrite.")
602
note('%d revision(s) pushed.' % (count,))
603
604
if verbose:
821
tree_to.lock_write()
822
try:
823
push_result = br_from.push(tree_to.branch, overwrite)
824
tree_to.update()
825
finally:
826
tree_to.unlock()
827
except errors.DivergedBranches:
828
raise errors.BzrCommandError('These branches have diverged.'
829
' Try using "merge" and then "push".')
830
if push_result is not None:
831
push_result.report(self.outf)
832
elif verbose:
605
833
new_rh = br_to.revision_history()
606
834
if old_rh != new_rh:
607
835
# Something changed
608
836
from bzrlib.log import show_changed_revisions
609
837
show_changed_revisions(br_to, old_rh, new_rh,
610
838
to_file=self.outf)
839
else:
840
# we probably did a clone rather than a push, so a message was
841
# emitted above
842
pass
611
843
612
844
613
845
class cmd_branch(Command):
615
847
616
848
If the TO_LOCATION is omitted, the last component of the FROM_LOCATION will
617
849
be used. In other words, "branch ../foo/bar" will attempt to create ./bar.
850
If the FROM_LOCATION has no / or path separator embedded, the TO_LOCATION
851
is derived from the FROM_LOCATION by stripping a leading scheme or drive
852
identifier, if any. For example, "branch lp:foo-bar" will attempt to
853
create ./foo-bar.
618
854
619
855
To retrieve the branch as of a particular revision, supply the --revision
620
856
parameter, as in "branch foo/bar -r 5".
857
"""
621
858
622
--basis is to speed up branching from remote branches. When specified, it
623
copies all the file-contents, inventory and revision data from the basis
624
branch before copying anything from the remote branch.
625
"""
859
_see_also = ['checkout']
626
860
takes_args = ['from_location', 'to_location?']
627
takes_options = ['revision', 'basis']
861
takes_options = ['revision']
628
862
aliases = ['get', 'clone']
629
863
630
def run(self, from_location, to_location=None, revision=None, basis=None):
864
def run(self, from_location, to_location=None, revision=None):
865
from bzrlib.tag import _merge_tags_if_possible
631
866
if revision is None:
632
867
revision = [None]
633
868
elif len(revision) > 1:
634
raise BzrCommandError(
869
raise errors.BzrCommandError(
635
870
'bzr branch --revision takes exactly 1 revision value')
636
try:
637
br_from = Branch.open(from_location)
638
except OSError, e:
639
if e.errno == errno.ENOENT:
640
raise BzrCommandError('Source location "%s" does not'
641
' exist.' % to_location)
642
else:
643
raise
871
872
br_from = Branch.open(from_location)
644
873
br_from.lock_read()
645
874
try:
646
if basis is not None:
647
basis_dir = bzrdir.BzrDir.open_containing(basis)[0]
648
else:
649
basis_dir = None
650
875
if len(revision) == 1 and revision[0] is not None:
651
876
revision_id = revision[0].in_history(br_from)[1]
652
877
else:
655
880
# RBC 20060209
656
881
revision_id = br_from.last_revision()
657
882
if to_location is None:
658
to_location = os.path.basename(from_location.rstrip("/\\"))
883
to_location = urlutils.derive_to_location(from_location)
659
884
name = None
660
885
else:
661
886
name = os.path.basename(to_location) + '\n'
664
889
try:
665
890
to_transport.mkdir('.')
666
891
except errors.FileExists:
667
raise BzrCommandError('Target directory "%s" already'
668
' exists.' % to_location)
892
raise errors.BzrCommandError('Target directory "%s" already'
893
' exists.' % to_location)
669
894
except errors.NoSuchFile:
670
raise BzrCommandError('Parent of "%s" does not exist.' %
671
to_location)
895
raise errors.BzrCommandError('Parent of "%s" does not exist.'
896
% to_location)
672
897
try:
673
898
# preserve whatever source format we have.
674
dir = br_from.bzrdir.sprout(to_transport.base,
675
revision_id, basis_dir)
899
dir = br_from.bzrdir.sprout(to_transport.base, revision_id,
900
possible_transports=[to_transport])
676
901
branch = dir.open_branch()
677
902
except errors.NoSuchRevision:
678
903
to_transport.delete_tree('.')
679
904
msg = "The branch %s has no revision %s." % (from_location, revision[0])
680
raise BzrCommandError(msg)
681
except errors.UnlistableBranch:
682
osutils.rmtree(to_location)
683
msg = "The branch %s cannot be used as a --basis" % (basis,)
684
raise BzrCommandError(msg)
905
raise errors.BzrCommandError(msg)
685
906
if name:
686
907
branch.control_files.put_utf8('branch-name', name)
908
_merge_tags_if_possible(br_from, branch)
687
909
note('Branched %d revision(s).' % branch.revno())
688
910
finally:
689
911
br_from.unlock()
699
921
700
922
If the TO_LOCATION is omitted, the last component of the BRANCH_LOCATION will
701
923
be used. In other words, "checkout ../foo/bar" will attempt to create ./bar.
924
If the BRANCH_LOCATION has no / or path separator embedded, the TO_LOCATION
925
is derived from the BRANCH_LOCATION by stripping a leading scheme or drive
926
identifier, if any. For example, "checkout lp:foo-bar" will attempt to
927
create ./foo-bar.
702
928
703
929
To retrieve the branch as of a particular revision, supply the --revision
704
930
parameter, as in "checkout foo/bar -r 5". Note that this will be immediately
705
931
out of date [so you cannot commit] but it may be useful (i.e. to examine old
706
932
code.)
933
"""
707
934
708
--basis is to speed up checking out from remote branches. When specified, it
709
uses the inventory and file contents from the basis branch in preference to the
710
branch being checked out.
711
"""
935
_see_also = ['checkouts', 'branch']
712
936
takes_args = ['branch_location?', 'to_location?']
713
takes_options = ['revision', # , 'basis']
937
takes_options = ['revision',
714
938
Option('lightweight',
715
help="perform a lightweight checkout. Lightweight "
939
help="Perform a lightweight checkout. Lightweight "
716
940
"checkouts depend on access to the branch for "
717
"every operation. Normal checkouts can perform "
941
"every operation. Normal checkouts can perform "
718
942
"common operations like diff and status without "
719
943
"such access, and also support local commits."
720
944
),
721
945
]
722
946
aliases = ['co']
723
947
724
def run(self, branch_location=None, to_location=None, revision=None, basis=None,
948
def run(self, branch_location=None, to_location=None, revision=None,
725
949
lightweight=False):
726
950
if revision is None:
727
951
revision = [None]
728
952
elif len(revision) > 1:
729
raise BzrCommandError(
953
raise errors.BzrCommandError(
730
954
'bzr checkout --revision takes exactly 1 revision value')
731
955
if branch_location is None:
732
956
branch_location = osutils.getcwd()
737
961
else:
738
962
revision_id = None
739
963
if to_location is None:
740
to_location = os.path.basename(branch_location.rstrip("/\\"))
964
to_location = urlutils.derive_to_location(branch_location)
741
965
# if the source and to_location are the same,
742
966
# and there is no working tree,
743
967
# then reconstitute a branch
744
if (osutils.abspath(to_location) ==
968
if (osutils.abspath(to_location) ==
745
969
osutils.abspath(branch_location)):
746
970
try:
747
971
source.bzrdir.open_workingtree()
752
976
os.mkdir(to_location)
753
977
except OSError, e:
754
978
if e.errno == errno.EEXIST:
755
raise BzrCommandError('Target directory "%s" already'
756
' exists.' % to_location)
979
raise errors.BzrCommandError('Target directory "%s" already'
980
' exists.' % to_location)
757
981
if e.errno == errno.ENOENT:
758
raise BzrCommandError('Parent of "%s" does not exist.' %
759
to_location)
982
raise errors.BzrCommandError('Parent of "%s" does not exist.'
983
% to_location)
760
984
else:
761
985
raise
762
old_format = bzrdir.BzrDirFormat.get_default_format()
763
bzrdir.BzrDirFormat.set_default_format(bzrdir.BzrDirMetaFormat1())
764
try:
765
if lightweight:
766
checkout = bzrdir.BzrDirMetaFormat1().initialize(to_location)
767
branch.BranchReferenceFormat().initialize(checkout, source)
768
else:
769
checkout_branch = bzrdir.BzrDir.create_branch_convenience(
770
to_location, force_new_tree=False)
771
checkout = checkout_branch.bzrdir
772
checkout_branch.bind(source)
773
if revision_id is not None:
774
rh = checkout_branch.revision_history()
775
checkout_branch.set_revision_history(rh[:rh.index(revision_id) + 1])
776
checkout.create_workingtree(revision_id)
777
finally:
778
bzrdir.BzrDirFormat.set_default_format(old_format)
986
source.create_checkout(to_location, revision_id, lightweight)
779
987
780
988
781
989
class cmd_renames(Command):
784
992
# TODO: Option to show renames between two historical versions.
785
993
786
994
# TODO: Only show renames under dir, rather than in the whole branch.
995
_see_also = ['status']
787
996
takes_args = ['dir?']
788
997
789
998
@display_command
790
999
def run(self, dir=u'.'):
791
from bzrlib.tree import find_renames
792
1000
tree = WorkingTree.open_containing(dir)[0]
793
old_inv = tree.basis_tree().inventory
794
new_inv = tree.read_working_inventory()
795
renames = list(find_renames(old_inv, new_inv))
796
renames.sort()
797
for old_name, new_name in renames:
798
self.outf.write("%s => %s\n" % (old_name, new_name))
1001
tree.lock_read()
1002
try:
1003
new_inv = tree.inventory
1004
old_tree = tree.basis_tree()
1005
old_tree.lock_read()
1006
try:
1007
old_inv = old_tree.inventory
1008
renames = list(_mod_tree.find_renames(old_inv, new_inv))
1009
renames.sort()
1010
for old_name, new_name in renames:
1011
self.outf.write("%s => %s\n" % (old_name, new_name))
1012
finally:
1013
old_tree.unlock()
1014
finally:
1015
tree.unlock()
799
1016
800
1017
801
1018
class cmd_update(Command):
808
1025
If you want to discard your local changes, you can just do a
809
1026
'bzr revert' instead of 'bzr commit' after the update.
810
1027
"""
1028
1029
_see_also = ['pull', 'working-trees']
811
1030
takes_args = ['dir?']
812
1031
aliases = ['up']
813
1032
814
1033
def run(self, dir='.'):
815
1034
tree = WorkingTree.open_containing(dir)[0]
816
tree.lock_write()
1035
master = tree.branch.get_master_branch()
1036
if master is not None:
1037
tree.lock_write()
1038
else:
1039
tree.lock_tree_write()
817
1040
try:
818
last_rev = tree.last_revision()
819
if last_rev == tree.branch.last_revision():
1041
existing_pending_merges = tree.get_parent_ids()[1:]
1042
last_rev = _mod_revision.ensure_null(tree.last_revision())
1043
if last_rev == _mod_revision.ensure_null(
1044
tree.branch.last_revision()):
820
1045
# may be up to date, check master too.
821
1046
master = tree.branch.get_master_branch()
822
if master is None or last_rev == master.last_revision():
1047
if master is None or last_rev == _mod_revision.ensure_null(
1048
master.last_revision()):
823
1049
revno = tree.branch.revision_id_to_revno(last_rev)
824
1050
note("Tree is up to date at revision %d." % (revno,))
825
1051
return 0
826
conflicts = tree.update()
827
revno = tree.branch.revision_id_to_revno(tree.last_revision())
1052
conflicts = tree.update(delta._ChangeReporter(
1053
unversioned_filter=tree.is_ignored))
1054
revno = tree.branch.revision_id_to_revno(
1055
_mod_revision.ensure_null(tree.last_revision()))
828
1056
note('Updated to revision %d.' % (revno,))
1057
if tree.get_parent_ids()[1:] != existing_pending_merges:
1058
note('Your local commits will now show as pending merges with '
1059
"'bzr status', and can be committed with 'bzr commit'.")
829
1060
if conflicts != 0:
830
1061
return 1
831
1062
else:
843
1074
844
1075
Branches and working trees will also report any missing revisions.
845
1076
"""
1077
_see_also = ['revno', 'working-trees', 'repositories']
846
1078
takes_args = ['location?']
847
1079
takes_options = ['verbose']
848
1080
849
1081
@display_command
850
def run(self, location=None, verbose=False):
1082
def run(self, location=None, verbose=0):
851
1083
from bzrlib.info import show_bzrdir_info
852
1084
show_bzrdir_info(bzrdir.BzrDir.open_containing(location)[0],
853
1085
verbose=verbose)
854
1086
855
1087
856
1088
class cmd_remove(Command):
857
"""Make a file unversioned.
1089
"""Remove files or directories.
858
1090
859
This makes bzr stop tracking changes to a versioned file. It does
860
not delete the working copy.
1091
This makes bzr stop tracking changes to the specified files and
1092
delete them if they can easily be recovered using revert.
861
1093
862
1094
You can specify one or more files, and/or --new. If you specify --new,
863
1095
only 'added' files will be removed. If you specify both, then new files
865
1097
also new, they will also be removed.
866
1098
"""
867
1099
takes_args = ['file*']
868
takes_options = ['verbose', Option('new', help='remove newly-added files')]
1100
takes_options = ['verbose',
1101
Option('new', help='Remove newly-added files.'),
1102
RegistryOption.from_kwargs('file-deletion-strategy',
1103
'The file deletion mode to be used',
1104
title='Deletion Strategy', value_switches=True, enum_switch=False,
1105
safe='Only delete files if they can be'
1106
' safely recovered (default).',
1107
keep="Don't delete any files.",
1108
force='Delete all the specified files, even if they can not be '
1109
'recovered and even if they are non-empty directories.')]
869
1110
aliases = ['rm']
870
1111
encoding_type = 'replace'
871
872
def run(self, file_list, verbose=False, new=False):
1112
1113
def run(self, file_list, verbose=False, new=False,
1114
file_deletion_strategy='safe'):
873
1115
tree, file_list = tree_files(file_list)
874
if new is False:
875
if file_list is None:
876
raise BzrCommandError('Specify one or more files to remove, or'
877
' use --new.')
878
else:
879
from bzrlib.delta import compare_trees
880
added = [compare_trees(tree.basis_tree(), tree,
881
specific_files=file_list).added]
882
file_list = sorted([f[0] for f in added[0]], reverse=True)
1116
1117
if file_list is not None:
1118
file_list = [f for f in file_list if f != '']
1119
elif not new:
1120
raise errors.BzrCommandError('Specify one or more files to'
1121
' remove, or use --new.')
1122
1123
if new:
1124
added = tree.changes_from(tree.basis_tree(),
1125
specific_files=file_list).added
1126
file_list = sorted([f[0] for f in added], reverse=True)
883
1127
if len(file_list) == 0:
884
raise BzrCommandError('No matching files.')
885
tree.remove(file_list, verbose=verbose, to_file=self.outf)
1128
raise errors.BzrCommandError('No matching files.')
1129
tree.remove(file_list, verbose=verbose, to_file=self.outf,
1130
keep_files=file_deletion_strategy=='keep',
1131
force=file_deletion_strategy=='force')
886
1132
887
1133
888
1134
class cmd_file_id(Command):
894
1140
"""
895
1141
896
1142
hidden = True
1143
_see_also = ['inventory', 'ls']
897
1144
takes_args = ['filename']
898
1145
899
1146
@display_command
900
1147
def run(self, filename):
901
1148
tree, relpath = WorkingTree.open_containing(filename)
902
i = tree.inventory.path2id(relpath)
903
if i == None:
904
raise BzrError("%r is not a versioned file" % filename)
1149
i = tree.path2id(relpath)
1150
if i is None:
1151
raise errors.NotVersionedError(filename)
905
1152
else:
906
1153
self.outf.write(i + '\n')
907
1154
919
1166
@display_command
920
1167
def run(self, filename):
921
1168
tree, relpath = WorkingTree.open_containing(filename)
922
inv = tree.inventory
923
fid = inv.path2id(relpath)
924
if fid == None:
925
raise BzrError("%r is not a versioned file" % filename)
926
for fip in inv.get_idpath(fid):
927
self.outf.write(fip + '\n')
1169
fid = tree.path2id(relpath)
1170
if fid is None:
1171
raise errors.NotVersionedError(filename)
1172
segments = osutils.splitpath(relpath)
1173
for pos in range(1, len(segments) + 1):
1174
path = osutils.joinpath(segments[:pos])
1175
self.outf.write("%s\n" % tree.path2id(path))
928
1176
929
1177
930
1178
class cmd_reconcile(Command):
945
1193
946
1194
The branch *MUST* be on a listable system such as local disk or sftp.
947
1195
"""
1196
1197
_see_also = ['check']
948
1198
takes_args = ['branch?']
949
1199
950
1200
def run(self, branch="."):
955
1205
956
1206
class cmd_revision_history(Command):
957
1207
"""Display the list of revision ids on a branch."""
1208
1209
_see_also = ['log']
958
1210
takes_args = ['location?']
959
1211
960
1212
hidden = True
969
1221
970
1222
class cmd_ancestry(Command):
971
1223
"""List all revisions merged into this branch."""
1224
1225
_see_also = ['log', 'revision-history']
972
1226
takes_args = ['location?']
973
1227
974
1228
hidden = True
985
1239
last_revision = wt.last_revision()
986
1240
987
1241
revision_ids = b.repository.get_ancestry(last_revision)
988
assert revision_ids[0] == None
1242
assert revision_ids[0] is None
989
1243
revision_ids.pop(0)
990
1244
for revision_id in revision_ids:
991
1245
self.outf.write(revision_id + '\n')
999
1253
1000
1254
If there is a repository in a parent directory of the location, then
1001
1255
the history of the branch will be stored in the repository. Otherwise
1002
init creates a standalone branch which carries its own history in
1003
.bzr.
1256
init creates a standalone branch which carries its own history
1257
in the .bzr directory.
1004
1258
1005
1259
If there is already a branch at the location but it has no working tree,
1006
1260
the tree can be populated with 'bzr checkout'.
1012
1266
bzr status
1013
1267
bzr commit -m 'imported project'
1014
1268
"""
1269
1270
_see_also = ['init-repo', 'branch', 'checkout']
1015
1271
takes_args = ['location?']
1016
1272
takes_options = [
1017
Option('format',
1018
help='Specify a format for this branch. Current'
1019
' formats are: default, knit, metaweave and'
1020
' weave. Default is knit; metaweave and'
1021
' weave are deprecated',
1022
type=get_format_type),
1023
]
1024
def run(self, location=None, format=None):
1273
Option('create-prefix',
1274
help='Create the path leading up to the branch '
1275
'if it does not already exist.'),
1276
RegistryOption('format',
1277
help='Specify a format for this branch. '
1278
'See "help formats".',
1279
registry=bzrdir.format_registry,
1280
converter=bzrdir.format_registry.make_bzrdir,
1281
value_switches=True,
1282
title="Branch Format",
1283
),
1284
Option('append-revisions-only',
1285
help='Never change revnos or the existing log.'
1286
' Append revisions to it only.')
1287
]
1288
def run(self, location=None, format=None, append_revisions_only=False,
1289
create_prefix=False):
1025
1290
if format is None:
1026
format = get_format_type('default')
1291
format = bzrdir.format_registry.make_bzrdir('default')
1027
1292
if location is None:
1028
1293
location = u'.'
1029
1294
1034
1299
# Just using os.mkdir, since I don't
1035
1300
# believe that we want to create a bunch of
1036
1301
# locations if the user supplies an extended path
1037
# TODO: create-prefix
1038
try:
1039
to_transport.mkdir('.')
1040
except errors.FileExists:
1041
pass
1042
1043
try:
1044
existing_bzrdir = bzrdir.BzrDir.open(location)
1045
except NotBranchError:
1302
try:
1303
to_transport.ensure_base()
1304
except errors.NoSuchFile:
1305
if not create_prefix:
1306
raise errors.BzrCommandError("Parent directory of %s"
1307
" does not exist."
1308
"\nYou may supply --create-prefix to create all"
1309
" leading parent directories."
1310
% location)
1311
_create_prefix(to_transport)
1312
1313
try:
1314
existing_bzrdir = bzrdir.BzrDir.open_from_transport(to_transport)
1315
except errors.NotBranchError:
1046
1316
# really a NotBzrDir error...
1047
bzrdir.BzrDir.create_branch_convenience(location, format=format)
1317
create_branch = bzrdir.BzrDir.create_branch_convenience
1318
branch = create_branch(to_transport.base, format=format,
1319
possible_transports=[to_transport])
1048
1320
else:
1321
from bzrlib.transport.local import LocalTransport
1049
1322
if existing_bzrdir.has_branch():
1050
1323
if (isinstance(to_transport, LocalTransport)
1051
1324
and not existing_bzrdir.has_workingtree()):
1052
1325
raise errors.BranchExistsWithoutWorkingTree(location)
1053
1326
raise errors.AlreadyBranchError(location)
1054
1327
else:
1055
existing_bzrdir.create_branch()
1328
branch = existing_bzrdir.create_branch()
1056
1329
existing_bzrdir.create_workingtree()
1330
if append_revisions_only:
1331
try:
1332
branch.set_append_revisions_only(True)
1333
except errors.UpgradeRequired:
1334
raise errors.BzrCommandError('This branch format cannot be set'
1335
' to append-revisions-only. Try --experimental-branch6')
1057
1336
1058
1337
1059
1338
class cmd_init_repository(Command):
1060
1339
"""Create a shared repository to hold branches.
1061
1340
1062
New branches created under the repository directory will store their revisions
1063
in the repository, not in the branch directory, if the branch format supports
1064
shared storage.
1341
New branches created under the repository directory will store their
1342
revisions in the repository, not in the branch directory.
1343
1344
If the --no-trees option is used then the branches in the repository
1345
will not have working trees by default.
1065
1346
1066
1347
example:
1067
bzr init-repo repo
1348
bzr init-repo --no-trees repo
1068
1349
bzr init repo/trunk
1069
1350
bzr checkout --lightweight repo/trunk trunk-checkout
1070
1351
cd trunk-checkout
1071
1352
(add files here)
1353
1354
See 'bzr help repositories' for more information.
1072
1355
"""
1073
takes_args = ["location"]
1074
takes_options = [Option('format',
1075
help='Specify a format for this repository.'
1076
' Current formats are: default, knit,'
1077
' metaweave and weave. Default is knit;'
1078
' metaweave and weave are deprecated',
1079
type=get_format_type),
1080
Option('trees',
1081
help='Allows branches in repository to have'
1082
' a working tree')]
1356
1357
_see_also = ['init', 'branch', 'checkout']
1358
takes_args = ["location"]
1359
takes_options = [RegistryOption('format',
1360
help='Specify a format for this repository. See'
1361
' "bzr help formats" for details.',
1362
registry=bzrdir.format_registry,
1363
converter=bzrdir.format_registry.make_bzrdir,
1364
value_switches=True, title='Repository format'),
1365
Option('no-trees',
1366
help='Branches in the repository will default to'
1367
' not having a working tree.'),
1368
]
1083
1369
aliases = ["init-repo"]
1084
def run(self, location, format=None, trees=False):
1370
1371
def run(self, location, format=None, no_trees=False):
1085
1372
if format is None:
1086
format = get_format_type('default')
1373
format = bzrdir.format_registry.make_bzrdir('default')
1087
1374
1088
1375
if location is None:
1089
1376
location = '.'
1090
1377
1091
1378
to_transport = transport.get_transport(location)
1092
try:
1093
to_transport.mkdir('.')
1094
except errors.FileExists:
1095
pass
1379
to_transport.ensure_base()
1096
1380
1097
1381
newdir = format.initialize_on_transport(to_transport)
1098
1382
repo = newdir.create_repository(shared=True)
1099
repo.set_make_working_trees(trees)
1383
repo.set_make_working_trees(not no_trees)
1100
1384
1101
1385
1102
1386
class cmd_diff(Command):
1115
1399
Difference between the working tree and revision 1
1116
1400
bzr diff -r1..2
1117
1401
Difference between revision 2 and revision 1
1118
bzr diff --diff-prefix old/:new/
1402
bzr diff --prefix old/:new/
1119
1403
Same as 'bzr diff' but prefix paths with old/ and new/
1120
1404
bzr diff bzr.mine bzr.dev
1121
1405
Show the differences between the two working trees
1132
1416
# deleted files.
1133
1417
1134
1418
# TODO: This probably handles non-Unix newlines poorly.
1135
1419
1420
_see_also = ['status']
1136
1421
takes_args = ['file*']
1137
takes_options = ['revision', 'diff-options', 'prefix']
1422
takes_options = [
1423
Option('diff-options', type=str,
1424
help='Pass these options to the external diff program.'),
1425
Option('prefix', type=str,
1426
short_name='p',
1427
help='Set prefixes to added to old and new filenames, as '
1428
'two values separated by a colon. (eg "old/:new/").'),
1429
'revision',
1430
]
1138
1431
aliases = ['di', 'dif']
1139
1432
encoding_type = 'exact'
1140
1433
1150
1443
elif prefix == '1':
1151
1444
old_label = 'old/'
1152
1445
new_label = 'new/'
1153
else:
1154
if not ':' in prefix:
1155
raise BzrError("--diff-prefix expects two values separated by a colon")
1446
elif ':' in prefix:
1156
1447
old_label, new_label = prefix.split(":")
1157
1448
else:
1449
raise errors.BzrCommandError(
1450
'--prefix expects two values separated by a colon'
1451
' (eg "old/:new/")')
1452
1453
if revision and len(revision) > 2:
1454
raise errors.BzrCommandError('bzr diff --revision takes exactly'
1455
' one or two revision specifiers')
1456
1158
1457
try:
1159
1458
tree1, file_list = internal_tree_files(file_list)
1160
1459
tree2 = None
1161
1460
b = None
1162
1461
b2 = None
1163
except FileInWrongBranch:
1462
except errors.FileInWrongBranch:
1164
1463
if len(file_list) != 2:
1165
raise BzrCommandError("Files are in different branches")
1464
raise errors.BzrCommandError("Files are in different branches")
1166
1465
1167
1466
tree1, file1 = WorkingTree.open_containing(file_list[0])
1168
1467
tree2, file2 = WorkingTree.open_containing(file_list[1])
1169
1468
if file1 != "" or file2 != "":
1170
1469
# FIXME diff those two files. rbc 20051123
1171
raise BzrCommandError("Files are in different branches")
1470
raise errors.BzrCommandError("Files are in different branches")
1172
1471
file_list = None
1173
except NotBranchError:
1174
# Don't raise an error when bzr diff is called from
1175
# outside a working tree.
1472
except errors.NotBranchError:
1176
1473
if (revision is not None and len(revision) == 2
1177
1474
and not revision[0].needs_branch()
1178
1475
and not revision[1].needs_branch()):
1476
# If both revision specs include a branch, we can
1477
# diff them without needing a local working tree
1179
1478
tree1, tree2 = None, None
1180
1479
else:
1181
1480
raise
1182
if revision is not None:
1183
if tree2 is not None:
1184
raise BzrCommandError("Can't specify -r with two branches")
1185
if (len(revision) == 1) or (revision[1].spec is None):
1186
return diff_cmd_helper(tree1, file_list, diff_options,
1187
revision[0],
1188
old_label=old_label, new_label=new_label)
1189
elif len(revision) == 2:
1190
return diff_cmd_helper(tree1, file_list, diff_options,
1191
revision[0], revision[1],
1192
old_label=old_label, new_label=new_label)
1193
else:
1194
raise BzrCommandError('bzr diff --revision takes exactly one or two revision identifiers')
1195
else:
1196
if tree2 is not None:
1197
return show_diff_trees(tree1, tree2, sys.stdout,
1198
specific_files=file_list,
1199
external_diff_options=diff_options,
1200
old_label=old_label, new_label=new_label)
1201
else:
1202
return diff_cmd_helper(tree1, file_list, diff_options,
1203
old_label=old_label, new_label=new_label)
1481
1482
if tree2 is not None:
1483
if revision is not None:
1484
# FIXME: but there should be a clean way to diff between
1485
# non-default versions of two trees, it's not hard to do
1486
# internally...
1487
raise errors.BzrCommandError(
1488
"Sorry, diffing arbitrary revisions across branches "
1489
"is not implemented yet")
1490
return show_diff_trees(tree1, tree2, sys.stdout,
1491
specific_files=file_list,
1492
external_diff_options=diff_options,
1493
old_label=old_label, new_label=new_label)
1494
1495
return diff_cmd_helper(tree1, file_list, diff_options,
1496
revision_specs=revision,
1497
old_label=old_label, new_label=new_label)
1204
1498
1205
1499
1206
1500
class cmd_deleted(Command):
1212
1506
# directories with readdir, rather than stating each one. Same
1213
1507
# level of effort but possibly much less IO. (Or possibly not,
1214
1508
# if the directories are very large...)
1509
_see_also = ['status', 'ls']
1215
1510
takes_options = ['show-ids']
1216
1511
1217
1512
@display_command
1218
1513
def run(self, show_ids=False):
1219
1514
tree = WorkingTree.open_containing(u'.')[0]
1220
old = tree.basis_tree()
1221
for path, ie in old.inventory.iter_entries():
1222
if not tree.has_id(ie.file_id):
1223
self.outf.write(path)
1224
if show_ids:
1225
self.outf.write(' ')
1226
self.outf.write(ie.file_id)
1227
self.outf.write('\n')
1515
tree.lock_read()
1516
try:
1517
old = tree.basis_tree()
1518
old.lock_read()
1519
try:
1520
for path, ie in old.inventory.iter_entries():
1521
if not tree.has_id(ie.file_id):
1522
self.outf.write(path)
1523
if show_ids:
1524
self.outf.write(' ')
1525
self.outf.write(ie.file_id)
1526
self.outf.write('\n')
1527
finally:
1528
old.unlock()
1529
finally:
1530
tree.unlock()
1228
1531
1229
1532
1230
1533
class cmd_modified(Command):
1231
"""List files modified in working tree."""
1534
"""List files modified in working tree.
1535
"""
1536
1232
1537
hidden = True
1538
_see_also = ['status', 'ls']
1539
1233
1540
@display_command
1234
1541
def run(self):
1235
from bzrlib.delta import compare_trees
1236
1237
1542
tree = WorkingTree.open_containing(u'.')[0]
1238
td = compare_trees(tree.basis_tree(), tree)
1239
1543
td = tree.changes_from(tree.basis_tree())
1240
1544
for path, id, kind, text_modified, meta_modified in td.modified:
1241
1545
self.outf.write(path + '\n')
1242
1546
1243
1547
1244
1548
class cmd_added(Command):
1245
"""List files added in working tree."""
1549
"""List files added in working tree.
1550
"""
1551
1246
1552
hidden = True
1553
_see_also = ['status', 'ls']
1554
1247
1555
@display_command
1248
1556
def run(self):
1249
1557
wt = WorkingTree.open_containing(u'.')[0]
1250
basis_inv = wt.basis_tree().inventory
1251
inv = wt.inventory
1252
for file_id in inv:
1253
if file_id in basis_inv:
1254
continue
1255
path = inv.id2path(file_id)
1256
if not os.access(osutils.abspath(path), os.F_OK):
1257
continue
1258
self.outf.write(path + '\n')
1558
wt.lock_read()
1559
try:
1560
basis = wt.basis_tree()
1561
basis.lock_read()
1562
try:
1563
basis_inv = basis.inventory
1564
inv = wt.inventory
1565
for file_id in inv:
1566
if file_id in basis_inv:
1567
continue
1568
if inv.is_root(file_id) and len(basis_inv) == 0:
1569
continue
1570
path = inv.id2path(file_id)
1571
if not os.access(osutils.abspath(path), os.F_OK):
1572
continue
1573
self.outf.write(path + '\n')
1574
finally:
1575
basis.unlock()
1576
finally:
1577
wt.unlock()
1259
1578
1260
1579
1261
1580
class cmd_root(Command):
1263
1582
1264
1583
The root is the nearest enclosing directory with a .bzr control
1265
1584
directory."""
1585
1266
1586
takes_args = ['filename?']
1267
1587
@display_command
1268
1588
def run(self, filename=None):
1271
1591
self.outf.write(tree.basedir + '\n')
1272
1592
1273
1593
1594
def _parse_limit(limitstring):
1595
try:
1596
return int(limitstring)
1597
except ValueError:
1598
msg = "The limit argument must be an integer."
1599
raise errors.BzrCommandError(msg)
1600
1601
1274
1602
class cmd_log(Command):
1275
1603
"""Show log of a branch, file, or directory.
1276
1604
1289
1617
# TODO: Make --revision support uuid: and hash: [future tag:] notation.
1290
1618
1291
1619
takes_args = ['location?']
1292
takes_options = [Option('forward',
1293
help='show from oldest to newest'),
1294
'timezone',
1295
Option('verbose',
1296
help='show files changed in each revision'),
1297
'show-ids', 'revision',
1298
'log-format',
1299
'line', 'long',
1300
Option('message',
1301
help='show revisions whose message matches this regexp',
1302
type=str),
1303
'short',
1304
]
1620
takes_options = [
1621
Option('forward',
1622
help='Show from oldest to newest.'),
1623
Option('timezone',
1624
type=str,
1625
help='Display timezone as local, original, or utc.'),
1626
Option('verbose',
1627
short_name='v',
1628
help='Show files changed in each revision.'),
1629
'show-ids',
1630
'revision',
1631
'log-format',
1632
Option('message',
1633
short_name='m',
1634
help='Show revisions whose message matches this '
1635
'regular expression.',
1636
type=str),
1637
Option('limit',
1638
help='Limit the output to the first N revisions.',
1639
argname='N',
1640
type=_parse_limit),
1641
]
1305
1642
encoding_type = 'replace'
1306
1643
1307
1644
@display_command
1312
1649
revision=None,
1313
1650
log_format=None,
1314
1651
message=None,
1315
long=False,
1316
short=False,
1317
line=False):
1318
from bzrlib.log import log_formatter, show_log
1652
limit=None):
1653
from bzrlib.log import show_log
1319
1654
assert message is None or isinstance(message, basestring), \
1320
1655
"invalid message argument %r" % message
1321
1656
direction = (forward and 'forward') or 'reverse'
1325
1660
if location:
1326
1661
# find the file id to log:
1327
1662
1328
dir, fp = bzrdir.BzrDir.open_containing(location)
1329
b = dir.open_branch()
1663
tree, b, fp = bzrdir.BzrDir.open_containing_tree_or_branch(
1664
location)
1330
1665
if fp != '':
1331
try:
1332
# might be a tree:
1333
inv = dir.open_workingtree().inventory
1334
except (errors.NotBranchError, errors.NotLocalUrl):
1335
# either no tree, or is remote.
1336
inv = b.basis_tree().inventory
1337
file_id = inv.path2id(fp)
1666
if tree is None:
1667
tree = b.basis_tree()
1668
file_id = tree.path2id(fp)
1669
if file_id is None:
1670
raise errors.BzrCommandError(
1671
"Path does not have any revision history: %s" %
1672
location)
1338
1673
else:
1339
1674
# local dir only
1340
1675
# FIXME ? log the current subdir only RBC 20060203
1341
dir, relpath = bzrdir.BzrDir.open_containing('.')
1676
if revision is not None \
1677
and len(revision) > 0 and revision[0].get_branch():
1678
location = revision[0].get_branch()
1679
else:
1680
location = '.'
1681
dir, relpath = bzrdir.BzrDir.open_containing(location)
1342
1682
b = dir.open_branch()
1343
1683
1344
if revision is None:
1345
rev1 = None
1346
rev2 = None
1347
elif len(revision) == 1:
1348
rev1 = rev2 = revision[0].in_history(b).revno
1349
elif len(revision) == 2:
1350
if revision[0].spec is None:
1351
# missing begin-range means first revision
1352
rev1 = 1
1353
else:
1354
rev1 = revision[0].in_history(b).revno
1355
1356
if revision[1].spec is None:
1357
# missing end-range means last known revision
1358
rev2 = b.revno()
1359
else:
1360
rev2 = revision[1].in_history(b).revno
1361
else:
1362
raise BzrCommandError('bzr log --revision takes one or two values.')
1363
1364
# By this point, the revision numbers are converted to the +ve
1365
# form if they were supplied in the -ve form, so we can do
1366
# this comparison in relative safety
1367
if rev1 > rev2:
1368
(rev2, rev1) = (rev1, rev2)
1369
1370
if (log_format == None):
1371
default = b.get_config().log_format()
1372
log_format = get_log_format(long=long, short=short, line=line,
1373
default=default)
1374
lf = log_formatter(log_format,
1375
show_ids=show_ids,
1376
to_file=self.outf,
1377
show_timezone=timezone)
1378
1379
show_log(b,
1380
lf,
1381
file_id,
1382
verbose=verbose,
1383
direction=direction,
1384
start_revision=rev1,
1385
end_revision=rev2,
1386
search=message)
1684
b.lock_read()
1685
try:
1686
if revision is None:
1687
rev1 = None
1688
rev2 = None
1689
elif len(revision) == 1:
1690
rev1 = rev2 = revision[0].in_history(b)
1691
elif len(revision) == 2:
1692
if revision[1].get_branch() != revision[0].get_branch():
1693
# b is taken from revision[0].get_branch(), and
1694
# show_log will use its revision_history. Having
1695
# different branches will lead to weird behaviors.
1696
raise errors.BzrCommandError(
1697
"Log doesn't accept two revisions in different"
1698
" branches.")
1699
rev1 = revision[0].in_history(b)
1700
rev2 = revision[1].in_history(b)
1701
else:
1702
raise errors.BzrCommandError(
1703
'bzr log --revision takes one or two values.')
1704
1705
if log_format is None:
1706
log_format = log.log_formatter_registry.get_default(b)
1707
1708
lf = log_format(show_ids=show_ids, to_file=self.outf,
1709
show_timezone=timezone)
1710
1711
show_log(b,
1712
lf,
1713
file_id,
1714
verbose=verbose,
1715
direction=direction,
1716
start_revision=rev1,
1717
end_revision=rev2,
1718
search=message,
1719
limit=limit)
1720
finally:
1721
b.unlock()
1387
1722
1388
1723
1389
1724
def get_log_format(long=False, short=False, line=False, default='long'):
1410
1745
def run(self, filename):
1411
1746
tree, relpath = WorkingTree.open_containing(filename)
1412
1747
b = tree.branch
1413
inv = tree.read_working_inventory()
1414
file_id = inv.path2id(relpath)
1748
file_id = tree.path2id(relpath)
1415
1749
for revno, revision_id, what in log.find_touching_revisions(b, file_id):
1416
1750
self.outf.write("%6d %s\n" % (revno, what))
1417
1751
1419
1753
class cmd_ls(Command):
1420
1754
"""List files in a tree.
1421
1755
"""
1756
1757
_see_also = ['status', 'cat']
1758
takes_args = ['path?']
1422
1759
# TODO: Take a revision or remote path and list that tree instead.
1423
hidden = True
1424
takes_options = ['verbose', 'revision',
1425
Option('non-recursive',
1426
help='don\'t recurse into sub-directories'),
1427
Option('from-root',
1428
help='Print all paths from the root of the branch.'),
1429
Option('unknown', help='Print unknown files'),
1430
Option('versioned', help='Print versioned files'),
1431
Option('ignored', help='Print ignored files'),
1432
1433
Option('null', help='Null separate the files'),
1434
]
1760
takes_options = [
1761
'verbose',
1762
'revision',
1763
Option('non-recursive',
1764
help='Don\'t recurse into subdirectories.'),
1765
Option('from-root',
1766
help='Print paths relative to the root of the branch.'),
1767
Option('unknown', help='Print unknown files.'),
1768
Option('versioned', help='Print versioned files.'),
1769
Option('ignored', help='Print ignored files.'),
1770
Option('null',
1771
help='Write an ascii NUL (\\0) separator '
1772
'between files rather than a newline.'),
1773
Option('kind',
1774
help='List entries of a particular kind: file, directory, symlink.',
1775
type=unicode),
1776
'show-ids',
1777
]
1435
1778
@display_command
1436
def run(self, revision=None, verbose=False,
1779
def run(self, revision=None, verbose=False,
1437
1780
non_recursive=False, from_root=False,
1438
1781
unknown=False, versioned=False, ignored=False,
1439
null=False):
1782
null=False, kind=None, show_ids=False, path=None):
1783
1784
if kind and kind not in ('file', 'directory', 'symlink'):
1785
raise errors.BzrCommandError('invalid kind specified')
1440
1786
1441
1787
if verbose and null:
1442
raise BzrCommandError('Cannot set both --verbose and --null')
1788
raise errors.BzrCommandError('Cannot set both --verbose and --null')
1443
1789
all = not (unknown or versioned or ignored)
1444
1790
1445
1791
selection = {'I':ignored, '?':unknown, 'V':versioned}
1446
1792
1447
tree, relpath = WorkingTree.open_containing(u'.')
1793
if path is None:
1794
fs_path = '.'
1795
prefix = ''
1796
else:
1797
if from_root:
1798
raise errors.BzrCommandError('cannot specify both --from-root'
1799
' and PATH')
1800
fs_path = path
1801
prefix = path
1802
tree, branch, relpath = bzrdir.BzrDir.open_containing_tree_or_branch(
1803
fs_path)
1448
1804
if from_root:
1449
1805
relpath = u''
1450
1806
elif relpath:
1451
1807
relpath += '/'
1452
1808
if revision is not None:
1453
tree = tree.branch.repository.revision_tree(
1454
revision[0].in_history(tree.branch).rev_id)
1809
tree = branch.repository.revision_tree(
1810
revision[0].in_history(branch).rev_id)
1811
elif tree is None:
1812
tree = branch.basis_tree()
1455
1813
1456
for fp, fc, kind, fid, entry in tree.list_files():
1457
if fp.startswith(relpath):
1458
fp = fp[len(relpath):]
1459
if non_recursive and '/' in fp:
1460
continue
1461
if not all and not selection[fc]:
1462
continue
1463
if verbose:
1464
kindch = entry.kind_character()
1465
self.outf.write('%-8s %s%s\n' % (fc, fp, kindch))
1466
elif null:
1467
self.outf.write(fp + '\0')
1468
self.outf.flush()
1469
else:
1470
self.outf.write(fp + '\n')
1814
tree.lock_read()
1815
try:
1816
for fp, fc, fkind, fid, entry in tree.list_files(include_root=False):
1817
if fp.startswith(relpath):
1818
fp = osutils.pathjoin(prefix, fp[len(relpath):])
1819
if non_recursive and '/' in fp:
1820
continue
1821
if not all and not selection[fc]:
1822
continue
1823
if kind is not None and fkind != kind:
1824
continue
1825
if verbose:
1826
kindch = entry.kind_character()
1827
outstring = '%-8s %s%s' % (fc, fp, kindch)
1828
if show_ids and fid is not None:
1829
outstring = "%-50s %s" % (outstring, fid)
1830
self.outf.write(outstring + '\n')
1831
elif null:
1832
self.outf.write(fp + '\0')
1833
if show_ids:
1834
if fid is not None:
1835
self.outf.write(fid)
1836
self.outf.write('\0')
1837
self.outf.flush()
1838
else:
1839
if fid is not None:
1840
my_id = fid
1841
else:
1842
my_id = ''
1843
if show_ids:
1844
self.outf.write('%-50s %s\n' % (fp, my_id))
1845
else:
1846
self.outf.write(fp + '\n')
1847
finally:
1848
tree.unlock()
1471
1849
1472
1850
1473
1851
class cmd_unknowns(Command):
1474
"""List unknown files."""
1852
"""List unknown files.
1853
"""
1854
1855
hidden = True
1856
_see_also = ['ls']
1857
1475
1858
@display_command
1476
1859
def run(self):
1477
1860
for f in WorkingTree.open_containing(u'.')[0].unknowns():
1479
1862
1480
1863
1481
1864
class cmd_ignore(Command):
1482
"""Ignore a command or pattern.
1865
"""Ignore specified files or patterns.
1483
1866
1484
1867
To remove patterns from the ignore list, edit the .bzrignore file.
1485
1868
1486
If the pattern contains a slash, it is compared to the whole path
1487
from the branch root. Otherwise, it is compared to only the last
1488
component of the path. To match a file only in the root directory,
1489
prepend './'.
1490
1491
Ignore patterns are case-insensitive on case-insensitive systems.
1492
1493
Note: wildcards must be quoted from the shell on Unix.
1869
Trailing slashes on patterns are ignored.
1870
If the pattern contains a slash or is a regular expression, it is compared
1871
to the whole path from the branch root. Otherwise, it is compared to only
1872
the last component of the path. To match a file only in the root
1873
directory, prepend './'.
1874
1875
Ignore patterns specifying absolute paths are not allowed.
1876
1877
Ignore patterns may include globbing wildcards such as:
1878
? - Matches any single character except '/'
1879
* - Matches 0 or more characters except '/'
1880
/**/ - Matches 0 or more directories in a path
1881
[a-z] - Matches a single character from within a group of characters
1882
1883
Ignore patterns may also be Python regular expressions.
1884
Regular expression ignore patterns are identified by a 'RE:' prefix
1885
followed by the regular expression. Regular expression ignore patterns
1886
may not include named or numbered groups.
1887
1888
Note: ignore patterns containing shell wildcards must be quoted from
1889
the shell on Unix.
1494
1890
1495
1891
examples:
1496
1892
bzr ignore ./Makefile
1497
1893
bzr ignore '*.class'
1894
bzr ignore 'lib/**/*.o'
1895
bzr ignore 'RE:lib/.*\.o'
1498
1896
"""
1499
# TODO: Complain if the filename is absolute
1500
takes_args = ['name_pattern?']
1897
1898
_see_also = ['status', 'ignored']
1899
takes_args = ['name_pattern*']
1501
1900
takes_options = [
1502
Option('old-default-rules',
1503
help='Out the ignore rules bzr < 0.9 always used.')
1504
]
1901
Option('old-default-rules',
1902
help='Write out the ignore rules bzr < 0.9 always used.')
1903
]
1505
1904
1506
def run(self, name_pattern=None, old_default_rules=None):
1905
def run(self, name_pattern_list=None, old_default_rules=None):
1507
1906
from bzrlib.atomicfile import AtomicFile
1508
1907
if old_default_rules is not None:
1509
1908
# dump the rules and exit
1510
1909
for pattern in ignores.OLD_DEFAULTS:
1511
1910
print pattern
1512
1911
return
1513
if name_pattern is None:
1514
raise BzrCommandError("ignore requires a NAME_PATTERN")
1912
if not name_pattern_list:
1913
raise errors.BzrCommandError("ignore requires at least one "
1914
"NAME_PATTERN or --old-default-rules")
1915
name_pattern_list = [globbing.normalize_pattern(p)
1916
for p in name_pattern_list]
1917
for name_pattern in name_pattern_list:
1918
if (name_pattern[0] == '/' or
1919
(len(name_pattern) > 1 and name_pattern[1] == ':')):
1920
raise errors.BzrCommandError(
1921
"NAME_PATTERN should not be an absolute path")
1515
1922
tree, relpath = WorkingTree.open_containing(u'.')
1516
1923
ifn = tree.abspath('.bzrignore')
1517
1924
if os.path.exists(ifn):
1528
1935
1529
1936
if igns and igns[-1] != '\n':
1530
1937
igns += '\n'
1531
igns += name_pattern + '\n'
1938
for name_pattern in name_pattern_list:
1939
igns += name_pattern + '\n'
1532
1940
1533
f = AtomicFile(ifn, 'wt')
1941
f = AtomicFile(ifn, 'wb')
1534
1942
try:
1535
1943
f.write(igns.encode('utf-8'))
1536
1944
f.commit()
1537
1945
finally:
1538
1946
f.close()
1539
1947
1540
inv = tree.inventory
1541
if inv.path2id('.bzrignore'):
1542
mutter('.bzrignore is already versioned')
1543
else:
1544
mutter('need to make new .bzrignore file versioned')
1948
if not tree.path2id('.bzrignore'):
1545
1949
tree.add(['.bzrignore'])
1546
1950
1547
1951
1548
1952
class cmd_ignored(Command):
1549
1953
"""List ignored files and the patterns that matched them.
1954
"""
1550
1955
1551
See also: bzr ignore"""
1956
_see_also = ['ignore']
1552
1957
@display_command
1553
1958
def run(self):
1554
1959
tree = WorkingTree.open_containing(u'.')[0]
1555
for path, file_class, kind, file_id, entry in tree.list_files():
1556
if file_class != 'I':
1557
continue
1558
## XXX: Slightly inefficient since this was already calculated
1559
pat = tree.is_ignored(path)
1560
print '%-50s %s' % (path, pat)
1960
tree.lock_read()
1961
try:
1962
for path, file_class, kind, file_id, entry in tree.list_files():
1963
if file_class != 'I':
1964
continue
1965
## XXX: Slightly inefficient since this was already calculated
1966
pat = tree.is_ignored(path)
1967
print '%-50s %s' % (path, pat)
1968
finally:
1969
tree.unlock()
1561
1970
1562
1971
1563
1972
class cmd_lookup_revision(Command):
1574
1983
try:
1575
1984
revno = int(revno)
1576
1985
except ValueError:
1577
raise BzrCommandError("not a valid revision-number: %r" % revno)
1986
raise errors.BzrCommandError("not a valid revision-number: %r" % revno)
1578
1987
1579
1988
print WorkingTree.open_containing(u'.')[0].branch.get_rev_id(revno)
1580
1989
1581
1990
1582
1991
class cmd_export(Command):
1583
"""Export past revision to destination directory.
1992
"""Export current or past revision to a destination directory or archive.
1584
1993
1585
1994
If no revision is specified this exports the last committed revision.
1586
1995
1588
1997
given, try to find the format with the extension. If no extension
1589
1998
is found exports to a directory (equivalent to --format=dir).
1590
1999
1591
Root may be the top directory for tar, tgz and tbz2 formats. If none
1592
is given, the top directory will be the root name of the file.
1593
1594
Note: export of tree with non-ascii filenames to zip is not supported.
2000
If root is supplied, it will be used as the root directory inside
2001
container formats (tar, zip, etc). If it is not supplied it will default
2002
to the exported filename. The root option has no effect for 'dir' format.
2003
2004
If branch is omitted then the branch containing the current working
2005
directory will be used.
2006
2007
Note: Export of tree with non-ASCII filenames to zip is not supported.
1595
2008
1596
2009
Supported formats Autodetected by extension
1597
2010
----------------- -------------------------
1601
2014
tgz .tar.gz, .tgz
1602
2015
zip .zip
1603
2016
"""
1604
takes_args = ['dest']
1605
takes_options = ['revision', 'format', 'root']
1606
def run(self, dest, revision=None, format=None, root=None):
2017
takes_args = ['dest', 'branch?']
2018
takes_options = [
2019
Option('format',
2020
help="Type of file to export to.",
2021
type=unicode),
2022
'revision',
2023
Option('root',
2024
type=str,
2025
help="Name of the root directory inside the exported file."),
2026
]
2027
def run(self, dest, branch=None, revision=None, format=None, root=None):
1607
2028
from bzrlib.export import export
1608
tree = WorkingTree.open_containing(u'.')[0]
1609
b = tree.branch
2029
2030
if branch is None:
2031
tree = WorkingTree.open_containing(u'.')[0]
2032
b = tree.branch
2033
else:
2034
b = Branch.open(branch)
2035
1610
2036
if revision is None:
1611
2037
# should be tree.last_revision FIXME
1612
2038
rev_id = b.last_revision()
1613
2039
else:
1614
2040
if len(revision) != 1:
1615
raise BzrError('bzr export --revision takes exactly 1 argument')
2041
raise errors.BzrCommandError('bzr export --revision takes exactly 1 argument')
1616
2042
rev_id = revision[0].in_history(b).rev_id
1617
2043
t = b.repository.revision_tree(rev_id)
1618
2044
try:
1619
2045
export(t, dest, format, root)
1620
2046
except errors.NoSuchExportFormat, e:
1621
raise BzrCommandError('Unsupported export format: %s' % e.format)
2047
raise errors.BzrCommandError('Unsupported export format: %s' % e.format)
1622
2048
1623
2049
1624
2050
class cmd_cat(Command):
1625
"""Write a file's text from a previous revision."""
1626
1627
takes_options = ['revision']
2051
"""Write the contents of a file as of a given revision to standard output.
2052
2053
If no revision is nominated, the last revision is used.
2054
2055
Note: Take care to redirect standard output when using this command on a
2056
binary file.
2057
"""
2058
2059
_see_also = ['ls']
2060
takes_options = [
2061
Option('name-from-revision', help='The path name in the old tree.'),
2062
'revision',
2063
]
1628
2064
takes_args = ['filename']
2065
encoding_type = 'exact'
1629
2066
1630
2067
@display_command
1631
def run(self, filename, revision=None):
2068
def run(self, filename, revision=None, name_from_revision=False):
1632
2069
if revision is not None and len(revision) != 1:
1633
raise BzrCommandError("bzr cat --revision takes exactly one number")
2070
raise errors.BzrCommandError("bzr cat --revision takes exactly"
2071
" one number")
2072
1634
2073
tree = None
1635
2074
try:
1636
tree, relpath = WorkingTree.open_containing(filename)
1637
b = tree.branch
1638
except NotBranchError:
2075
tree, b, relpath = \
2076
bzrdir.BzrDir.open_containing_tree_or_branch(filename)
2077
except errors.NotBranchError:
1639
2078
pass
1640
2079
2080
if revision is not None and revision[0].get_branch() is not None:
2081
b = Branch.open(revision[0].get_branch())
1641
2082
if tree is None:
1642
b, relpath = Branch.open_containing(filename)
2083
tree = b.basis_tree()
1643
2084
if revision is None:
1644
2085
revision_id = b.last_revision()
1645
2086
else:
1646
2087
revision_id = revision[0].in_history(b).rev_id
1647
b.print_file(relpath, revision_id)
2088
2089
cur_file_id = tree.path2id(relpath)
2090
rev_tree = b.repository.revision_tree(revision_id)
2091
old_file_id = rev_tree.path2id(relpath)
2092
2093
if name_from_revision:
2094
if old_file_id is None:
2095
raise errors.BzrCommandError("%r is not present in revision %s"
2096
% (filename, revision_id))
2097
else:
2098
rev_tree.print_file(old_file_id)
2099
elif cur_file_id is not None:
2100
rev_tree.print_file(cur_file_id)
2101
elif old_file_id is not None:
2102
rev_tree.print_file(old_file_id)
2103
else:
2104
raise errors.BzrCommandError("%r is not present in revision %s" %
2105
(filename, revision_id))
1648
2106
1649
2107
1650
2108
class cmd_local_time_offset(Command):
1666
2124
within it is committed.
1667
2125
1668
2126
A selected-file commit may fail in some cases where the committed
1669
tree would be invalid, such as trying to commit a file in a
1670
newly-added directory that is not itself committed.
2127
tree would be invalid. Consider::
2128
2129
bzr init foo
2130
mkdir foo/bar
2131
bzr add foo/bar
2132
bzr commit foo -m "committing foo"
2133
bzr mv foo/bar foo/baz
2134
mkdir foo/bar
2135
bzr add foo/bar
2136
bzr commit foo/bar -m "committing bar but not baz"
2137
2138
In the example above, the last commit will fail by design. This gives
2139
the user the opportunity to decide whether they want to commit the
2140
rename at the same time, separately first, or not at all. (As a general
2141
rule, when in doubt, Bazaar has a policy of Doing the Safe Thing.)
2142
2143
Note: A selected-file commit after a merge is not yet supported.
1671
2144
"""
1672
2145
# TODO: Run hooks on tree to-be-committed, and after commit.
1673
2146
1678
2151
1679
2152
# XXX: verbose currently does nothing
1680
2153
2154
_see_also = ['bugs', 'uncommit']
1681
2155
takes_args = ['selected*']
1682
takes_options = ['message', 'verbose',
1683
Option('unchanged',
1684
help='commit even if nothing has changed'),
1685
Option('file', type=str,
1686
argname='msgfile',
1687
help='file containing commit message'),
1688
Option('strict',
1689
help="refuse to commit if there are unknown "
1690
"files in the working tree."),
1691
Option('local',
1692
help="perform a local only commit in a bound "
1693
"branch. Such commits are not pushed to "
1694
"the master branch until a normal commit "
1695
"is performed."
1696
),
1697
]
2156
takes_options = [
2157
Option('message', type=unicode,
2158
short_name='m',
2159
help="Description of the new revision."),
2160
'verbose',
2161
Option('unchanged',
2162
help='Commit even if nothing has changed.'),
2163
Option('file', type=str,
2164
short_name='F',
2165
argname='msgfile',
2166
help='Take commit message from this file.'),
2167
Option('strict',
2168
help="Refuse to commit if there are unknown "
2169
"files in the working tree."),
2170
ListOption('fixes', type=str,
2171
help="Mark a bug as being fixed by this revision."),
2172
Option('local',
2173
help="Perform a local commit in a bound "
2174
"branch. Local commits are not pushed to "
2175
"the master branch until a normal commit "
2176
"is performed."
2177
),
2178
]
1698
2179
aliases = ['ci', 'checkin']
1699
2180
2181
def _get_bug_fix_properties(self, fixes, branch):
2182
properties = []
2183
# Configure the properties for bug fixing attributes.
2184
for fixed_bug in fixes:
2185
tokens = fixed_bug.split(':')
2186
if len(tokens) != 2:
2187
raise errors.BzrCommandError(
2188
"Invalid bug %s. Must be in the form of 'tag:id'. "
2189
"Commit refused." % fixed_bug)
2190
tag, bug_id = tokens
2191
try:
2192
bug_url = bugtracker.get_bug_url(tag, branch, bug_id)
2193
except errors.UnknownBugTrackerAbbreviation:
2194
raise errors.BzrCommandError(
2195
'Unrecognized bug %s. Commit refused.' % fixed_bug)
2196
except errors.MalformedBugIdentifier:
2197
raise errors.BzrCommandError(
2198
"Invalid bug identifier for %s. Commit refused."
2199
% fixed_bug)
2200
properties.append('%s fixed' % bug_url)
2201
return '\n'.join(properties)
2202
1700
2203
def run(self, message=None, file=None, verbose=True, selected_list=None,
1701
unchanged=False, strict=False, local=False):
2204
unchanged=False, strict=False, local=False, fixes=None):
1702
2205
from bzrlib.commit import (NullCommitReporter, ReportCommitToLog)
1703
2206
from bzrlib.errors import (PointlessCommit, ConflictsInTree,
1704
2207
StrictCommitFailed)
1705
2208
from bzrlib.msgeditor import edit_commit_message, \
1706
2209
make_commit_message_template
1707
from tempfile import TemporaryFile
1708
2210
1709
2211
# TODO: Need a blackbox test for invoking the external editor; may be
1710
2212
# slightly problematic to run this cross-platform.
1711
2213
1712
2214
# TODO: do more checks that the commit will succeed before
1713
2215
# spending the user's valuable time typing a commit message.
1714
#
1715
# TODO: if the commit *does* happen to fail, then save the commit
1716
# message to a temporary file where it can be recovered
2216
2217
properties = {}
2218
1717
2219
tree, selected_list = tree_files(selected_list)
1718
2220
if selected_list == ['']:
1719
2221
# workaround - commit of root of tree should be exactly the same
1721
2223
# selected-file merge commit is not done yet
1722
2224
selected_list = []
1723
2225
2226
bug_property = self._get_bug_fix_properties(fixes, tree.branch)
2227
if bug_property:
2228
properties['bugs'] = bug_property
2229
1724
2230
if local and not tree.branch.get_bound_location():
1725
2231
raise errors.LocalRequiresBoundBranch()
1726
if message is None and not file:
1727
template = make_commit_message_template(tree, selected_list)
1728
message = edit_commit_message(template)
1729
if message is None:
1730
raise BzrCommandError("please specify a commit message"
1731
" with either --message or --file")
1732
elif message and file:
1733
raise BzrCommandError("please specify either --message or --file")
1734
1735
if file:
1736
message = codecs.open(file, 'rt', bzrlib.user_encoding).read()
1737
1738
if message == "":
1739
raise BzrCommandError("empty commit message specified")
1740
2232
2233
def get_message(commit_obj):
2234
"""Callback to get commit message"""
2235
my_message = message
2236
if my_message is None and not file:
2237
template = make_commit_message_template(tree, selected_list)
2238
my_message = edit_commit_message(template)
2239
if my_message is None:
2240
raise errors.BzrCommandError("please specify a commit"
2241
" message with either --message or --file")
2242
elif my_message and file:
2243
raise errors.BzrCommandError(
2244
"please specify either --message or --file")
2245
if file:
2246
my_message = codecs.open(file, 'rt',
2247
bzrlib.user_encoding).read()
2248
if my_message == "":
2249
raise errors.BzrCommandError("empty commit message specified")
2250
return my_message
2251
1741
2252
if verbose:
1742
2253
reporter = ReportCommitToLog()
1743
2254
else:
1744
2255
reporter = NullCommitReporter()
1745
2256
1746
2257
try:
1747
tree.commit(message, specific_files=selected_list,
2258
tree.commit(message_callback=get_message,
2259
specific_files=selected_list,
1748
2260
allow_pointless=unchanged, strict=strict, local=local,
1749
reporter=reporter)
2261
reporter=reporter, revprops=properties)
1750
2262
except PointlessCommit:
1751
2263
# FIXME: This should really happen before the file is read in;
1752
2264
# perhaps prepare the commit; get the message; then actually commit
1753
raise BzrCommandError("no changes to commit."
1754
" use --unchanged to commit anyhow")
2265
raise errors.BzrCommandError("no changes to commit."
2266
" use --unchanged to commit anyhow")
1755
2267
except ConflictsInTree:
1756
raise BzrCommandError("Conflicts detected in working tree. "
1757
'Use "bzr conflicts" to list, "bzr resolve FILE" to resolve.')
2268
raise errors.BzrCommandError('Conflicts detected in working '
2269
'tree. Use "bzr conflicts" to list, "bzr resolve FILE" to'
2270
' resolve.')
1758
2271
except StrictCommitFailed:
1759
raise BzrCommandError("Commit refused because there are unknown "
1760
"files in the working tree.")
2272
raise errors.BzrCommandError("Commit refused because there are"
2273
" unknown files in the working tree.")
1761
2274
except errors.BoundBranchOutOfDate, e:
1762
raise BzrCommandError(str(e)
1763
+ ' Either unbind, update, or'
1764
' pass --local to commit.')
2275
raise errors.BzrCommandError(str(e) + "\n"
2276
'To commit to master branch, run update and then commit.\n'
2277
'You can also pass --local to commit to continue working '
2278
'disconnected.')
1765
2279
1766
2280
1767
2281
class cmd_check(Command):
1770
2284
This command checks various invariants about the branch storage to
1771
2285
detect data corruption or bzr bugs.
1772
2286
"""
2287
2288
_see_also = ['reconcile']
1773
2289
takes_args = ['branch?']
1774
2290
takes_options = ['verbose']
1775
2291
1783
2299
check(branch, verbose)
1784
2300
1785
2301
1786
class cmd_scan_cache(Command):
1787
hidden = True
1788
def run(self):
1789
from bzrlib.hashcache import HashCache
1790
1791
c = HashCache(u'.')
1792
c.read()
1793
c.scan()
1794
1795
print '%6d stats' % c.stat_count
1796
print '%6d in hashcache' % len(c._cache)
1797
print '%6d files removed from cache' % c.removed_count
1798
print '%6d hashes updated' % c.update_count
1799
print '%6d files changed too recently to cache' % c.danger_count
1800
1801
if c.needs_write:
1802
c.write()
1803
1804
1805
2302
class cmd_upgrade(Command):
1806
2303
"""Upgrade branch storage to current format.
1807
2304
1809
2306
this command. When the default format has changed you may also be warned
1810
2307
during other operations to upgrade.
1811
2308
"""
2309
2310
_see_also = ['check']
1812
2311
takes_args = ['url?']
1813
2312
takes_options = [
1814
Option('format',
1815
help='Upgrade to a specific format. Current formats'
1816
' are: default, knit, metaweave and weave.'
1817
' Default is knit; metaweave and weave are'
1818
' deprecated',
1819
type=get_format_type),
2313
RegistryOption('format',
2314
help='Upgrade to a specific format. See "bzr help'
2315
' formats" for details.',
2316
registry=bzrdir.format_registry,
2317
converter=bzrdir.format_registry.make_bzrdir,
2318
value_switches=True, title='Branch format'),
1820
2319
]
1821
2320
1822
1823
2321
def run(self, url='.', format=None):
1824
2322
from bzrlib.upgrade import upgrade
1825
2323
if format is None:
1826
format = get_format_type('default')
2324
format = bzrdir.format_registry.make_bzrdir('default')
1827
2325
upgrade(url, format)
1828
2326
1829
2327
1835
2333
bzr whoami 'Frank Chu <fchu@example.com>'
1836
2334
"""
1837
2335
takes_options = [ Option('email',
1838
help='display email address only'),
2336
help='Display email address only.'),
1839
2337
Option('branch',
1840
help='set identity for the current branch instead of '
1841
'globally'),
2338
help='Set identity for the current branch instead of '
2339
'globally.'),
1842
2340
]
1843
2341
takes_args = ['name?']
1844
2342
encoding_type = 'replace'
1849
2347
# use branch if we're inside one; otherwise global config
1850
2348
try:
1851
2349
c = Branch.open_containing('.')[0].get_config()
1852
except NotBranchError:
2350
except errors.NotBranchError:
1853
2351
c = config.GlobalConfig()
1854
2352
if email:
1855
2353
self.outf.write(c.user_email() + '\n')
1860
2358
# display a warning if an email address isn't included in the given name.
1861
2359
try:
1862
2360
config.extract_email_address(name)
1863
except BzrError, e:
2361
except errors.NoEmailInUsername, e:
1864
2362
warning('"%s" does not seem to contain an email address. '
1865
2363
'This is allowed, but not recommended.', name)
1866
2364
1878
2376
If unset, the tree root directory name is used as the nickname
1879
2377
To print the current nickname, execute with no argument.
1880
2378
"""
2379
2380
_see_also = ['info']
1881
2381
takes_args = ['nickname?']
1882
2382
def run(self, nickname=None):
1883
2383
branch = Branch.open_containing(u'.')[0]
1888
2388
1889
2389
@display_command
1890
2390
def printme(self, branch):
1891
print branch.nick
2391
print branch.nick
1892
2392
1893
2393
1894
2394
class cmd_selftest(Command):
1895
2395
"""Run internal test suite.
1896
2396
1897
This creates temporary test directories in the working directory,
1898
but not existing data is affected. These directories are deleted
1899
if the tests pass, or left behind to help in debugging if they
1900
fail and --keep-output is specified.
1901
1902
If arguments are given, they are regular expressions that say
1903
which tests should run.
2397
If arguments are given, they are regular expressions that say which tests
2398
should run. Tests matching any expression are run, and other tests are
2399
not run.
2400
2401
Alternatively if --first is given, matching tests are run first and then
2402
all other tests are run. This is useful if you have been working in a
2403
particular area, but want to make sure nothing else was broken.
2404
2405
If --exclude is given, tests that match that regular expression are
2406
excluded, regardless of whether they match --first or not.
2407
2408
To help catch accidential dependencies between tests, the --randomize
2409
option is useful. In most cases, the argument used is the word 'now'.
2410
Note that the seed used for the random number generator is displayed
2411
when this option is used. The seed can be explicitly passed as the
2412
argument to this option if required. This enables reproduction of the
2413
actual ordering used if and when an order sensitive problem is encountered.
2414
2415
If --list-only is given, the tests that would be run are listed. This is
2416
useful when combined with --first, --exclude and/or --randomize to
2417
understand their impact. The test harness reports "Listed nn tests in ..."
2418
instead of "Ran nn tests in ..." when list mode is enabled.
1904
2419
1905
2420
If the global option '--no-plugins' is given, plugins are not loaded
1906
2421
before running the selftests. This has two effects: features provided or
1907
2422
modified by plugins will not be tested, and tests provided by plugins will
1908
2423
not be run.
1909
2424
1910
examples:
2425
Tests that need working space on disk use a common temporary directory,
2426
typically inside $TMPDIR or /tmp.
2427
2428
examples::
1911
2429
bzr selftest ignore
2430
run only tests relating to 'ignore'
1912
2431
bzr --no-plugins selftest -v
2432
disable plugins and list tests as they're run
1913
2433
"""
1914
# TODO: --list should give a list of all available tests
1915
1916
2434
# NB: this is used from the class without creating an instance, which is
1917
2435
# why it does not have a self parameter.
1918
2436
def get_transport_type(typestring):
1928
2446
return FakeNFSServer
1929
2447
msg = "No known transport type %s. Supported types are: sftp\n" %\
1930
2448
(typestring)
1931
raise BzrCommandError(msg)
2449
raise errors.BzrCommandError(msg)
1932
2450
1933
2451
hidden = True
1934
2452
takes_args = ['testspecs*']
1935
2453
takes_options = ['verbose',
1936
Option('one', help='stop when one test fails'),
1937
Option('keep-output',
1938
help='keep output directories when tests fail'),
1939
Option('transport',
2454
Option('one',
2455
help='Stop when one test fails.',
2456
short_name='1',
2457
),
2458
Option('transport',
1940
2459
help='Use a different transport by default '
1941
2460
'throughout the test suite.',
1942
2461
type=get_transport_type),
1943
Option('benchmark', help='run the bzr bencharks.'),
2462
Option('benchmark',
2463
help='Run the benchmarks rather than selftests.'),
1944
2464
Option('lsprof-timed',
1945
help='generate lsprof output for benchmarked'
2465
help='Generate lsprof output for benchmarked'
1946
2466
' sections of code.'),
2467
Option('cache-dir', type=str,
2468
help='Cache intermediate benchmark output in this '
2469
'directory.'),
2470
Option('first',
2471
help='Run all tests, but run specified tests first.',
2472
short_name='f',
2473
),
2474
Option('list-only',
2475
help='List the tests instead of running them.'),
2476
Option('randomize', type=str, argname="SEED",
2477
help='Randomize the order of tests using the given'
2478
' seed or "now" for the current time.'),
2479
Option('exclude', type=str, argname="PATTERN",
2480
short_name='x',
2481
help='Exclude tests that match this regular'
2482
' expression.'),
1947
2483
]
2484
encoding_type = 'replace'
1948
2485
1949
2486
def run(self, testspecs_list=None, verbose=None, one=False,
1950
keep_output=False, transport=None, benchmark=None,
1951
lsprof_timed=None):
2487
transport=None, benchmark=None,
2488
lsprof_timed=None, cache_dir=None,
2489
first=False, list_only=False,
2490
randomize=None, exclude=None):
1952
2491
import bzrlib.ui
1953
2492
from bzrlib.tests import selftest
1954
2493
import bzrlib.benchmarks as benchmarks
1955
# we don't want progress meters from the tests to go to the
1956
# real output; and we don't want log messages cluttering up
1957
# the real logs.
1958
save_ui = ui.ui_factory
1959
print '%10s: %s' % ('bzr', osutils.realpath(sys.argv[0]))
1960
print '%10s: %s' % ('bzrlib', bzrlib.__path__[0])
2494
from bzrlib.benchmarks import tree_creator
2495
from bzrlib.version import show_version
2496
2497
if cache_dir is not None:
2498
tree_creator.TreeCreator.CACHE_ROOT = osutils.abspath(cache_dir)
2499
if not list_only:
2500
show_version(show_config=False, show_copyright=False)
1961
2501
print
1962
info('running tests...')
2502
if testspecs_list is not None:
2503
pattern = '|'.join(testspecs_list)
2504
else:
2505
pattern = ".*"
2506
if benchmark:
2507
test_suite_factory = benchmarks.test_suite
2508
if verbose is None:
2509
verbose = True
2510
# TODO: should possibly lock the history file...
2511
benchfile = open(".perf_history", "at", buffering=1)
2512
else:
2513
test_suite_factory = None
2514
if verbose is None:
2515
verbose = False
2516
benchfile = None
1963
2517
try:
1964
ui.ui_factory = ui.SilentUIFactory()
1965
if testspecs_list is not None:
1966
pattern = '|'.join(testspecs_list)
1967
else:
1968
pattern = ".*"
1969
if benchmark:
1970
test_suite_factory = benchmarks.test_suite
1971
if verbose is None:
1972
verbose = True
1973
else:
1974
test_suite_factory = None
1975
if verbose is None:
1976
verbose = False
1977
result = selftest(verbose=verbose,
2518
result = selftest(verbose=verbose,
1978
2519
pattern=pattern,
1979
stop_on_failure=one,
1980
keep_output=keep_output,
2520
stop_on_failure=one,
1981
2521
transport=transport,
1982
2522
test_suite_factory=test_suite_factory,
1983
lsprof_timed=lsprof_timed)
1984
if result:
1985
info('tests passed')
1986
else:
1987
info('tests failed')
1988
return int(not result)
2523
lsprof_timed=lsprof_timed,
2524
bench_history=benchfile,
2525
matching_tests_first=first,
2526
list_only=list_only,
2527
random_seed=randomize,
2528
exclude_pattern=exclude
2529
)
1989
2530
finally:
1990
ui.ui_factory = save_ui
1991
1992
1993
def _get_bzr_branch():
1994
"""If bzr is run from a branch, return Branch or None"""
1995
from os.path import dirname
1996
1997
try:
1998
branch = Branch.open(dirname(osutils.abspath(dirname(__file__))))
1999
return branch
2000
except errors.BzrError:
2001
return None
2002
2003
2004
def show_version():
2005
import bzrlib
2006
print "bzr (bazaar-ng) %s" % bzrlib.__version__
2007
# is bzrlib itself in a branch?
2008
branch = _get_bzr_branch()
2009
if branch:
2010
rh = branch.revision_history()
2011
revno = len(rh)
2012
print " bzr checkout, revision %d" % (revno,)
2013
print " nick: %s" % (branch.nick,)
2014
if rh:
2015
print " revid: %s" % (rh[-1],)
2016
print "Using python interpreter:", sys.executable
2017
import site
2018
print "Using python standard library:", os.path.dirname(site.__file__)
2019
print "Using bzrlib:",
2020
if len(bzrlib.__path__) > 1:
2021
# print repr, which is a good enough way of making it clear it's
2022
# more than one element (eg ['/foo/bar', '/foo/bzr'])
2023
print repr(bzrlib.__path__)
2024
else:
2025
print bzrlib.__path__[0]
2026
2027
print
2028
print bzrlib.__copyright__
2029
print "http://bazaar-vcs.org/"
2030
print
2031
print "bzr comes with ABSOLUTELY NO WARRANTY. bzr is free software, and"
2032
print "you may use, modify and redistribute it under the terms of the GNU"
2033
print "General Public License version 2 or later."
2531
if benchfile is not None:
2532
benchfile.close()
2533
if result:
2534
info('tests passed')
2535
else:
2536
info('tests failed')
2537
return int(not result)
2034
2538
2035
2539
2036
2540
class cmd_version(Command):
2038
2542
2039
2543
@display_command
2040
2544
def run(self):
2545
from bzrlib.version import show_version
2041
2546
show_version()
2042
2547
2043
2548
2048
2553
2049
2554
@display_command
2050
2555
def run(self):
2051
print "it sure does!"
2556
print "It sure does!"
2052
2557
2053
2558
2054
2559
class cmd_find_merge_base(Command):
2060
2565
2061
2566
@display_command
2062
2567
def run(self, branch, other):
2063
from bzrlib.revision import common_ancestor, MultipleRevisionSources
2568
from bzrlib.revision import ensure_null, MultipleRevisionSources
2064
2569
2065
2570
branch1 = Branch.open_containing(branch)[0]
2066
2571
branch2 = Branch.open_containing(other)[0]
2067
2572
2068
history_1 = branch1.revision_history()
2069
history_2 = branch2.revision_history()
2070
2071
last1 = branch1.last_revision()
2072
last2 = branch2.last_revision()
2073
2074
source = MultipleRevisionSources(branch1.repository,
2075
branch2.repository)
2076
2077
base_rev_id = common_ancestor(last1, last2, source)
2573
last1 = ensure_null(branch1.last_revision())
2574
last2 = ensure_null(branch2.last_revision())
2575
2576
graph = branch1.repository.get_graph(branch2.repository)
2577
base_rev_id = graph.find_unique_lca(last1, last2)
2078
2578
2079
2579
print 'merge base is revision %s' % base_rev_id
2080
2580
2104
2604
default, use --remember. The value will only be saved if the remote
2105
2605
location can be accessed.
2106
2606
2607
The results of the merge are placed into the destination working
2608
directory, where they can be reviewed (with bzr diff), tested, and then
2609
committed to record the result of the merge.
2610
2107
2611
Examples:
2108
2612
2109
To merge the latest revision from bzr.dev
2110
bzr merge ../bzr.dev
2613
To merge the latest revision from bzr.dev:
2614
bzr merge ../bzr.dev
2111
2615
2112
To merge changes up to and including revision 82 from bzr.dev
2113
bzr merge -r 82 ../bzr.dev
2616
To merge changes up to and including revision 82 from bzr.dev:
2617
bzr merge -r 82 ../bzr.dev
2114
2618
2115
2619
To merge the changes introduced by 82, without previous changes:
2116
bzr merge -r 81..82 ../bzr.dev
2620
bzr merge -r 81..82 ../bzr.dev
2117
2621
2118
2622
merge refuses to run if there are any uncommitted changes, unless
2119
2623
--force is given.
2120
2121
The following merge types are available:
2122
2624
"""
2625
2626
_see_also = ['update', 'remerge', 'status-flags']
2123
2627
takes_args = ['branch?']
2124
takes_options = ['revision', 'force', 'merge-type', 'reprocess', 'remember',
2125
Option('show-base', help="Show base revision text in "
2126
"conflicts")]
2127
2128
def help(self):
2129
from merge import merge_type_help
2130
from inspect import getdoc
2131
return getdoc(self) + '\n' + merge_type_help()
2628
takes_options = [
2629
'revision',
2630
Option('force',
2631
help='Merge even if the destination tree has uncommitted changes.'),
2632
'merge-type',
2633
'reprocess',
2634
'remember',
2635
Option('show-base', help="Show base revision text in "
2636
"conflicts."),
2637
Option('uncommitted', help='Apply uncommitted changes'
2638
' from a working copy, instead of branch changes.'),
2639
Option('pull', help='If the destination is already'
2640
' completely merged into the source, pull from the'
2641
' source rather than merging. When this happens,'
2642
' you do not need to commit the result.'),
2643
Option('directory',
2644
help='Branch to merge into, '
2645
'rather than the one containing the working directory.',
2646
short_name='d',
2647
type=unicode,
2648
),
2649
]
2132
2650
2133
2651
def run(self, branch=None, revision=None, force=False, merge_type=None,
2134
show_base=False, reprocess=False, remember=False):
2652
show_base=False, reprocess=False, remember=False,
2653
uncommitted=False, pull=False,
2654
directory=None,
2655
):
2656
from bzrlib.tag import _merge_tags_if_possible
2135
2657
if merge_type is None:
2136
merge_type = Merge3Merger
2137
2138
tree = WorkingTree.open_containing(u'.')[0]
2139
2658
merge_type = _mod_merge.Merge3Merger
2659
2660
if directory is None: directory = u'.'
2661
# XXX: jam 20070225 WorkingTree should be locked before you extract its
2662
# inventory. Because merge is a mutating operation, it really
2663
# should be a lock_write() for the whole cmd_merge operation.
2664
# However, cmd_merge open's its own tree in _merge_helper, which
2665
# means if we lock here, the later lock_write() will always block.
2666
# Either the merge helper code should be updated to take a tree,
2667
# (What about tree.merge_from_branch?)
2668
tree = WorkingTree.open_containing(directory)[0]
2669
change_reporter = delta._ChangeReporter(
2670
unversioned_filter=tree.is_ignored)
2671
2672
other_transport = None
2673
other_revision_id = None
2674
possible_transports = []
2675
# The user may provide a bundle or branch as 'branch' We first try to
2676
# identify a bundle, if it's not, we try to preserve connection used by
2677
# the transport to access the branch.
2140
2678
if branch is not None:
2141
try:
2142
reader = bundle.read_bundle_from_url(branch)
2143
except NotABundle:
2144
pass # Continue on considering this url a Branch
2145
else:
2146
conflicts = merge_bundle(reader, tree, not force, merge_type,
2147
reprocess, show_base)
2148
if conflicts == 0:
2149
return 0
2679
url = urlutils.normalize_url(branch)
2680
url, filename = urlutils.split(url, exclude_trailing_slash=False)
2681
other_transport = transport.get_transport(url)
2682
if filename:
2683
try:
2684
read_bundle = bundle.read_mergeable_from_transport
2685
# There may be redirections but we ignore the intermediate
2686
# and final transports used
2687
mergeable, t = read_bundle(other_transport, filename)
2688
except errors.NotABundle:
2689
# Continue on considering this url a Branch but adjust the
2690
# other_transport
2691
other_transport = other_transport.clone(filename)
2150
2692
else:
2151
return 1
2693
if revision is not None:
2694
raise errors.BzrCommandError('Cannot use -r with merge'
2695
' directives or bundles')
2696
other_revision_id = mergeable.install_revisions(
2697
tree.branch.repository)
2698
revision = [RevisionSpec.from_string(
2699
'revid:' + other_revision_id)]
2700
possible_transports.append(other_transport)
2152
2701
2153
branch = self._get_remembered_parent(tree, branch, 'Merging from')
2702
if revision is None \
2703
or len(revision) < 1 or revision[0].needs_branch():
2704
branch = self._get_remembered_parent(tree, branch, 'Merging from')
2154
2705
2155
2706
if revision is None or len(revision) < 1:
2156
base = [None, None]
2157
other = [branch, -1]
2158
other_branch, path = Branch.open_containing(branch)
2707
if uncommitted:
2708
base = [branch, -1]
2709
other = [branch, None]
2710
else:
2711
base = [None, None]
2712
other = [branch, -1]
2713
other_branch, path = Branch.open_containing(branch,
2714
possible_transports)
2159
2715
else:
2716
if uncommitted:
2717
raise errors.BzrCommandError('Cannot use --uncommitted and'
2718
' --revision at the same time.')
2719
branch = revision[0].get_branch() or branch
2160
2720
if len(revision) == 1:
2161
2721
base = [None, None]
2162
other_branch, path = Branch.open_containing(branch)
2163
revno = revision[0].in_history(other_branch).revno
2164
other = [branch, revno]
2722
if other_revision_id is not None:
2723
# We merge from a bundle
2724
other_branch = None
2725
path = ""
2726
other = None
2727
else:
2728
other_branch, path = Branch.open_containing(
2729
branch, possible_transports)
2730
revno = revision[0].in_history(other_branch).revno
2731
other = [branch, revno]
2165
2732
else:
2166
2733
assert len(revision) == 2
2167
2734
if None in revision:
2168
raise BzrCommandError(
2169
"Merge doesn't permit that revision specifier.")
2170
other_branch, path = Branch.open_containing(branch)
2171
2172
base = [branch, revision[0].in_history(other_branch).revno]
2173
other = [branch, revision[1].in_history(other_branch).revno]
2174
2175
if tree.branch.get_parent() is None or remember:
2735
raise errors.BzrCommandError(
2736
"Merge doesn't permit empty revision specifier.")
2737
base_branch, path = Branch.open_containing(branch,
2738
possible_transports)
2739
branch1 = revision[1].get_branch() or branch
2740
other_branch, path1 = Branch.open_containing(
2741
branch1, possible_transports)
2742
if revision[0].get_branch() is not None:
2743
# then path was obtained from it, and is None.
2744
path = path1
2745
2746
base = [branch, revision[0].in_history(base_branch).revno]
2747
other = [branch1, revision[1].in_history(other_branch).revno]
2748
2749
# Remember where we merge from
2750
if ((tree.branch.get_parent() is None or remember) and
2751
other_branch is not None):
2176
2752
tree.branch.set_parent(other_branch.base)
2177
2753
2754
# pull tags now... it's a bit inconsistent to do it ahead of copying
2755
# the history but that's done inside the merge code
2756
if other_branch is not None:
2757
_merge_tags_if_possible(other_branch, tree.branch)
2758
2178
2759
if path != "":
2179
2760
interesting_files = [path]
2180
2761
else:
2182
2763
pb = ui.ui_factory.nested_progress_bar()
2183
2764
try:
2184
2765
try:
2185
conflict_count = merge(other, base, check_clean=(not force),
2186
merge_type=merge_type,
2187
reprocess=reprocess,
2188
show_base=show_base,
2189
pb=pb, file_list=interesting_files)
2766
conflict_count = _merge_helper(
2767
other, base, possible_transports,
2768
other_rev_id=other_revision_id,
2769
check_clean=(not force),
2770
merge_type=merge_type,
2771
reprocess=reprocess,
2772
show_base=show_base,
2773
pull=pull,
2774
this_dir=directory,
2775
pb=pb, file_list=interesting_files,
2776
change_reporter=change_reporter)
2190
2777
finally:
2191
2778
pb.finished()
2192
2779
if conflict_count != 0:
2213
2800
stored_location = tree.branch.get_parent()
2214
2801
mutter("%s", stored_location)
2215
2802
if stored_location is None:
2216
raise BzrCommandError("No location specified or remembered")
2803
raise errors.BzrCommandError("No location specified or remembered")
2217
2804
display_url = urlutils.unescape_for_display(stored_location, self.outf.encoding)
2218
2805
self.outf.write("%s remembered location %s\n" % (verb_string, display_url))
2219
2806
return stored_location
2231
2818
pending merge, and it lets you specify particular files.
2232
2819
2233
2820
Examples:
2821
2234
2822
$ bzr remerge --show-base
2235
2823
Re-do the merge of all conflicted files, and show the base text in
2236
2824
conflict regions, in addition to the usual THIS and OTHER texts.
2238
2826
$ bzr remerge --merge-type weave --reprocess foobar
2239
2827
Re-do the merge of "foobar", using the weave merge algorithm, with
2240
2828
additional processing to reduce the size of conflict regions.
2241
2242
The following merge types are available:"""
2829
"""
2243
2830
takes_args = ['file*']
2244
takes_options = ['merge-type', 'reprocess',
2245
Option('show-base', help="Show base revision text in "
2246
"conflicts")]
2247
2248
def help(self):
2249
from merge import merge_type_help
2250
from inspect import getdoc
2251
return getdoc(self) + '\n' + merge_type_help()
2831
takes_options = [
2832
'merge-type',
2833
'reprocess',
2834
Option('show-base',
2835
help="Show base revision text in conflicts."),
2836
]
2252
2837
2253
2838
def run(self, file_list=None, merge_type=None, show_base=False,
2254
2839
reprocess=False):
2255
from bzrlib.merge import merge_inner, transform_tree
2256
2840
if merge_type is None:
2257
merge_type = Merge3Merger
2841
merge_type = _mod_merge.Merge3Merger
2258
2842
tree, file_list = tree_files(file_list)
2259
2843
tree.lock_write()
2260
2844
try:
2261
pending_merges = tree.pending_merges()
2262
if len(pending_merges) != 1:
2263
raise BzrCommandError("Sorry, remerge only works after normal"
2264
" merges. Not cherrypicking or"
2265
" multi-merges.")
2845
parents = tree.get_parent_ids()
2846
if len(parents) != 2:
2847
raise errors.BzrCommandError("Sorry, remerge only works after normal"
2848
" merges. Not cherrypicking or"
2849
" multi-merges.")
2266
2850
repository = tree.branch.repository
2267
base_revision = common_ancestor(tree.branch.last_revision(),
2268
pending_merges[0], repository)
2851
graph = repository.get_graph()
2852
base_revision = graph.find_unique_lca(parents[0], parents[1])
2269
2853
base_tree = repository.revision_tree(base_revision)
2270
other_tree = repository.revision_tree(pending_merges[0])
2854
other_tree = repository.revision_tree(parents[1])
2271
2855
interesting_ids = None
2272
2856
new_conflicts = []
2273
2857
conflicts = tree.conflicts()
2276
2860
for filename in file_list:
2277
2861
file_id = tree.path2id(filename)
2278
2862
if file_id is None:
2279
raise NotVersionedError(filename)
2863
raise errors.NotVersionedError(filename)
2280
2864
interesting_ids.add(file_id)
2281
2865
if tree.kind(file_id) != "directory":
2282
2866
continue
2284
2868
for name, ie in tree.inventory.iter_entries(file_id):
2285
2869
interesting_ids.add(ie.file_id)
2286
2870
new_conflicts = conflicts.select_conflicts(tree, file_list)[0]
2287
transform_tree(tree, tree.basis_tree(), interesting_ids)
2871
else:
2872
# Remerge only supports resolving contents conflicts
2873
allowed_conflicts = ('text conflict', 'contents conflict')
2874
restore_files = [c.path for c in conflicts
2875
if c.typestring in allowed_conflicts]
2876
_mod_merge.transform_tree(tree, tree.basis_tree(), interesting_ids)
2288
2877
tree.set_conflicts(ConflictList(new_conflicts))
2289
if file_list is None:
2290
restore_files = list(tree.iter_conflicts())
2291
else:
2878
if file_list is not None:
2292
2879
restore_files = file_list
2293
2880
for filename in restore_files:
2294
2881
try:
2295
2882
restore(tree.abspath(filename))
2296
except NotConflicted:
2883
except errors.NotConflicted:
2297
2884
pass
2298
conflicts = merge_inner(tree.branch, other_tree, base_tree,
2299
this_tree=tree,
2300
interesting_ids=interesting_ids,
2301
other_rev_id=pending_merges[0],
2302
merge_type=merge_type,
2303
show_base=show_base,
2304
reprocess=reprocess)
2885
conflicts = _mod_merge.merge_inner(
2886
tree.branch, other_tree, base_tree,
2887
this_tree=tree,
2888
interesting_ids=interesting_ids,
2889
other_rev_id=parents[1],
2890
merge_type=merge_type,
2891
show_base=show_base,
2892
reprocess=reprocess)
2305
2893
finally:
2306
2894
tree.unlock()
2307
2895
if conflicts > 0:
2309
2897
else:
2310
2898
return 0
2311
2899
2900
2312
2901
class cmd_revert(Command):
2313
"""Reverse all changes since the last commit.
2314
2315
Only versioned files are affected. Specify filenames to revert only
2316
those files. By default, any files that are changed will be backed up
2317
first. Backup files have a '~' appended to their name.
2902
"""Revert files to a previous revision.
2903
2904
Giving a list of files will revert only those files. Otherwise, all files
2905
will be reverted. If the revision is not specified with '--revision', the
2906
last committed revision is used.
2907
2908
To remove only some changes, without reverting to a prior version, use
2909
merge instead. For example, "merge . --r-2..-3" will remove the changes
2910
introduced by -2, without affecting the changes introduced by -1. Or
2911
to remove certain changes on a hunk-by-hunk basis, see the Shelf plugin.
2912
2913
By default, any files that have been manually changed will be backed up
2914
first. (Files changed only by merge are not backed up.) Backup files have
2915
'.~#~' appended to their name, where # is a number.
2916
2917
When you provide files, you can use their current pathname or the pathname
2918
from the target revision. So you can use revert to "undelete" a file by
2919
name. If you name a directory, all the contents of that directory will be
2920
reverted.
2318
2921
"""
2319
takes_options = ['revision', 'no-backup']
2922
2923
_see_also = ['cat', 'export']
2924
takes_options = [
2925
'revision',
2926
Option('no-backup', "Do not save backups of reverted files."),
2927
]
2320
2928
takes_args = ['file*']
2321
aliases = ['merge-revert']
2322
2929
2323
2930
def run(self, revision=None, no_backup=False, file_list=None):
2324
from bzrlib.commands import parse_spec
2325
2931
if file_list is not None:
2326
2932
if len(file_list) == 0:
2327
raise BzrCommandError("No files specified")
2933
raise errors.BzrCommandError("No files specified")
2328
2934
else:
2329
2935
file_list = []
2330
2936
2333
2939
# FIXME should be tree.last_revision
2334
2940
rev_id = tree.last_revision()
2335
2941
elif len(revision) != 1:
2336
raise BzrCommandError('bzr revert --revision takes exactly 1 argument')
2942
raise errors.BzrCommandError('bzr revert --revision takes exactly 1 argument')
2337
2943
else:
2338
2944
rev_id = revision[0].in_history(tree.branch).rev_id
2339
2945
pb = ui.ui_factory.nested_progress_bar()
2340
2946
try:
2341
2947
tree.revert(file_list,
2342
2948
tree.branch.repository.revision_tree(rev_id),
2343
not no_backup, pb)
2949
not no_backup, pb, report_changes=True)
2344
2950
finally:
2345
2951
pb.finished()
2346
2952
2347
2953
2348
2954
class cmd_assert_fail(Command):
2349
2955
"""Test reporting of assertion failures"""
2956
# intended just for use in testing
2957
2350
2958
hidden = True
2959
2351
2960
def run(self):
2352
assert False, "always fails"
2961
raise AssertionError("always fails")
2353
2962
2354
2963
2355
2964
class cmd_help(Command):
2356
2965
"""Show help on a command or other topic.
2966
"""
2357
2967
2358
For a list of all available commands, say 'bzr help commands'."""
2359
takes_options = [Option('long', 'show help on all commands')]
2968
_see_also = ['topics']
2969
takes_options = [
2970
Option('long', 'Show help on all commands.'),
2971
]
2360
2972
takes_args = ['topic?']
2361
2973
aliases = ['?', '--help', '-?', '-h']
2362
2974
2363
2975
@display_command
2364
2976
def run(self, topic=None, long=False):
2365
import help
2977
import bzrlib.help
2366
2978
if topic is None and long:
2367
2979
topic = "commands"
2368
help.help(topic)
2980
bzrlib.help.help(topic)
2369
2981
2370
2982
2371
2983
class cmd_shell_complete(Command):
2372
2984
"""Show appropriate completions for context.
2373
2985
2374
For a list of all available commands, say 'bzr shell-complete'."""
2986
For a list of all available commands, say 'bzr shell-complete'.
2987
"""
2375
2988
takes_args = ['context?']
2376
2989
aliases = ['s-c']
2377
2990
hidden = True
2385
2998
class cmd_fetch(Command):
2386
2999
"""Copy in history from another branch but don't merge it.
2387
3000
2388
This is an internal method used for pull and merge."""
3001
This is an internal method used for pull and merge.
3002
"""
2389
3003
hidden = True
2390
3004
takes_args = ['from_branch', 'to_branch']
2391
3005
def run(self, from_branch, to_branch):
2397
3011
2398
3012
class cmd_missing(Command):
2399
3013
"""Show unmerged/unpulled revisions between two branches.
3014
3015
OTHER_BRANCH may be local or remote.
3016
"""
2400
3017
2401
OTHER_BRANCH may be local or remote."""
3018
_see_also = ['merge', 'pull']
2402
3019
takes_args = ['other_branch?']
2403
takes_options = [Option('reverse', 'Reverse the order of revisions'),
2404
Option('mine-only',
2405
'Display changes in the local branch only'),
2406
Option('theirs-only',
2407
'Display changes in the remote branch only'),
2408
'log-format',
2409
'line',
2410
'long',
2411
'short',
2412
'show-ids',
2413
'verbose'
2414
]
3020
takes_options = [
3021
Option('reverse', 'Reverse the order of revisions.'),
3022
Option('mine-only',
3023
'Display changes in the local branch only.'),
3024
Option('this' , 'Same as --mine-only.'),
3025
Option('theirs-only',
3026
'Display changes in the remote branch only.'),
3027
Option('other', 'Same as --theirs-only.'),
3028
'log-format',
3029
'show-ids',
3030
'verbose'
3031
]
2415
3032
encoding_type = 'replace'
2416
3033
2417
3034
@display_command
2418
3035
def run(self, other_branch=None, reverse=False, mine_only=False,
2419
3036
theirs_only=False, log_format=None, long=False, short=False, line=False,
2420
show_ids=False, verbose=False):
2421
from bzrlib.missing import find_unmerged, iter_log_data
3037
show_ids=False, verbose=False, this=False, other=False):
3038
from bzrlib.missing import find_unmerged, iter_log_revisions
2422
3039
from bzrlib.log import log_formatter
3040
3041
if this:
3042
mine_only = this
3043
if other:
3044
theirs_only = other
3045
2423
3046
local_branch = Branch.open_containing(u".")[0]
2424
3047
parent = local_branch.get_parent()
2425
3048
if other_branch is None:
2426
3049
other_branch = parent
2427
3050
if other_branch is None:
2428
raise BzrCommandError("No peer location known or specified.")
2429
print "Using last location: " + local_branch.get_parent()
3051
raise errors.BzrCommandError("No peer location known"
3052
" or specified.")
3053
display_url = urlutils.unescape_for_display(parent,
3054
self.outf.encoding)
3055
self.outf.write("Using last location: " + display_url + '\n')
3056
2430
3057
remote_branch = Branch.open(other_branch)
2431
3058
if remote_branch.base == local_branch.base:
2432
3059
remote_branch = local_branch
2434
3061
try:
2435
3062
remote_branch.lock_read()
2436
3063
try:
2437
local_extra, remote_extra = find_unmerged(local_branch, remote_branch)
2438
if (log_format == None):
2439
default = local_branch.get_config().log_format()
2440
log_format = get_log_format(long=long, short=short,
2441
line=line, default=default)
2442
lf = log_formatter(log_format,
2443
to_file=self.outf,
2444
show_ids=show_ids,
2445
show_timezone='original')
3064
local_extra, remote_extra = find_unmerged(local_branch,
3065
remote_branch)
3066
if log_format is None:
3067
registry = log.log_formatter_registry
3068
log_format = registry.get_default(local_branch)
3069
lf = log_format(to_file=self.outf,
3070
show_ids=show_ids,
3071
show_timezone='original')
2446
3072
if reverse is False:
2447
3073
local_extra.reverse()
2448
3074
remote_extra.reverse()
2449
3075
if local_extra and not theirs_only:
2450
print "You have %d extra revision(s):" % len(local_extra)
2451
for data in iter_log_data(local_extra, local_branch.repository,
2452
verbose):
2453
lf.show(*data)
3076
self.outf.write("You have %d extra revision(s):\n" %
3077
len(local_extra))
3078
for revision in iter_log_revisions(local_extra,
3079
local_branch.repository,
3080
verbose):
3081
lf.log_revision(revision)
2454
3082
printed_local = True
2455
3083
else:
2456
3084
printed_local = False
2457
3085
if remote_extra and not mine_only:
2458
3086
if printed_local is True:
2459
print "\n\n"
2460
print "You are missing %d revision(s):" % len(remote_extra)
2461
for data in iter_log_data(remote_extra, remote_branch.repository,
2462
verbose):
2463
lf.show(*data)
3087
self.outf.write("\n\n\n")
3088
self.outf.write("You are missing %d revision(s):\n" %
3089
len(remote_extra))
3090
for revision in iter_log_revisions(remote_extra,
3091
remote_branch.repository,
3092
verbose):
3093
lf.log_revision(revision)
2464
3094
if not remote_extra and not local_extra:
2465
3095
status_code = 0
2466
print "Branches are up to date."
3096
self.outf.write("Branches are up to date.\n")
2467
3097
else:
2468
3098
status_code = 1
2469
3099
finally:
2481
3111
return status_code
2482
3112
2483
3113
3114
class cmd_pack(Command):
3115
"""Compress the data within a repository."""
3116
3117
_see_also = ['repositories']
3118
takes_args = ['branch_or_repo?']
3119
3120
def run(self, branch_or_repo='.'):
3121
dir = bzrdir.BzrDir.open_containing(branch_or_repo)[0]
3122
try:
3123
branch = dir.open_branch()
3124
repository = branch.repository
3125
except errors.NotBranchError:
3126
repository = dir.open_repository()
3127
repository.pack()
3128
3129
2484
3130
class cmd_plugins(Command):
2485
3131
"""List plugins"""
2486
3132
hidden = True
2489
3135
import bzrlib.plugin
2490
3136
from inspect import getdoc
2491
3137
for name, plugin in bzrlib.plugin.all_plugins().items():
2492
if hasattr(plugin, '__path__'):
3138
if getattr(plugin, '__path__', None) is not None:
2493
3139
print plugin.__path__[0]
2494
elif hasattr(plugin, '__file__'):
3140
elif getattr(plugin, '__file__', None) is not None:
2495
3141
print plugin.__file__
2496
3142
else:
2497
print `plugin`
3143
print repr(plugin)
2498
3144
2499
3145
d = getdoc(plugin)
2500
3146
if d:
2503
3149
2504
3150
class cmd_testament(Command):
2505
3151
"""Show testament (signing-form) of a revision."""
2506
takes_options = ['revision', 'long',
2507
Option('strict', help='Produce a strict-format'
2508
' testament')]
3152
takes_options = [
3153
'revision',
3154
Option('long', help='Produce long-format testament.'),
3155
Option('strict',
3156
help='Produce a strict-format testament.')]
2509
3157
takes_args = ['branch?']
2510
3158
@display_command
2511
3159
def run(self, branch=u'.', revision=None, long=False, strict=False):
2544
3192
# with new uncommitted lines marked
2545
3193
aliases = ['ann', 'blame', 'praise']
2546
3194
takes_args = ['filename']
2547
takes_options = [Option('all', help='show annotations on all lines'),
2548
Option('long', help='show date in annotations'),
2549
'revision'
3195
takes_options = [Option('all', help='Show annotations on all lines.'),
3196
Option('long', help='Show commit date in annotations.'),
3197
'revision',
3198
'show-ids',
2550
3199
]
3200
encoding_type = 'exact'
2551
3201
2552
3202
@display_command
2553
def run(self, filename, all=False, long=False, revision=None):
3203
def run(self, filename, all=False, long=False, revision=None,
3204
show_ids=False):
2554
3205
from bzrlib.annotate import annotate_file
2555
3206
tree, relpath = WorkingTree.open_containing(filename)
2556
3207
branch = tree.branch
2559
3210
if revision is None:
2560
3211
revision_id = branch.last_revision()
2561
3212
elif len(revision) != 1:
2562
raise BzrCommandError('bzr annotate --revision takes exactly 1 argument')
3213
raise errors.BzrCommandError('bzr annotate --revision takes exactly 1 argument')
2563
3214
else:
2564
3215
revision_id = revision[0].in_history(branch).rev_id
2565
file_id = tree.inventory.path2id(relpath)
3216
file_id = tree.path2id(relpath)
3217
if file_id is None:
3218
raise errors.NotVersionedError(filename)
2566
3219
tree = branch.repository.revision_tree(revision_id)
2567
3220
file_version = tree.inventory[file_id].revision
2568
annotate_file(branch, file_version, file_id, long, all, sys.stdout)
3221
annotate_file(branch, file_version, file_id, long, all, self.outf,
3222
show_ids=show_ids)
2569
3223
finally:
2570
3224
branch.unlock()
2571
3225
2581
3235
def run(self, revision_id_list=None, revision=None):
2582
3236
import bzrlib.gpg as gpg
2583
3237
if revision_id_list is not None and revision is not None:
2584
raise BzrCommandError('You can only supply one of revision_id or --revision')
3238
raise errors.BzrCommandError('You can only supply one of revision_id or --revision')
2585
3239
if revision_id_list is None and revision is None:
2586
raise BzrCommandError('You must supply either --revision or a revision_id')
3240
raise errors.BzrCommandError('You must supply either --revision or a revision_id')
2587
3241
b = WorkingTree.open_containing(u'.')[0].branch
2588
3242
gpg_strategy = gpg.GPGStrategy(b.get_config())
2589
3243
if revision_id_list is not None:
2602
3256
if to_revid is None:
2603
3257
to_revno = b.revno()
2604
3258
if from_revno is None or to_revno is None:
2605
raise BzrCommandError('Cannot sign a range of non-revision-history revisions')
3259
raise errors.BzrCommandError('Cannot sign a range of non-revision-history revisions')
2606
3260
for revno in range(from_revno, to_revno + 1):
2607
3261
b.repository.sign_revision(b.get_rev_id(revno),
2608
3262
gpg_strategy)
2609
3263
else:
2610
raise BzrCommandError('Please supply either one revision, or a range.')
3264
raise errors.BzrCommandError('Please supply either one revision, or a range.')
2611
3265
2612
3266
2613
3267
class cmd_bind(Command):
2614
"""Bind the current branch to a master branch.
3268
"""Convert the current branch into a checkout of the supplied branch.
2615
3269
2616
After binding, commits must succeed on the master branch
2617
before they are executed on the local one.
3270
Once converted into a checkout, commits must succeed on the master branch
3271
before they will be applied to the local branch.
2618
3272
"""
2619
3273
2620
takes_args = ['location']
3274
_see_also = ['checkouts', 'unbind']
3275
takes_args = ['location?']
2621
3276
takes_options = []
2622
3277
2623
3278
def run(self, location=None):
2624
3279
b, relpath = Branch.open_containing(u'.')
3280
if location is None:
3281
try:
3282
location = b.get_old_bound_location()
3283
except errors.UpgradeRequired:
3284
raise errors.BzrCommandError('No location supplied. '
3285
'This format does not remember old locations.')
3286
else:
3287
if location is None:
3288
raise errors.BzrCommandError('No location supplied and no '
3289
'previous location known')
2625
3290
b_other = Branch.open(location)
2626
3291
try:
2627
3292
b.bind(b_other)
2628
except DivergedBranches:
2629
raise BzrCommandError('These branches have diverged.'
2630
' Try merging, and then bind again.')
3293
except errors.DivergedBranches:
3294
raise errors.BzrCommandError('These branches have diverged.'
3295
' Try merging, and then bind again.')
2631
3296
2632
3297
2633
3298
class cmd_unbind(Command):
2634
"""Unbind the current branch from its master branch.
3299
"""Convert the current checkout into a regular branch.
2635
3300
2636
After unbinding, the local branch is considered independent.
2637
All subsequent commits will be local.
3301
After unbinding, the local branch is considered independent and subsequent
3302
commits will be local only.
2638
3303
"""
2639
3304
3305
_see_also = ['checkouts', 'bind']
2640
3306
takes_args = []
2641
3307
takes_options = []
2642
3308
2643
3309
def run(self):
2644
3310
b, relpath = Branch.open_containing(u'.')
2645
3311
if not b.unbind():
2646
raise BzrCommandError('Local branch is not bound')
3312
raise errors.BzrCommandError('Local branch is not bound')
2647
3313
2648
3314
2649
3315
class cmd_uncommit(Command):
2661
3327
# unreferenced information in 'branch-as-repository' branches.
2662
3328
# TODO: jam 20060108 Add the ability for uncommit to remove unreferenced
2663
3329
# information in shared branches as well.
3330
_see_also = ['commit']
2664
3331
takes_options = ['verbose', 'revision',
2665
Option('dry-run', help='Don\'t actually make changes'),
3332
Option('dry-run', help='Don\'t actually make changes.'),
2666
3333
Option('force', help='Say yes to all questions.')]
2667
3334
takes_args = ['location?']
2668
3335
aliases = []
2751
3418
pass
2752
3419
2753
3420
3421
class cmd_wait_until_signalled(Command):
3422
"""Test helper for test_start_and_stop_bzr_subprocess_send_signal.
3423
3424
This just prints a line to signal when it is ready, then blocks on stdin.
3425
"""
3426
3427
hidden = True
3428
3429
def run(self):
3430
sys.stdout.write("running\n")
3431
sys.stdout.flush()
3432
sys.stdin.readline()
3433
3434
3435
class cmd_serve(Command):
3436
"""Run the bzr server."""
3437
3438
aliases = ['server']
3439
3440
takes_options = [
3441
Option('inet',
3442
help='Serve on stdin/out for use from inetd or sshd.'),
3443
Option('port',
3444
help='Listen for connections on nominated port of the form '
3445
'[hostname:]portnumber. Passing 0 as the port number will '
3446
'result in a dynamically allocated port. The default port is '
3447
'4155.',
3448
type=str),
3449
Option('directory',
3450
help='Serve contents of this directory.',
3451
type=unicode),
3452
Option('allow-writes',
3453
help='By default the server is a readonly server. Supplying '
3454
'--allow-writes enables write access to the contents of '
3455
'the served directory and below.'
3456
),
3457
]
3458
3459
def run(self, port=None, inet=False, directory=None, allow_writes=False):
3460
from bzrlib.smart import medium, server
3461
from bzrlib.transport import get_transport
3462
from bzrlib.transport.chroot import ChrootServer
3463
from bzrlib.transport.remote import BZR_DEFAULT_PORT, BZR_DEFAULT_INTERFACE
3464
if directory is None:
3465
directory = os.getcwd()
3466
url = urlutils.local_path_to_url(directory)
3467
if not allow_writes:
3468
url = 'readonly+' + url
3469
chroot_server = ChrootServer(get_transport(url))
3470
chroot_server.setUp()
3471
t = get_transport(chroot_server.get_url())
3472
if inet:
3473
smart_server = medium.SmartServerPipeStreamMedium(
3474
sys.stdin, sys.stdout, t)
3475
else:
3476
host = BZR_DEFAULT_INTERFACE
3477
if port is None:
3478
port = BZR_DEFAULT_PORT
3479
else:
3480
if ':' in port:
3481
host, port = port.split(':')
3482
port = int(port)
3483
smart_server = server.SmartTCPServer(t, host=host, port=port)
3484
print 'listening on port: ', smart_server.port
3485
sys.stdout.flush()
3486
# for the duration of this server, no UI output is permitted.
3487
# note that this may cause problems with blackbox tests. This should
3488
# be changed with care though, as we dont want to use bandwidth sending
3489
# progress over stderr to smart server clients!
3490
old_factory = ui.ui_factory
3491
try:
3492
ui.ui_factory = ui.SilentUIFactory()
3493
smart_server.serve()
3494
finally:
3495
ui.ui_factory = old_factory
3496
3497
3498
class cmd_join(Command):
3499
"""Combine a subtree into its containing tree.
3500
3501
This command is for experimental use only. It requires the target tree
3502
to be in dirstate-with-subtree format, which cannot be converted into
3503
earlier formats.
3504
3505
The TREE argument should be an independent tree, inside another tree, but
3506
not part of it. (Such trees can be produced by "bzr split", but also by
3507
running "bzr branch" with the target inside a tree.)
3508
3509
The result is a combined tree, with the subtree no longer an independant
3510
part. This is marked as a merge of the subtree into the containing tree,
3511
and all history is preserved.
3512
3513
If --reference is specified, the subtree retains its independence. It can
3514
be branched by itself, and can be part of multiple projects at the same
3515
time. But operations performed in the containing tree, such as commit
3516
and merge, will recurse into the subtree.
3517
"""
3518
3519
_see_also = ['split']
3520
takes_args = ['tree']
3521
takes_options = [
3522
Option('reference', help='Join by reference.'),
3523
]
3524
hidden = True
3525
3526
def run(self, tree, reference=False):
3527
sub_tree = WorkingTree.open(tree)
3528
parent_dir = osutils.dirname(sub_tree.basedir)
3529
containing_tree = WorkingTree.open_containing(parent_dir)[0]
3530
repo = containing_tree.branch.repository
3531
if not repo.supports_rich_root():
3532
raise errors.BzrCommandError(
3533
"Can't join trees because %s doesn't support rich root data.\n"
3534
"You can use bzr upgrade on the repository."
3535
% (repo,))
3536
if reference:
3537
try:
3538
containing_tree.add_reference(sub_tree)
3539
except errors.BadReferenceTarget, e:
3540
# XXX: Would be better to just raise a nicely printable
3541
# exception from the real origin. Also below. mbp 20070306
3542
raise errors.BzrCommandError("Cannot join %s. %s" %
3543
(tree, e.reason))
3544
else:
3545
try:
3546
containing_tree.subsume(sub_tree)
3547
except errors.BadSubsumeSource, e:
3548
raise errors.BzrCommandError("Cannot join %s. %s" %
3549
(tree, e.reason))
3550
3551
3552
class cmd_split(Command):
3553
"""Split a tree into two trees.
3554
3555
This command is for experimental use only. It requires the target tree
3556
to be in dirstate-with-subtree format, which cannot be converted into
3557
earlier formats.
3558
3559
The TREE argument should be a subdirectory of a working tree. That
3560
subdirectory will be converted into an independent tree, with its own
3561
branch. Commits in the top-level tree will not apply to the new subtree.
3562
If you want that behavior, do "bzr join --reference TREE".
3563
"""
3564
3565
_see_also = ['join']
3566
takes_args = ['tree']
3567
3568
hidden = True
3569
3570
def run(self, tree):
3571
containing_tree, subdir = WorkingTree.open_containing(tree)
3572
sub_id = containing_tree.path2id(subdir)
3573
if sub_id is None:
3574
raise errors.NotVersionedError(subdir)
3575
try:
3576
containing_tree.extract(sub_id)
3577
except errors.RootNotRich:
3578
raise errors.UpgradeRequired(containing_tree.branch.base)
3579
3580
3581
3582
class cmd_merge_directive(Command):
3583
"""Generate a merge directive for auto-merge tools.
3584
3585
A directive requests a merge to be performed, and also provides all the
3586
information necessary to do so. This means it must either include a
3587
revision bundle, or the location of a branch containing the desired
3588
revision.
3589
3590
A submit branch (the location to merge into) must be supplied the first
3591
time the command is issued. After it has been supplied once, it will
3592
be remembered as the default.
3593
3594
A public branch is optional if a revision bundle is supplied, but required
3595
if --diff or --plain is specified. It will be remembered as the default
3596
after the first use.
3597
"""
3598
3599
takes_args = ['submit_branch?', 'public_branch?']
3600
3601
takes_options = [
3602
RegistryOption.from_kwargs('patch-type',
3603
'The type of patch to include in the directive',
3604
title='Patch type',
3605
value_switches=True,
3606
enum_switch=False,
3607
bundle='Bazaar revision bundle (default).',
3608
diff='Normal unified diff.',
3609
plain='No patch, just directive.'),
3610
Option('sign', help='GPG-sign the directive.'), 'revision',
3611
Option('mail-to', type=str,
3612
help='Instead of printing the directive, email to this address.'),
3613
Option('message', type=str, short_name='m',
3614
help='Message to use when committing this merge.')
3615
]
3616
3617
encoding_type = 'exact'
3618
3619
def run(self, submit_branch=None, public_branch=None, patch_type='bundle',
3620
sign=False, revision=None, mail_to=None, message=None):
3621
from bzrlib.revision import ensure_null, NULL_REVISION
3622
if patch_type == 'plain':
3623
patch_type = None
3624
branch = Branch.open('.')
3625
stored_submit_branch = branch.get_submit_branch()
3626
if submit_branch is None:
3627
submit_branch = stored_submit_branch
3628
else:
3629
if stored_submit_branch is None:
3630
branch.set_submit_branch(submit_branch)
3631
if submit_branch is None:
3632
submit_branch = branch.get_parent()
3633
if submit_branch is None:
3634
raise errors.BzrCommandError('No submit branch specified or known')
3635
3636
stored_public_branch = branch.get_public_branch()
3637
if public_branch is None:
3638
public_branch = stored_public_branch
3639
elif stored_public_branch is None:
3640
branch.set_public_branch(public_branch)
3641
if patch_type != "bundle" and public_branch is None:
3642
raise errors.BzrCommandError('No public branch specified or'
3643
' known')
3644
if revision is not None:
3645
if len(revision) != 1:
3646
raise errors.BzrCommandError('bzr merge-directive takes '
3647
'exactly one revision identifier')
3648
else:
3649
revision_id = revision[0].in_history(branch).rev_id
3650
else:
3651
revision_id = branch.last_revision()
3652
revision_id = ensure_null(revision_id)
3653
if revision_id == NULL_REVISION:
3654
raise errors.BzrCommandError('No revisions to bundle.')
3655
directive = merge_directive.MergeDirective.from_objects(
3656
branch.repository, revision_id, time.time(),
3657
osutils.local_time_offset(), submit_branch,
3658
public_branch=public_branch, patch_type=patch_type,
3659
message=message)
3660
if mail_to is None:
3661
if sign:
3662
self.outf.write(directive.to_signed(branch))
3663
else:
3664
self.outf.writelines(directive.to_lines())
3665
else:
3666
message = directive.to_email(mail_to, branch, sign)
3667
s = SMTPConnection(branch.get_config())
3668
s.send_email(message)
3669
3670
3671
class cmd_tag(Command):
3672
"""Create a tag naming a revision.
3673
3674
Tags give human-meaningful names to revisions. Commands that take a -r
3675
(--revision) option can be given -rtag:X, where X is any previously
3676
created tag.
3677
3678
Tags are stored in the branch. Tags are copied from one branch to another
3679
along when you branch, push, pull or merge.
3680
3681
It is an error to give a tag name that already exists unless you pass
3682
--force, in which case the tag is moved to point to the new revision.
3683
"""
3684
3685
_see_also = ['commit', 'tags']
3686
takes_args = ['tag_name']
3687
takes_options = [
3688
Option('delete',
3689
help='Delete this tag rather than placing it.',
3690
),
3691
Option('directory',
3692
help='Branch in which to place the tag.',
3693
short_name='d',
3694
type=unicode,
3695
),
3696
Option('force',
3697
help='Replace existing tags.',
3698
),
3699
'revision',
3700
]
3701
3702
def run(self, tag_name,
3703
delete=None,
3704
directory='.',
3705
force=None,
3706
revision=None,
3707
):
3708
branch, relpath = Branch.open_containing(directory)
3709
branch.lock_write()
3710
try:
3711
if delete:
3712
branch.tags.delete_tag(tag_name)
3713
self.outf.write('Deleted tag %s.\n' % tag_name)
3714
else:
3715
if revision:
3716
if len(revision) != 1:
3717
raise errors.BzrCommandError(
3718
"Tags can only be placed on a single revision, "
3719
"not on a range")
3720
revision_id = revision[0].in_history(branch).rev_id
3721
else:
3722
revision_id = branch.last_revision()
3723
if (not force) and branch.tags.has_tag(tag_name):
3724
raise errors.TagAlreadyExists(tag_name)
3725
branch.tags.set_tag(tag_name, revision_id)
3726
self.outf.write('Created tag %s.\n' % tag_name)
3727
finally:
3728
branch.unlock()
3729
3730
3731
class cmd_tags(Command):
3732
"""List tags.
3733
3734
This tag shows a table of tag names and the revisions they reference.
3735
"""
3736
3737
_see_also = ['tag']
3738
takes_options = [
3739
Option('directory',
3740
help='Branch whose tags should be displayed.',
3741
short_name='d',
3742
type=unicode,
3743
),
3744
]
3745
3746
@display_command
3747
def run(self,
3748
directory='.',
3749
):
3750
branch, relpath = Branch.open_containing(directory)
3751
for tag_name, target in sorted(branch.tags.get_tag_dict().items()):
3752
self.outf.write('%-20s %s\n' % (tag_name, target))
3753
2754
3754
2755
3755
# command-line interpretation helper for merge-related commands
2756
def merge(other_revision, base_revision,
2757
check_clean=True, ignore_zero=False,
2758
this_dir=None, backup_files=False, merge_type=Merge3Merger,
2759
file_list=None, show_base=False, reprocess=False,
2760
pb=DummyProgress()):
3756
def _merge_helper(other_revision, base_revision, possible_transports=None,
3757
check_clean=True, ignore_zero=False,
3758
this_dir=None, backup_files=False,
3759
merge_type=None,
3760
file_list=None, show_base=False, reprocess=False,
3761
pull=False,
3762
pb=DummyProgress(),
3763
change_reporter=None,
3764
other_rev_id=None):
2761
3765
"""Merge changes into a tree.
2762
3766
2763
3767
base_revision
2785
3789
clients might prefer to call merge.merge_inner(), which has less magic
2786
3790
behavior.
2787
3791
"""
2788
from bzrlib.merge import Merger
3792
# Loading it late, so that we don't always have to import bzrlib.merge
3793
if merge_type is None:
3794
merge_type = _mod_merge.Merge3Merger
2789
3795
if this_dir is None:
2790
3796
this_dir = u'.'
2791
3797
this_tree = WorkingTree.open_containing(this_dir)[0]
2792
if show_base and not merge_type is Merge3Merger:
2793
raise BzrCommandError("Show-base is not supported for this merge"
2794
" type. %s" % merge_type)
3798
if show_base and not merge_type is _mod_merge.Merge3Merger:
3799
raise errors.BzrCommandError("Show-base is not supported for this merge"
3800
" type. %s" % merge_type)
2795
3801
if reprocess and not merge_type.supports_reprocess:
2796
raise BzrCommandError("Conflict reduction is not supported for merge"
2797
" type %s." % merge_type)
3802
raise errors.BzrCommandError("Conflict reduction is not supported for merge"
3803
" type %s." % merge_type)
2798
3804
if reprocess and show_base:
2799
raise BzrCommandError("Cannot do conflict reduction and show base.")
3805
raise errors.BzrCommandError("Cannot do conflict reduction and show base.")
3806
# TODO: jam 20070226 We should really lock these trees earlier. However, we
3807
# only want to take out a lock_tree_write() if we don't have to pull
3808
# any ancestry. But merge might fetch ancestry in the middle, in
3809
# which case we would need a lock_write().
3810
# Because we cannot upgrade locks, for now we live with the fact that
3811
# the tree will be locked multiple times during a merge. (Maybe
3812
# read-only some of the time, but it means things will get read
3813
# multiple times.)
2800
3814
try:
2801
merger = Merger(this_tree.branch, this_tree=this_tree, pb=pb)
3815
merger = _mod_merge.Merger(this_tree.branch, this_tree=this_tree,
3816
pb=pb, change_reporter=change_reporter)
2802
3817
merger.pp = ProgressPhase("Merge phase", 5, pb)
2803
3818
merger.pp.next_phase()
2804
3819
merger.check_basis(check_clean)
2805
merger.set_other(other_revision)
3820
if other_rev_id is not None:
3821
merger.set_other_revision(other_rev_id, this_tree.branch)
3822
else:
3823
merger.set_other(other_revision, possible_transports)
2806
3824
merger.pp.next_phase()
2807
3825
merger.set_base(base_revision)
2808
3826
if merger.base_rev_id == merger.other_rev_id:
2809
3827
note('Nothing to do.')
2810
3828
return 0
3829
if file_list is None:
3830
if pull and merger.base_rev_id == merger.this_rev_id:
3831
# FIXME: deduplicate with pull
3832
result = merger.this_tree.pull(merger.this_branch,
3833
False, merger.other_rev_id)
3834
if result.old_revid == result.new_revid:
3835
note('No revisions to pull.')
3836
else:
3837
note('Now on revision %d.' % result.new_revno)
3838
return 0
2811
3839
merger.backup_files = backup_files
2812
3840
merger.merge_type = merge_type
2813
3841
merger.set_interesting_files(file_list)
2821
3849
return conflicts
2822
3850
2823
3851
3852
def _create_prefix(cur_transport):
3853
needed = [cur_transport]
3854
# Recurse upwards until we can create a directory successfully
3855
while True:
3856
new_transport = cur_transport.clone('..')
3857
if new_transport.base == cur_transport.base:
3858
raise errors.BzrCommandError(
3859
"Failed to create path prefix for %s."
3860
% cur_transport.base)
3861
try:
3862
new_transport.mkdir('.')
3863
except errors.NoSuchFile:
3864
needed.append(new_transport)
3865
cur_transport = new_transport
3866
else:
3867
break
3868
# Now we only need to create child directories
3869
while needed:
3870
cur_transport = needed.pop()
3871
cur_transport.ensure_base()
3872
3873
3874
# Compatibility
3875
merge = _merge_helper
3876
3877
2824
3878
# these get imported and then picked up by the scan for cmd_*
2825
3879
# TODO: Some more consistent way to split command definitions across files;
2826
3880
# we do need to load at least some information about them to know of
2827
3881
# aliases. ideally we would avoid loading the implementation until the
2828
3882
# details were needed.
3883
from bzrlib.cmd_version_info import cmd_version_info
2829
3884
from bzrlib.conflicts import cmd_resolve, cmd_conflicts, restore
2830
3885
from bzrlib.bundle.commands import cmd_bundle_revisions
2831
3886
from bzrlib.sign_my_commits import cmd_sign_my_commits
2832
from bzrlib.weave_commands import cmd_weave_list, cmd_weave_join, \
3887
from bzrlib.weave_commands import cmd_versionedfile_list, cmd_weave_join, \
2833
3888
cmd_weave_plan_merge, cmd_weave_merge_text
Loggerhead is a web-based interface for Breezy
Version: 2.0.1