« back to all changes in this revision
Viewing changes to bzrlib/builtins.py
- browse files at revision 525
- compare with another revision
- download diff
- download tarball
- view history from revision 525
- Committer: Martin Pool
- Date: 2005-05-17 07:51:51 UTC
- Revision ID: mbp@sourcefrog.net-20050517075151-b64853a6a38a6225
- export bzrlib.find_branch
- files added:
- build-api
- notes
- patches
- urlgrabber
- files removed:
- BRANCH.TODO
- bzrlib/benchmarks
- bzrlib/benchmarks/tree_creator
- bzrlib/bundle
- bzrlib/bundle/serializer
- bzrlib/doc
- bzrlib/doc/api
- bzrlib/export
- bzrlib/filters
- bzrlib/help_topics
- bzrlib/help_topics/en
- bzrlib/plugins
- bzrlib/plugins/launchpad
- bzrlib/plugins/netrc_credential_store
- bzrlib/plugins/netrc_credential_store/tests
- bzrlib/repofmt
- bzrlib/smart
- bzrlib/store
- bzrlib/store/revision
- bzrlib/store/versioned
- bzrlib/tests
- bzrlib/tests/blackbox
- bzrlib/tests/branch_implementations
- bzrlib/tests/bzrdir_implementations
- bzrlib/tests/commands
- bzrlib/tests/ftp_server
- bzrlib/tests/interrepository_implementations
- bzrlib/tests/intertree_implementations
- bzrlib/tests/inventory_implementations
- bzrlib/tests/per_interbranch
- bzrlib/tests/per_lock
- bzrlib/tests/per_repository
- bzrlib/tests/per_repository_reference
- bzrlib/tests/ssl_certs
- bzrlib/tests/test_patches_data
- bzrlib/tests/tree_implementations
- bzrlib/tests/workingtree_implementations
- bzrlib/transport
- bzrlib/transport/ftp
- bzrlib/transport/http
- bzrlib/ui
- bzrlib/util
- bzrlib/util/configobj
- bzrlib/util/configobj/docs
- bzrlib/util/effbot
- bzrlib/util/effbot/org
- bzrlib/util/tests
- bzrlib/version_info_formats
- contrib/emacs
- doc/developers
- doc/en
- doc/en/admin-guide
- doc/en/developer-guide
- doc/en/mini-tutorial
- doc/en/quick-reference
- doc/en/release-notes
- doc/en/tutorials
- doc/en/user-guide
- doc/en/user-guide/images
- doc/en/user-reference
- doc/es
- doc/es/guia-desarrollador
- doc/es/guia-usuario
- doc/es/mini-tutorial
- doc/es/notas-version
- doc/es/referencia
- doc/es/referencia-rapida
- man1
- tools
- tools/doc_generate
- tools/packaging
- tools/win32
- files renamed:
- bzrlib/bundle/__init__.py => bzrlib/changeset.py
- contrib/newinventory.py => bzrlib/newinventory.py
- bzrlib/store/__init__.py => bzrlib/store.py
- bzrlib/xml_serializer.py => bzrlib/xml.py
- contrib/bash/bzr.simple => contrib/bash/bzr
- bzrlib/util/elementtree/ => elementtree/
- files modified:
- .bzrignore
- bzr *
- setup.py *
added
removed
bzrlib/builtins.py
1
# Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009 Canonical Ltd
2
#
3
# This program is free software; you can redistribute it and/or modify
4
# it under the terms of the GNU General Public License as published by
5
# the Free Software Foundation; either version 2 of the License, or
6
# (at your option) any later version.
7
#
8
# This program is distributed in the hope that it will be useful,
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11
# GNU General Public License for more details.
12
#
13
# You should have received a copy of the GNU General Public License
14
# along with this program; if not, write to the Free Software
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16
17
"""builtin bzr commands"""
18
19
import os
20
21
from bzrlib.lazy_import import lazy_import
22
lazy_import(globals(), """
23
import codecs
24
import cStringIO
25
import sys
26
import time
27
28
import bzrlib
29
from bzrlib import (
30
bugtracker,
31
bundle,
32
btree_index,
33
bzrdir,
34
delta,
35
config,
36
errors,
37
globbing,
38
hooks,
39
log,
40
merge as _mod_merge,
41
merge_directive,
42
osutils,
43
reconfigure,
44
rename_map,
45
revision as _mod_revision,
46
symbol_versioning,
47
transport,
48
tree as _mod_tree,
49
ui,
50
urlutils,
51
views,
52
)
53
from bzrlib.branch import Branch
54
from bzrlib.conflicts import ConflictList
55
from bzrlib.revisionspec import RevisionSpec, RevisionInfo
56
from bzrlib.smtp_connection import SMTPConnection
57
from bzrlib.workingtree import WorkingTree
58
""")
59
60
from bzrlib.commands import Command, display_command
61
from bzrlib.option import (
62
ListOption,
63
Option,
64
RegistryOption,
65
custom_help,
66
_parse_revision_str,
67
)
68
from bzrlib.trace import mutter, note, warning, is_quiet, get_verbosity_level
69
70
71
def tree_files(file_list, default_branch=u'.', canonicalize=True,
72
apply_view=True):
73
try:
74
return internal_tree_files(file_list, default_branch, canonicalize,
75
apply_view)
76
except errors.FileInWrongBranch, e:
77
raise errors.BzrCommandError("%s is not in the same branch as %s" %
78
(e.path, file_list[0]))
79
80
81
def tree_files_for_add(file_list):
82
"""Add handles files a bit differently so it a custom implementation."""
83
if file_list:
84
tree = WorkingTree.open_containing(file_list[0])[0]
85
if tree.supports_views():
86
view_files = tree.views.lookup_view()
87
if view_files:
88
for filename in file_list:
89
if not osutils.is_inside_any(view_files, filename):
90
raise errors.FileOutsideView(filename, view_files)
91
else:
92
tree = WorkingTree.open_containing(u'.')[0]
93
if tree.supports_views():
94
view_files = tree.views.lookup_view()
95
if view_files:
96
file_list = view_files
97
view_str = views.view_display_str(view_files)
98
note("Ignoring files outside view. View is %s" % view_str)
99
return tree, file_list
100
101
102
def _get_one_revision(command_name, revisions):
103
if revisions is None:
104
return None
105
if len(revisions) != 1:
106
raise errors.BzrCommandError(
107
'bzr %s --revision takes exactly one revision identifier' % (
108
command_name,))
109
return revisions[0]
110
111
112
def _get_one_revision_tree(command_name, revisions, branch=None, tree=None):
113
if branch is None:
114
branch = tree.branch
115
if revisions is None:
116
if tree is not None:
117
rev_tree = tree.basis_tree()
118
else:
119
rev_tree = branch.basis_tree()
120
else:
121
revision = _get_one_revision(command_name, revisions)
122
rev_tree = revision.as_tree(branch)
123
return rev_tree
124
125
126
# XXX: Bad function name; should possibly also be a class method of
127
# WorkingTree rather than a function.
128
def internal_tree_files(file_list, default_branch=u'.', canonicalize=True,
129
apply_view=True):
130
"""Convert command-line paths to a WorkingTree and relative paths.
131
132
This is typically used for command-line processors that take one or
133
more filenames, and infer the workingtree that contains them.
134
135
The filenames given are not required to exist.
136
137
:param file_list: Filenames to convert.
138
139
:param default_branch: Fallback tree path to use if file_list is empty or
140
None.
141
142
:param apply_view: if True and a view is set, apply it or check that
143
specified files are within it
144
145
:return: workingtree, [relative_paths]
146
"""
147
if file_list is None or len(file_list) == 0:
148
tree = WorkingTree.open_containing(default_branch)[0]
149
if tree.supports_views() and apply_view:
150
view_files = tree.views.lookup_view()
151
if view_files:
152
file_list = view_files
153
view_str = views.view_display_str(view_files)
154
note("Ignoring files outside view. View is %s" % view_str)
155
return tree, file_list
156
tree = WorkingTree.open_containing(osutils.realpath(file_list[0]))[0]
157
return tree, safe_relpath_files(tree, file_list, canonicalize,
158
apply_view=apply_view)
159
160
161
def safe_relpath_files(tree, file_list, canonicalize=True, apply_view=True):
162
"""Convert file_list into a list of relpaths in tree.
163
164
:param tree: A tree to operate on.
165
:param file_list: A list of user provided paths or None.
166
:param apply_view: if True and a view is set, apply it or check that
167
specified files are within it
168
:return: A list of relative paths.
169
:raises errors.PathNotChild: When a provided path is in a different tree
170
than tree.
171
"""
172
if file_list is None:
173
return None
174
if tree.supports_views() and apply_view:
175
view_files = tree.views.lookup_view()
176
else:
177
view_files = []
178
new_list = []
179
# tree.relpath exists as a "thunk" to osutils, but canonical_relpath
180
# doesn't - fix that up here before we enter the loop.
181
if canonicalize:
182
fixer = lambda p: osutils.canonical_relpath(tree.basedir, p)
183
else:
184
fixer = tree.relpath
185
for filename in file_list:
186
try:
187
relpath = fixer(osutils.dereference_path(filename))
188
if view_files and not osutils.is_inside_any(view_files, relpath):
189
raise errors.FileOutsideView(filename, view_files)
190
new_list.append(relpath)
191
except errors.PathNotChild:
192
raise errors.FileInWrongBranch(tree.branch, filename)
193
return new_list
194
195
196
def _get_view_info_for_change_reporter(tree):
197
"""Get the view information from a tree for change reporting."""
198
view_info = None
199
try:
200
current_view = tree.views.get_view_info()[0]
201
if current_view is not None:
202
view_info = (current_view, tree.views.lookup_view())
203
except errors.ViewsNotSupported:
204
pass
205
return view_info
206
207
208
# TODO: Make sure no commands unconditionally use the working directory as a
209
# branch. If a filename argument is used, the first of them should be used to
210
# specify the branch. (Perhaps this can be factored out into some kind of
211
# Argument class, representing a file in a branch, where the first occurrence
212
# opens the branch?)
213
214
class cmd_status(Command):
215
"""Display status summary.
216
217
This reports on versioned and unknown files, reporting them
218
grouped by state. Possible states are:
219
220
added
221
Versioned in the working copy but not in the previous revision.
222
223
removed
224
Versioned in the previous revision but removed or deleted
225
in the working copy.
226
227
renamed
228
Path of this file changed from the previous revision;
229
the text may also have changed. This includes files whose
230
parent directory was renamed.
231
232
modified
233
Text has changed since the previous revision.
234
235
kind changed
236
File kind has been changed (e.g. from file to directory).
237
238
unknown
239
Not versioned and not matching an ignore pattern.
240
241
To see ignored files use 'bzr ignored'. For details on the
242
changes to file texts, use 'bzr diff'.
243
244
Note that --short or -S gives status flags for each item, similar
245
to Subversion's status command. To get output similar to svn -q,
246
use bzr status -SV.
247
248
If no arguments are specified, the status of the entire working
249
directory is shown. Otherwise, only the status of the specified
250
files or directories is reported. If a directory is given, status
251
is reported for everything inside that directory.
252
253
Before merges are committed, the pending merge tip revisions are
254
shown. To see all pending merge revisions, use the -v option.
255
To skip the display of pending merge information altogether, use
256
the no-pending option or specify a file/directory.
257
258
If a revision argument is given, the status is calculated against
259
that revision, or between two revisions if two are provided.
260
"""
261
262
# TODO: --no-recurse, --recurse options
263
264
takes_args = ['file*']
265
takes_options = ['show-ids', 'revision', 'change', 'verbose',
266
Option('short', help='Use short status indicators.',
267
short_name='S'),
268
Option('versioned', help='Only show versioned files.',
269
short_name='V'),
270
Option('no-pending', help='Don\'t show pending merges.',
271
),
272
]
273
aliases = ['st', 'stat']
274
275
encoding_type = 'replace'
276
_see_also = ['diff', 'revert', 'status-flags']
277
278
@display_command
279
def run(self, show_ids=False, file_list=None, revision=None, short=False,
280
versioned=False, no_pending=False, verbose=False):
281
from bzrlib.status import show_tree_status
282
283
if revision and len(revision) > 2:
284
raise errors.BzrCommandError('bzr status --revision takes exactly'
285
' one or two revision specifiers')
286
287
tree, relfile_list = tree_files(file_list)
288
# Avoid asking for specific files when that is not needed.
289
if relfile_list == ['']:
290
relfile_list = None
291
# Don't disable pending merges for full trees other than '.'.
292
if file_list == ['.']:
293
no_pending = True
294
# A specific path within a tree was given.
295
elif relfile_list is not None:
296
no_pending = True
297
show_tree_status(tree, show_ids=show_ids,
298
specific_files=relfile_list, revision=revision,
299
to_file=self.outf, short=short, versioned=versioned,
300
show_pending=(not no_pending), verbose=verbose)
301
302
303
class cmd_cat_revision(Command):
304
"""Write out metadata for a revision.
305
306
The revision to print can either be specified by a specific
307
revision identifier, or you can use --revision.
308
"""
309
310
hidden = True
311
takes_args = ['revision_id?']
312
takes_options = ['revision']
313
# cat-revision is more for frontends so should be exact
314
encoding = 'strict'
315
316
@display_command
317
def run(self, revision_id=None, revision=None):
318
if revision_id is not None and revision is not None:
319
raise errors.BzrCommandError('You can only supply one of'
320
' revision_id or --revision')
321
if revision_id is None and revision is None:
322
raise errors.BzrCommandError('You must supply either'
323
' --revision or a revision_id')
324
b = WorkingTree.open_containing(u'.')[0].branch
325
326
# TODO: jam 20060112 should cat-revision always output utf-8?
327
if revision_id is not None:
328
revision_id = osutils.safe_revision_id(revision_id, warn=False)
329
try:
330
self.outf.write(b.repository.get_revision_xml(revision_id).decode('utf-8'))
331
except errors.NoSuchRevision:
332
msg = "The repository %s contains no revision %s." % (b.repository.base,
333
revision_id)
334
raise errors.BzrCommandError(msg)
335
elif revision is not None:
336
for rev in revision:
337
if rev is None:
338
raise errors.BzrCommandError('You cannot specify a NULL'
339
' revision.')
340
rev_id = rev.as_revision_id(b)
341
self.outf.write(b.repository.get_revision_xml(rev_id).decode('utf-8'))
342
343
344
class cmd_dump_btree(Command):
345
"""Dump the contents of a btree index file to stdout.
346
347
PATH is a btree index file, it can be any URL. This includes things like
348
.bzr/repository/pack-names, or .bzr/repository/indices/a34b3a...ca4a4.iix
349
350
By default, the tuples stored in the index file will be displayed. With
351
--raw, we will uncompress the pages, but otherwise display the raw bytes
352
stored in the index.
353
"""
354
355
# TODO: Do we want to dump the internal nodes as well?
356
# TODO: It would be nice to be able to dump the un-parsed information,
357
# rather than only going through iter_all_entries. However, this is
358
# good enough for a start
359
hidden = True
360
encoding_type = 'exact'
361
takes_args = ['path']
362
takes_options = [Option('raw', help='Write the uncompressed bytes out,'
363
' rather than the parsed tuples.'),
364
]
365
366
def run(self, path, raw=False):
367
dirname, basename = osutils.split(path)
368
t = transport.get_transport(dirname)
369
if raw:
370
self._dump_raw_bytes(t, basename)
371
else:
372
self._dump_entries(t, basename)
373
374
def _get_index_and_bytes(self, trans, basename):
375
"""Create a BTreeGraphIndex and raw bytes."""
376
bt = btree_index.BTreeGraphIndex(trans, basename, None)
377
bytes = trans.get_bytes(basename)
378
bt._file = cStringIO.StringIO(bytes)
379
bt._size = len(bytes)
380
return bt, bytes
381
382
def _dump_raw_bytes(self, trans, basename):
383
import zlib
384
385
# We need to parse at least the root node.
386
# This is because the first page of every row starts with an
387
# uncompressed header.
388
bt, bytes = self._get_index_and_bytes(trans, basename)
389
for page_idx, page_start in enumerate(xrange(0, len(bytes),
390
btree_index._PAGE_SIZE)):
391
page_end = min(page_start + btree_index._PAGE_SIZE, len(bytes))
392
page_bytes = bytes[page_start:page_end]
393
if page_idx == 0:
394
self.outf.write('Root node:\n')
395
header_end, data = bt._parse_header_from_bytes(page_bytes)
396
self.outf.write(page_bytes[:header_end])
397
page_bytes = data
398
self.outf.write('\nPage %d\n' % (page_idx,))
399
decomp_bytes = zlib.decompress(page_bytes)
400
self.outf.write(decomp_bytes)
401
self.outf.write('\n')
402
403
def _dump_entries(self, trans, basename):
404
try:
405
st = trans.stat(basename)
406
except errors.TransportNotPossible:
407
# We can't stat, so we'll fake it because we have to do the 'get()'
408
# anyway.
409
bt, _ = self._get_index_and_bytes(trans, basename)
410
else:
411
bt = btree_index.BTreeGraphIndex(trans, basename, st.st_size)
412
for node in bt.iter_all_entries():
413
# Node is made up of:
414
# (index, key, value, [references])
415
self.outf.write('%s\n' % (node[1:],))
416
417
418
class cmd_remove_tree(Command):
419
"""Remove the working tree from a given branch/checkout.
420
421
Since a lightweight checkout is little more than a working tree
422
this will refuse to run against one.
423
424
To re-create the working tree, use "bzr checkout".
425
"""
426
_see_also = ['checkout', 'working-trees']
427
takes_args = ['location?']
428
takes_options = [
429
Option('force',
430
help='Remove the working tree even if it has '
431
'uncommitted changes.'),
432
]
433
434
def run(self, location='.', force=False):
435
d = bzrdir.BzrDir.open(location)
436
437
try:
438
working = d.open_workingtree()
439
except errors.NoWorkingTree:
440
raise errors.BzrCommandError("No working tree to remove")
441
except errors.NotLocalUrl:
442
raise errors.BzrCommandError("You cannot remove the working tree of a "
443
"remote path")
444
if not force:
445
changes = working.changes_from(working.basis_tree())
446
if changes.has_changed():
447
raise errors.UncommittedChanges(working)
448
449
working_path = working.bzrdir.root_transport.base
450
branch_path = working.branch.bzrdir.root_transport.base
451
if working_path != branch_path:
452
raise errors.BzrCommandError("You cannot remove the working tree from "
453
"a lightweight checkout")
454
455
d.destroy_workingtree()
456
457
458
class cmd_revno(Command):
459
"""Show current revision number.
460
461
This is equal to the number of revisions on this branch.
462
"""
463
464
_see_also = ['info']
465
takes_args = ['location?']
466
467
@display_command
468
def run(self, location=u'.'):
469
self.outf.write(str(Branch.open_containing(location)[0].revno()))
470
self.outf.write('\n')
471
472
473
class cmd_revision_info(Command):
474
"""Show revision number and revision id for a given revision identifier.
475
"""
476
hidden = True
477
takes_args = ['revision_info*']
478
takes_options = [
479
'revision',
480
Option('directory',
481
help='Branch to examine, '
482
'rather than the one containing the working directory.',
483
short_name='d',
484
type=unicode,
485
),
486
]
487
488
@display_command
489
def run(self, revision=None, directory=u'.', revision_info_list=[]):
490
491
revs = []
492
if revision is not None:
493
revs.extend(revision)
494
if revision_info_list is not None:
495
for rev in revision_info_list:
496
revs.append(RevisionSpec.from_string(rev))
497
498
b = Branch.open_containing(directory)[0]
499
500
if len(revs) == 0:
501
revs.append(RevisionSpec.from_string('-1'))
502
503
for rev in revs:
504
revision_id = rev.as_revision_id(b)
505
try:
506
revno = '%4d' % (b.revision_id_to_revno(revision_id))
507
except errors.NoSuchRevision:
508
dotted_map = b.get_revision_id_to_revno_map()
509
revno = '.'.join(str(i) for i in dotted_map[revision_id])
510
print '%s %s' % (revno, revision_id)
511
512
513
class cmd_add(Command):
514
"""Add specified files or directories.
515
516
In non-recursive mode, all the named items are added, regardless
517
of whether they were previously ignored. A warning is given if
518
any of the named files are already versioned.
519
520
In recursive mode (the default), files are treated the same way
521
but the behaviour for directories is different. Directories that
522
are already versioned do not give a warning. All directories,
523
whether already versioned or not, are searched for files or
524
subdirectories that are neither versioned or ignored, and these
525
are added. This search proceeds recursively into versioned
526
directories. If no names are given '.' is assumed.
527
528
Therefore simply saying 'bzr add' will version all files that
529
are currently unknown.
530
531
Adding a file whose parent directory is not versioned will
532
implicitly add the parent, and so on up to the root. This means
533
you should never need to explicitly add a directory, they'll just
534
get added when you add a file in the directory.
535
536
--dry-run will show which files would be added, but not actually
537
add them.
538
539
--file-ids-from will try to use the file ids from the supplied path.
540
It looks up ids trying to find a matching parent directory with the
541
same filename, and then by pure path. This option is rarely needed
542
but can be useful when adding the same logical file into two
543
branches that will be merged later (without showing the two different
544
adds as a conflict). It is also useful when merging another project
545
into a subdirectory of this one.
546
"""
547
takes_args = ['file*']
548
takes_options = [
549
Option('no-recurse',
550
help="Don't recursively add the contents of directories."),
551
Option('dry-run',
552
help="Show what would be done, but don't actually do anything."),
553
'verbose',
554
Option('file-ids-from',
555
type=unicode,
556
help='Lookup file ids from this tree.'),
557
]
558
encoding_type = 'replace'
559
_see_also = ['remove']
560
561
def run(self, file_list, no_recurse=False, dry_run=False, verbose=False,
562
file_ids_from=None):
563
import bzrlib.add
564
565
base_tree = None
566
if file_ids_from is not None:
567
try:
568
base_tree, base_path = WorkingTree.open_containing(
569
file_ids_from)
570
except errors.NoWorkingTree:
571
base_branch, base_path = Branch.open_containing(
572
file_ids_from)
573
base_tree = base_branch.basis_tree()
574
575
action = bzrlib.add.AddFromBaseAction(base_tree, base_path,
576
to_file=self.outf, should_print=(not is_quiet()))
577
else:
578
action = bzrlib.add.AddAction(to_file=self.outf,
579
should_print=(not is_quiet()))
580
581
if base_tree:
582
base_tree.lock_read()
583
try:
584
file_list = self._maybe_expand_globs(file_list)
585
tree, file_list = tree_files_for_add(file_list)
586
added, ignored = tree.smart_add(file_list, not
587
no_recurse, action=action, save=not dry_run)
588
finally:
589
if base_tree is not None:
590
base_tree.unlock()
591
if len(ignored) > 0:
592
if verbose:
593
for glob in sorted(ignored.keys()):
594
for path in ignored[glob]:
595
self.outf.write("ignored %s matching \"%s\"\n"
596
% (path, glob))
597
else:
598
match_len = 0
599
for glob, paths in ignored.items():
600
match_len += len(paths)
601
self.outf.write("ignored %d file(s).\n" % match_len)
602
self.outf.write("If you wish to add some of these files,"
603
" please add them by name.\n")
604
605
606
class cmd_mkdir(Command):
607
"""Create a new versioned directory.
608
609
This is equivalent to creating the directory and then adding it.
610
"""
611
612
takes_args = ['dir+']
613
encoding_type = 'replace'
614
615
def run(self, dir_list):
616
for d in dir_list:
617
os.mkdir(d)
618
wt, dd = WorkingTree.open_containing(d)
619
wt.add([dd])
620
self.outf.write('added %s\n' % d)
621
622
623
class cmd_relpath(Command):
624
"""Show path of a file relative to root"""
625
626
takes_args = ['filename']
627
hidden = True
628
629
@display_command
630
def run(self, filename):
631
# TODO: jam 20050106 Can relpath return a munged path if
632
# sys.stdout encoding cannot represent it?
633
tree, relpath = WorkingTree.open_containing(filename)
634
self.outf.write(relpath)
635
self.outf.write('\n')
636
637
638
class cmd_inventory(Command):
639
"""Show inventory of the current working copy or a revision.
640
641
It is possible to limit the output to a particular entry
642
type using the --kind option. For example: --kind file.
643
644
It is also possible to restrict the list of files to a specific
645
set. For example: bzr inventory --show-ids this/file
646
"""
647
648
hidden = True
649
_see_also = ['ls']
650
takes_options = [
651
'revision',
652
'show-ids',
653
Option('kind',
654
help='List entries of a particular kind: file, directory, symlink.',
655
type=unicode),
656
]
657
takes_args = ['file*']
658
659
@display_command
660
def run(self, revision=None, show_ids=False, kind=None, file_list=None):
661
if kind and kind not in ['file', 'directory', 'symlink']:
662
raise errors.BzrCommandError('invalid kind %r specified' % (kind,))
663
664
revision = _get_one_revision('inventory', revision)
665
work_tree, file_list = tree_files(file_list)
666
work_tree.lock_read()
667
try:
668
if revision is not None:
669
tree = revision.as_tree(work_tree.branch)
670
671
extra_trees = [work_tree]
672
tree.lock_read()
673
else:
674
tree = work_tree
675
extra_trees = []
676
677
if file_list is not None:
678
file_ids = tree.paths2ids(file_list, trees=extra_trees,
679
require_versioned=True)
680
# find_ids_across_trees may include some paths that don't
681
# exist in 'tree'.
682
entries = sorted((tree.id2path(file_id), tree.inventory[file_id])
683
for file_id in file_ids if file_id in tree)
684
else:
685
entries = tree.inventory.entries()
686
finally:
687
tree.unlock()
688
if tree is not work_tree:
689
work_tree.unlock()
690
691
for path, entry in entries:
692
if kind and kind != entry.kind:
693
continue
694
if show_ids:
695
self.outf.write('%-50s %s\n' % (path, entry.file_id))
696
else:
697
self.outf.write(path)
698
self.outf.write('\n')
699
700
701
class cmd_mv(Command):
702
"""Move or rename a file.
703
704
:Usage:
705
bzr mv OLDNAME NEWNAME
706
707
bzr mv SOURCE... DESTINATION
708
709
If the last argument is a versioned directory, all the other names
710
are moved into it. Otherwise, there must be exactly two arguments
711
and the file is changed to a new name.
712
713
If OLDNAME does not exist on the filesystem but is versioned and
714
NEWNAME does exist on the filesystem but is not versioned, mv
715
assumes that the file has been manually moved and only updates
716
its internal inventory to reflect that change.
717
The same is valid when moving many SOURCE files to a DESTINATION.
718
719
Files cannot be moved between branches.
720
"""
721
722
takes_args = ['names*']
723
takes_options = [Option("after", help="Move only the bzr identifier"
724
" of the file, because the file has already been moved."),
725
Option('auto', help='Automatically guess renames.'),
726
Option('dry-run', help='Avoid making changes when guessing renames.'),
727
]
728
aliases = ['move', 'rename']
729
encoding_type = 'replace'
730
731
def run(self, names_list, after=False, auto=False, dry_run=False):
732
if auto:
733
return self.run_auto(names_list, after, dry_run)
734
elif dry_run:
735
raise errors.BzrCommandError('--dry-run requires --auto.')
736
if names_list is None:
737
names_list = []
738
if len(names_list) < 2:
739
raise errors.BzrCommandError("missing file argument")
740
tree, rel_names = tree_files(names_list, canonicalize=False)
741
tree.lock_write()
742
try:
743
self._run(tree, names_list, rel_names, after)
744
finally:
745
tree.unlock()
746
747
def run_auto(self, names_list, after, dry_run):
748
if names_list is not None and len(names_list) > 1:
749
raise errors.BzrCommandError('Only one path may be specified to'
750
' --auto.')
751
if after:
752
raise errors.BzrCommandError('--after cannot be specified with'
753
' --auto.')
754
work_tree, file_list = tree_files(names_list, default_branch='.')
755
work_tree.lock_write()
756
try:
757
rename_map.RenameMap.guess_renames(work_tree, dry_run)
758
finally:
759
work_tree.unlock()
760
761
def _run(self, tree, names_list, rel_names, after):
762
into_existing = osutils.isdir(names_list[-1])
763
if into_existing and len(names_list) == 2:
764
# special cases:
765
# a. case-insensitive filesystem and change case of dir
766
# b. move directory after the fact (if the source used to be
767
# a directory, but now doesn't exist in the working tree
768
# and the target is an existing directory, just rename it)
769
if (not tree.case_sensitive
770
and rel_names[0].lower() == rel_names[1].lower()):
771
into_existing = False
772
else:
773
inv = tree.inventory
774
# 'fix' the case of a potential 'from'
775
from_id = tree.path2id(
776
tree.get_canonical_inventory_path(rel_names[0]))
777
if (not osutils.lexists(names_list[0]) and
778
from_id and inv.get_file_kind(from_id) == "directory"):
779
into_existing = False
780
# move/rename
781
if into_existing:
782
# move into existing directory
783
# All entries reference existing inventory items, so fix them up
784
# for cicp file-systems.
785
rel_names = tree.get_canonical_inventory_paths(rel_names)
786
for pair in tree.move(rel_names[:-1], rel_names[-1], after=after):
787
self.outf.write("%s => %s\n" % pair)
788
else:
789
if len(names_list) != 2:
790
raise errors.BzrCommandError('to mv multiple files the'
791
' destination must be a versioned'
792
' directory')
793
794
# for cicp file-systems: the src references an existing inventory
795
# item:
796
src = tree.get_canonical_inventory_path(rel_names[0])
797
# Find the canonical version of the destination: In all cases, the
798
# parent of the target must be in the inventory, so we fetch the
799
# canonical version from there (we do not always *use* the
800
# canonicalized tail portion - we may be attempting to rename the
801
# case of the tail)
802
canon_dest = tree.get_canonical_inventory_path(rel_names[1])
803
dest_parent = osutils.dirname(canon_dest)
804
spec_tail = osutils.basename(rel_names[1])
805
# For a CICP file-system, we need to avoid creating 2 inventory
806
# entries that differ only by case. So regardless of the case
807
# we *want* to use (ie, specified by the user or the file-system),
808
# we must always choose to use the case of any existing inventory
809
# items. The only exception to this is when we are attempting a
810
# case-only rename (ie, canonical versions of src and dest are
811
# the same)
812
dest_id = tree.path2id(canon_dest)
813
if dest_id is None or tree.path2id(src) == dest_id:
814
# No existing item we care about, so work out what case we
815
# are actually going to use.
816
if after:
817
# If 'after' is specified, the tail must refer to a file on disk.
818
if dest_parent:
819
dest_parent_fq = osutils.pathjoin(tree.basedir, dest_parent)
820
else:
821
# pathjoin with an empty tail adds a slash, which breaks
822
# relpath :(
823
dest_parent_fq = tree.basedir
824
825
dest_tail = osutils.canonical_relpath(
826
dest_parent_fq,
827
osutils.pathjoin(dest_parent_fq, spec_tail))
828
else:
829
# not 'after', so case as specified is used
830
dest_tail = spec_tail
831
else:
832
# Use the existing item so 'mv' fails with AlreadyVersioned.
833
dest_tail = os.path.basename(canon_dest)
834
dest = osutils.pathjoin(dest_parent, dest_tail)
835
mutter("attempting to move %s => %s", src, dest)
836
tree.rename_one(src, dest, after=after)
837
self.outf.write("%s => %s\n" % (src, dest))
838
839
840
class cmd_pull(Command):
841
"""Turn this branch into a mirror of another branch.
842
843
This command only works on branches that have not diverged. Branches are
844
considered diverged if the destination branch's most recent commit is one
845
that has not been merged (directly or indirectly) into the parent.
846
847
If branches have diverged, you can use 'bzr merge' to integrate the changes
848
from one into the other. Once one branch has merged, the other should
849
be able to pull it again.
850
851
If you want to forget your local changes and just update your branch to
852
match the remote one, use pull --overwrite.
853
854
If there is no default location set, the first pull will set it. After
855
that, you can omit the location to use the default. To change the
856
default, use --remember. The value will only be saved if the remote
857
location can be accessed.
858
859
Note: The location can be specified either in the form of a branch,
860
or in the form of a path to a file containing a merge directive generated
861
with bzr send.
862
"""
863
864
_see_also = ['push', 'update', 'status-flags', 'send']
865
takes_options = ['remember', 'overwrite', 'revision',
866
custom_help('verbose',
867
help='Show logs of pulled revisions.'),
868
Option('directory',
869
help='Branch to pull into, '
870
'rather than the one containing the working directory.',
871
short_name='d',
872
type=unicode,
873
),
874
]
875
takes_args = ['location?']
876
encoding_type = 'replace'
877
878
def run(self, location=None, remember=False, overwrite=False,
879
revision=None, verbose=False,
880
directory=None):
881
# FIXME: too much stuff is in the command class
882
revision_id = None
883
mergeable = None
884
if directory is None:
885
directory = u'.'
886
try:
887
tree_to = WorkingTree.open_containing(directory)[0]
888
branch_to = tree_to.branch
889
except errors.NoWorkingTree:
890
tree_to = None
891
branch_to = Branch.open_containing(directory)[0]
892
893
possible_transports = []
894
if location is not None:
895
try:
896
mergeable = bundle.read_mergeable_from_url(location,
897
possible_transports=possible_transports)
898
except errors.NotABundle:
899
mergeable = None
900
901
stored_loc = branch_to.get_parent()
902
if location is None:
903
if stored_loc is None:
904
raise errors.BzrCommandError("No pull location known or"
905
" specified.")
906
else:
907
display_url = urlutils.unescape_for_display(stored_loc,
908
self.outf.encoding)
909
if not is_quiet():
910
self.outf.write("Using saved parent location: %s\n" % display_url)
911
location = stored_loc
912
913
revision = _get_one_revision('pull', revision)
914
if mergeable is not None:
915
if revision is not None:
916
raise errors.BzrCommandError(
917
'Cannot use -r with merge directives or bundles')
918
mergeable.install_revisions(branch_to.repository)
919
base_revision_id, revision_id, verified = \
920
mergeable.get_merge_request(branch_to.repository)
921
branch_from = branch_to
922
else:
923
branch_from = Branch.open(location,
924
possible_transports=possible_transports)
925
926
if branch_to.get_parent() is None or remember:
927
branch_to.set_parent(branch_from.base)
928
929
if revision is not None:
930
revision_id = revision.as_revision_id(branch_from)
931
932
branch_to.lock_write()
933
try:
934
if tree_to is not None:
935
view_info = _get_view_info_for_change_reporter(tree_to)
936
change_reporter = delta._ChangeReporter(
937
unversioned_filter=tree_to.is_ignored, view_info=view_info)
938
result = tree_to.pull(branch_from, overwrite, revision_id,
939
change_reporter,
940
possible_transports=possible_transports)
941
else:
942
result = branch_to.pull(branch_from, overwrite, revision_id)
943
944
result.report(self.outf)
945
if verbose and result.old_revid != result.new_revid:
946
log.show_branch_change(branch_to, self.outf, result.old_revno,
947
result.old_revid)
948
finally:
949
branch_to.unlock()
950
951
952
class cmd_push(Command):
953
"""Update a mirror of this branch.
954
955
The target branch will not have its working tree populated because this
956
is both expensive, and is not supported on remote file systems.
957
958
Some smart servers or protocols *may* put the working tree in place in
959
the future.
960
961
This command only works on branches that have not diverged. Branches are
962
considered diverged if the destination branch's most recent commit is one
963
that has not been merged (directly or indirectly) by the source branch.
964
965
If branches have diverged, you can use 'bzr push --overwrite' to replace
966
the other branch completely, discarding its unmerged changes.
967
968
If you want to ensure you have the different changes in the other branch,
969
do a merge (see bzr help merge) from the other branch, and commit that.
970
After that you will be able to do a push without '--overwrite'.
971
972
If there is no default push location set, the first push will set it.
973
After that, you can omit the location to use the default. To change the
974
default, use --remember. The value will only be saved if the remote
975
location can be accessed.
976
"""
977
978
_see_also = ['pull', 'update', 'working-trees']
979
takes_options = ['remember', 'overwrite', 'verbose', 'revision',
980
Option('create-prefix',
981
help='Create the path leading up to the branch '
982
'if it does not already exist.'),
983
Option('directory',
984
help='Branch to push from, '
985
'rather than the one containing the working directory.',
986
short_name='d',
987
type=unicode,
988
),
989
Option('use-existing-dir',
990
help='By default push will fail if the target'
991
' directory exists, but does not already'
992
' have a control directory. This flag will'
993
' allow push to proceed.'),
994
Option('stacked',
995
help='Create a stacked branch that references the public location '
996
'of the parent branch.'),
997
Option('stacked-on',
998
help='Create a stacked branch that refers to another branch '
999
'for the commit history. Only the work not present in the '
1000
'referenced branch is included in the branch created.',
1001
type=unicode),
1002
]
1003
takes_args = ['location?']
1004
encoding_type = 'replace'
1005
1006
def run(self, location=None, remember=False, overwrite=False,
1007
create_prefix=False, verbose=False, revision=None,
1008
use_existing_dir=False, directory=None, stacked_on=None,
1009
stacked=False):
1010
from bzrlib.push import _show_push_branch
1011
1012
# Get the source branch and revision_id
1013
if directory is None:
1014
directory = '.'
1015
br_from = Branch.open_containing(directory)[0]
1016
revision = _get_one_revision('push', revision)
1017
if revision is not None:
1018
revision_id = revision.in_history(br_from).rev_id
1019
else:
1020
revision_id = br_from.last_revision()
1021
1022
# Get the stacked_on branch, if any
1023
if stacked_on is not None:
1024
stacked_on = urlutils.normalize_url(stacked_on)
1025
elif stacked:
1026
parent_url = br_from.get_parent()
1027
if parent_url:
1028
parent = Branch.open(parent_url)
1029
stacked_on = parent.get_public_branch()
1030
if not stacked_on:
1031
# I considered excluding non-http url's here, thus forcing
1032
# 'public' branches only, but that only works for some
1033
# users, so it's best to just depend on the user spotting an
1034
# error by the feedback given to them. RBC 20080227.
1035
stacked_on = parent_url
1036
if not stacked_on:
1037
raise errors.BzrCommandError(
1038
"Could not determine branch to refer to.")
1039
1040
# Get the destination location
1041
if location is None:
1042
stored_loc = br_from.get_push_location()
1043
if stored_loc is None:
1044
raise errors.BzrCommandError(
1045
"No push location known or specified.")
1046
else:
1047
display_url = urlutils.unescape_for_display(stored_loc,
1048
self.outf.encoding)
1049
self.outf.write("Using saved push location: %s\n" % display_url)
1050
location = stored_loc
1051
1052
_show_push_branch(br_from, revision_id, location, self.outf,
1053
verbose=verbose, overwrite=overwrite, remember=remember,
1054
stacked_on=stacked_on, create_prefix=create_prefix,
1055
use_existing_dir=use_existing_dir)
1056
1057
1058
class cmd_branch(Command):
1059
"""Create a new copy of a branch.
1060
1061
If the TO_LOCATION is omitted, the last component of the FROM_LOCATION will
1062
be used. In other words, "branch ../foo/bar" will attempt to create ./bar.
1063
If the FROM_LOCATION has no / or path separator embedded, the TO_LOCATION
1064
is derived from the FROM_LOCATION by stripping a leading scheme or drive
1065
identifier, if any. For example, "branch lp:foo-bar" will attempt to
1066
create ./foo-bar.
1067
1068
To retrieve the branch as of a particular revision, supply the --revision
1069
parameter, as in "branch foo/bar -r 5".
1070
"""
1071
1072
_see_also = ['checkout']
1073
takes_args = ['from_location', 'to_location?']
1074
takes_options = ['revision', Option('hardlink',
1075
help='Hard-link working tree files where possible.'),
1076
Option('no-tree',
1077
help="Create a branch without a working-tree."),
1078
Option('stacked',
1079
help='Create a stacked branch referring to the source branch. '
1080
'The new branch will depend on the availability of the source '
1081
'branch for all operations.'),
1082
Option('standalone',
1083
help='Do not use a shared repository, even if available.'),
1084
]
1085
aliases = ['get', 'clone']
1086
1087
def run(self, from_location, to_location=None, revision=None,
1088
hardlink=False, stacked=False, standalone=False, no_tree=False):
1089
from bzrlib.tag import _merge_tags_if_possible
1090
1091
accelerator_tree, br_from = bzrdir.BzrDir.open_tree_or_branch(
1092
from_location)
1093
revision = _get_one_revision('branch', revision)
1094
br_from.lock_read()
1095
try:
1096
if revision is not None:
1097
revision_id = revision.as_revision_id(br_from)
1098
else:
1099
# FIXME - wt.last_revision, fallback to branch, fall back to
1100
# None or perhaps NULL_REVISION to mean copy nothing
1101
# RBC 20060209
1102
revision_id = br_from.last_revision()
1103
if to_location is None:
1104
to_location = urlutils.derive_to_location(from_location)
1105
to_transport = transport.get_transport(to_location)
1106
try:
1107
to_transport.mkdir('.')
1108
except errors.FileExists:
1109
raise errors.BzrCommandError('Target directory "%s" already'
1110
' exists.' % to_location)
1111
except errors.NoSuchFile:
1112
raise errors.BzrCommandError('Parent of "%s" does not exist.'
1113
% to_location)
1114
try:
1115
# preserve whatever source format we have.
1116
dir = br_from.bzrdir.sprout(to_transport.base, revision_id,
1117
possible_transports=[to_transport],
1118
accelerator_tree=accelerator_tree,
1119
hardlink=hardlink, stacked=stacked,
1120
force_new_repo=standalone,
1121
create_tree_if_local=not no_tree,
1122
source_branch=br_from)
1123
branch = dir.open_branch()
1124
except errors.NoSuchRevision:
1125
to_transport.delete_tree('.')
1126
msg = "The branch %s has no revision %s." % (from_location,
1127
revision)
1128
raise errors.BzrCommandError(msg)
1129
_merge_tags_if_possible(br_from, branch)
1130
# If the source branch is stacked, the new branch may
1131
# be stacked whether we asked for that explicitly or not.
1132
# We therefore need a try/except here and not just 'if stacked:'
1133
try:
1134
note('Created new stacked branch referring to %s.' %
1135
branch.get_stacked_on_url())
1136
except (errors.NotStacked, errors.UnstackableBranchFormat,
1137
errors.UnstackableRepositoryFormat), e:
1138
note('Branched %d revision(s).' % branch.revno())
1139
finally:
1140
br_from.unlock()
1141
1142
1143
class cmd_checkout(Command):
1144
"""Create a new checkout of an existing branch.
1145
1146
If BRANCH_LOCATION is omitted, checkout will reconstitute a working tree for
1147
the branch found in '.'. This is useful if you have removed the working tree
1148
or if it was never created - i.e. if you pushed the branch to its current
1149
location using SFTP.
1150
1151
If the TO_LOCATION is omitted, the last component of the BRANCH_LOCATION will
1152
be used. In other words, "checkout ../foo/bar" will attempt to create ./bar.
1153
If the BRANCH_LOCATION has no / or path separator embedded, the TO_LOCATION
1154
is derived from the BRANCH_LOCATION by stripping a leading scheme or drive
1155
identifier, if any. For example, "checkout lp:foo-bar" will attempt to
1156
create ./foo-bar.
1157
1158
To retrieve the branch as of a particular revision, supply the --revision
1159
parameter, as in "checkout foo/bar -r 5". Note that this will be immediately
1160
out of date [so you cannot commit] but it may be useful (i.e. to examine old
1161
code.)
1162
"""
1163
1164
_see_also = ['checkouts', 'branch']
1165
takes_args = ['branch_location?', 'to_location?']
1166
takes_options = ['revision',
1167
Option('lightweight',
1168
help="Perform a lightweight checkout. Lightweight "
1169
"checkouts depend on access to the branch for "
1170
"every operation. Normal checkouts can perform "
1171
"common operations like diff and status without "
1172
"such access, and also support local commits."
1173
),
1174
Option('files-from', type=str,
1175
help="Get file contents from this tree."),
1176
Option('hardlink',
1177
help='Hard-link working tree files where possible.'
1178
),
1179
]
1180
aliases = ['co']
1181
1182
def run(self, branch_location=None, to_location=None, revision=None,
1183
lightweight=False, files_from=None, hardlink=False):
1184
if branch_location is None:
1185
branch_location = osutils.getcwd()
1186
to_location = branch_location
1187
accelerator_tree, source = bzrdir.BzrDir.open_tree_or_branch(
1188
branch_location)
1189
revision = _get_one_revision('checkout', revision)
1190
if files_from is not None:
1191
accelerator_tree = WorkingTree.open(files_from)
1192
if revision is not None:
1193
revision_id = revision.as_revision_id(source)
1194
else:
1195
revision_id = None
1196
if to_location is None:
1197
to_location = urlutils.derive_to_location(branch_location)
1198
# if the source and to_location are the same,
1199
# and there is no working tree,
1200
# then reconstitute a branch
1201
if (osutils.abspath(to_location) ==
1202
osutils.abspath(branch_location)):
1203
try:
1204
source.bzrdir.open_workingtree()
1205
except errors.NoWorkingTree:
1206
source.bzrdir.create_workingtree(revision_id)
1207
return
1208
source.create_checkout(to_location, revision_id, lightweight,
1209
accelerator_tree, hardlink)
1210
1211
1212
class cmd_renames(Command):
1213
"""Show list of renamed files.
1214
"""
1215
# TODO: Option to show renames between two historical versions.
1216
1217
# TODO: Only show renames under dir, rather than in the whole branch.
1218
_see_also = ['status']
1219
takes_args = ['dir?']
1220
1221
@display_command
1222
def run(self, dir=u'.'):
1223
tree = WorkingTree.open_containing(dir)[0]
1224
tree.lock_read()
1225
try:
1226
new_inv = tree.inventory
1227
old_tree = tree.basis_tree()
1228
old_tree.lock_read()
1229
try:
1230
old_inv = old_tree.inventory
1231
renames = []
1232
iterator = tree.iter_changes(old_tree, include_unchanged=True)
1233
for f, paths, c, v, p, n, k, e in iterator:
1234
if paths[0] == paths[1]:
1235
continue
1236
if None in (paths):
1237
continue
1238
renames.append(paths)
1239
renames.sort()
1240
for old_name, new_name in renames:
1241
self.outf.write("%s => %s\n" % (old_name, new_name))
1242
finally:
1243
old_tree.unlock()
1244
finally:
1245
tree.unlock()
1246
1247
1248
class cmd_update(Command):
1249
"""Update a tree to have the latest code committed to its branch.
1250
1251
This will perform a merge into the working tree, and may generate
1252
conflicts. If you have any local changes, you will still
1253
need to commit them after the update for the update to be complete.
1254
1255
If you want to discard your local changes, you can just do a
1256
'bzr revert' instead of 'bzr commit' after the update.
1257
"""
1258
1259
_see_also = ['pull', 'working-trees', 'status-flags']
1260
takes_args = ['dir?']
1261
aliases = ['up']
1262
1263
def run(self, dir='.'):
1264
tree = WorkingTree.open_containing(dir)[0]
1265
possible_transports = []
1266
master = tree.branch.get_master_branch(
1267
possible_transports=possible_transports)
1268
if master is not None:
1269
tree.lock_write()
1270
else:
1271
tree.lock_tree_write()
1272
try:
1273
existing_pending_merges = tree.get_parent_ids()[1:]
1274
last_rev = _mod_revision.ensure_null(tree.last_revision())
1275
if last_rev == _mod_revision.ensure_null(
1276
tree.branch.last_revision()):
1277
# may be up to date, check master too.
1278
if master is None or last_rev == _mod_revision.ensure_null(
1279
master.last_revision()):
1280
revno = tree.branch.revision_id_to_revno(last_rev)
1281
note("Tree is up to date at revision %d." % (revno,))
1282
return 0
1283
view_info = _get_view_info_for_change_reporter(tree)
1284
conflicts = tree.update(
1285
delta._ChangeReporter(unversioned_filter=tree.is_ignored,
1286
view_info=view_info), possible_transports=possible_transports)
1287
revno = tree.branch.revision_id_to_revno(
1288
_mod_revision.ensure_null(tree.last_revision()))
1289
note('Updated to revision %d.' % (revno,))
1290
if tree.get_parent_ids()[1:] != existing_pending_merges:
1291
note('Your local commits will now show as pending merges with '
1292
"'bzr status', and can be committed with 'bzr commit'.")
1293
if conflicts != 0:
1294
return 1
1295
else:
1296
return 0
1297
finally:
1298
tree.unlock()
1299
1300
1301
class cmd_info(Command):
1302
"""Show information about a working tree, branch or repository.
1303
1304
This command will show all known locations and formats associated to the
1305
tree, branch or repository.
1306
1307
In verbose mode, statistical information is included with each report.
1308
To see extended statistic information, use a verbosity level of 2 or
1309
higher by specifying the verbose option multiple times, e.g. -vv.
1310
1311
Branches and working trees will also report any missing revisions.
1312
1313
:Examples:
1314
1315
Display information on the format and related locations:
1316
1317
bzr info
1318
1319
Display the above together with extended format information and
1320
basic statistics (like the number of files in the working tree and
1321
number of revisions in the branch and repository):
1322
1323
bzr info -v
1324
1325
Display the above together with number of committers to the branch:
1326
1327
bzr info -vv
1328
"""
1329
_see_also = ['revno', 'working-trees', 'repositories']
1330
takes_args = ['location?']
1331
takes_options = ['verbose']
1332
encoding_type = 'replace'
1333
1334
@display_command
1335
def run(self, location=None, verbose=False):
1336
if verbose:
1337
noise_level = get_verbosity_level()
1338
else:
1339
noise_level = 0
1340
from bzrlib.info import show_bzrdir_info
1341
show_bzrdir_info(bzrdir.BzrDir.open_containing(location)[0],
1342
verbose=noise_level, outfile=self.outf)
1343
1344
1345
class cmd_remove(Command):
1346
"""Remove files or directories.
1347
1348
This makes bzr stop tracking changes to the specified files. bzr will delete
1349
them if they can easily be recovered using revert. If no options or
1350
parameters are given bzr will scan for files that are being tracked by bzr
1351
but missing in your tree and stop tracking them for you.
1352
"""
1353
takes_args = ['file*']
1354
takes_options = ['verbose',
1355
Option('new', help='Only remove files that have never been committed.'),
1356
RegistryOption.from_kwargs('file-deletion-strategy',
1357
'The file deletion mode to be used.',
1358
title='Deletion Strategy', value_switches=True, enum_switch=False,
1359
safe='Only delete files if they can be'
1360
' safely recovered (default).',
1361
keep="Don't delete any files.",
1362
force='Delete all the specified files, even if they can not be '
1363
'recovered and even if they are non-empty directories.')]
1364
aliases = ['rm', 'del']
1365
encoding_type = 'replace'
1366
1367
def run(self, file_list, verbose=False, new=False,
1368
file_deletion_strategy='safe'):
1369
tree, file_list = tree_files(file_list)
1370
1371
if file_list is not None:
1372
file_list = [f for f in file_list]
1373
1374
tree.lock_write()
1375
try:
1376
# Heuristics should probably all move into tree.remove_smart or
1377
# some such?
1378
if new:
1379
added = tree.changes_from(tree.basis_tree(),
1380
specific_files=file_list).added
1381
file_list = sorted([f[0] for f in added], reverse=True)
1382
if len(file_list) == 0:
1383
raise errors.BzrCommandError('No matching files.')
1384
elif file_list is None:
1385
# missing files show up in iter_changes(basis) as
1386
# versioned-with-no-kind.
1387
missing = []
1388
for change in tree.iter_changes(tree.basis_tree()):
1389
# Find paths in the working tree that have no kind:
1390
if change[1][1] is not None and change[6][1] is None:
1391
missing.append(change[1][1])
1392
file_list = sorted(missing, reverse=True)
1393
file_deletion_strategy = 'keep'
1394
tree.remove(file_list, verbose=verbose, to_file=self.outf,
1395
keep_files=file_deletion_strategy=='keep',
1396
force=file_deletion_strategy=='force')
1397
finally:
1398
tree.unlock()
1399
1400
1401
class cmd_file_id(Command):
1402
"""Print file_id of a particular file or directory.
1403
1404
The file_id is assigned when the file is first added and remains the
1405
same through all revisions where the file exists, even when it is
1406
moved or renamed.
1407
"""
1408
1409
hidden = True
1410
_see_also = ['inventory', 'ls']
1411
takes_args = ['filename']
1412
1413
@display_command
1414
def run(self, filename):
1415
tree, relpath = WorkingTree.open_containing(filename)
1416
i = tree.path2id(relpath)
1417
if i is None:
1418
raise errors.NotVersionedError(filename)
1419
else:
1420
self.outf.write(i + '\n')
1421
1422
1423
class cmd_file_path(Command):
1424
"""Print path of file_ids to a file or directory.
1425
1426
This prints one line for each directory down to the target,
1427
starting at the branch root.
1428
"""
1429
1430
hidden = True
1431
takes_args = ['filename']
1432
1433
@display_command
1434
def run(self, filename):
1435
tree, relpath = WorkingTree.open_containing(filename)
1436
fid = tree.path2id(relpath)
1437
if fid is None:
1438
raise errors.NotVersionedError(filename)
1439
segments = osutils.splitpath(relpath)
1440
for pos in range(1, len(segments) + 1):
1441
path = osutils.joinpath(segments[:pos])
1442
self.outf.write("%s\n" % tree.path2id(path))
1443
1444
1445
class cmd_reconcile(Command):
1446
"""Reconcile bzr metadata in a branch.
1447
1448
This can correct data mismatches that may have been caused by
1449
previous ghost operations or bzr upgrades. You should only
1450
need to run this command if 'bzr check' or a bzr developer
1451
advises you to run it.
1452
1453
If a second branch is provided, cross-branch reconciliation is
1454
also attempted, which will check that data like the tree root
1455
id which was not present in very early bzr versions is represented
1456
correctly in both branches.
1457
1458
At the same time it is run it may recompress data resulting in
1459
a potential saving in disk space or performance gain.
1460
1461
The branch *MUST* be on a listable system such as local disk or sftp.
1462
"""
1463
1464
_see_also = ['check']
1465
takes_args = ['branch?']
1466
1467
def run(self, branch="."):
1468
from bzrlib.reconcile import reconcile
1469
dir = bzrdir.BzrDir.open(branch)
1470
reconcile(dir)
1471
1472
1473
class cmd_revision_history(Command):
1474
"""Display the list of revision ids on a branch."""
1475
1476
_see_also = ['log']
1477
takes_args = ['location?']
1478
1479
hidden = True
1480
1481
@display_command
1482
def run(self, location="."):
1483
branch = Branch.open_containing(location)[0]
1484
for revid in branch.revision_history():
1485
self.outf.write(revid)
1486
self.outf.write('\n')
1487
1488
1489
class cmd_ancestry(Command):
1490
"""List all revisions merged into this branch."""
1491
1492
_see_also = ['log', 'revision-history']
1493
takes_args = ['location?']
1494
1495
hidden = True
1496
1497
@display_command
1498
def run(self, location="."):
1499
try:
1500
wt = WorkingTree.open_containing(location)[0]
1501
except errors.NoWorkingTree:
1502
b = Branch.open(location)
1503
last_revision = b.last_revision()
1504
else:
1505
b = wt.branch
1506
last_revision = wt.last_revision()
1507
1508
revision_ids = b.repository.get_ancestry(last_revision)
1509
revision_ids.pop(0)
1510
for revision_id in revision_ids:
1511
self.outf.write(revision_id + '\n')
1512
1513
1514
class cmd_init(Command):
1515
"""Make a directory into a versioned branch.
1516
1517
Use this to create an empty branch, or before importing an
1518
existing project.
1519
1520
If there is a repository in a parent directory of the location, then
1521
the history of the branch will be stored in the repository. Otherwise
1522
init creates a standalone branch which carries its own history
1523
in the .bzr directory.
1524
1525
If there is already a branch at the location but it has no working tree,
1526
the tree can be populated with 'bzr checkout'.
1527
1528
Recipe for importing a tree of files::
1529
1530
cd ~/project
1531
bzr init
1532
bzr add .
1533
bzr status
1534
bzr commit -m "imported project"
1535
"""
1536
1537
_see_also = ['init-repository', 'branch', 'checkout']
1538
takes_args = ['location?']
1539
takes_options = [
1540
Option('create-prefix',
1541
help='Create the path leading up to the branch '
1542
'if it does not already exist.'),
1543
RegistryOption('format',
1544
help='Specify a format for this branch. '
1545
'See "help formats".',
1546
lazy_registry=('bzrlib.bzrdir', 'format_registry'),
1547
converter=lambda name: bzrdir.format_registry.make_bzrdir(name),
1548
value_switches=True,
1549
title="Branch Format",
1550
),
1551
Option('append-revisions-only',
1552
help='Never change revnos or the existing log.'
1553
' Append revisions to it only.')
1554
]
1555
def run(self, location=None, format=None, append_revisions_only=False,
1556
create_prefix=False):
1557
if format is None:
1558
format = bzrdir.format_registry.make_bzrdir('default')
1559
if location is None:
1560
location = u'.'
1561
1562
to_transport = transport.get_transport(location)
1563
1564
# The path has to exist to initialize a
1565
# branch inside of it.
1566
# Just using os.mkdir, since I don't
1567
# believe that we want to create a bunch of
1568
# locations if the user supplies an extended path
1569
try:
1570
to_transport.ensure_base()
1571
except errors.NoSuchFile:
1572
if not create_prefix:
1573
raise errors.BzrCommandError("Parent directory of %s"
1574
" does not exist."
1575
"\nYou may supply --create-prefix to create all"
1576
" leading parent directories."
1577
% location)
1578
_create_prefix(to_transport)
1579
1580
try:
1581
a_bzrdir = bzrdir.BzrDir.open_from_transport(to_transport)
1582
except errors.NotBranchError:
1583
# really a NotBzrDir error...
1584
create_branch = bzrdir.BzrDir.create_branch_convenience
1585
branch = create_branch(to_transport.base, format=format,
1586
possible_transports=[to_transport])
1587
a_bzrdir = branch.bzrdir
1588
else:
1589
from bzrlib.transport.local import LocalTransport
1590
if a_bzrdir.has_branch():
1591
if (isinstance(to_transport, LocalTransport)
1592
and not a_bzrdir.has_workingtree()):
1593
raise errors.BranchExistsWithoutWorkingTree(location)
1594
raise errors.AlreadyBranchError(location)
1595
branch = a_bzrdir.create_branch()
1596
a_bzrdir.create_workingtree()
1597
if append_revisions_only:
1598
try:
1599
branch.set_append_revisions_only(True)
1600
except errors.UpgradeRequired:
1601
raise errors.BzrCommandError('This branch format cannot be set'
1602
' to append-revisions-only. Try --experimental-branch6')
1603
if not is_quiet():
1604
from bzrlib.info import describe_layout, describe_format
1605
try:
1606
tree = a_bzrdir.open_workingtree(recommend_upgrade=False)
1607
except (errors.NoWorkingTree, errors.NotLocalUrl):
1608
tree = None
1609
repository = branch.repository
1610
layout = describe_layout(repository, branch, tree).lower()
1611
format = describe_format(a_bzrdir, repository, branch, tree)
1612
self.outf.write("Created a %s (format: %s)\n" % (layout, format))
1613
if repository.is_shared():
1614
#XXX: maybe this can be refactored into transport.path_or_url()
1615
url = repository.bzrdir.root_transport.external_url()
1616
try:
1617
url = urlutils.local_path_from_url(url)
1618
except errors.InvalidURL:
1619
pass
1620
self.outf.write("Using shared repository: %s\n" % url)
1621
1622
1623
class cmd_init_repository(Command):
1624
"""Create a shared repository to hold branches.
1625
1626
New branches created under the repository directory will store their
1627
revisions in the repository, not in the branch directory.
1628
1629
If the --no-trees option is used then the branches in the repository
1630
will not have working trees by default.
1631
1632
:Examples:
1633
Create a shared repositories holding just branches::
1634
1635
bzr init-repo --no-trees repo
1636
bzr init repo/trunk
1637
1638
Make a lightweight checkout elsewhere::
1639
1640
bzr checkout --lightweight repo/trunk trunk-checkout
1641
cd trunk-checkout
1642
(add files here)
1643
"""
1644
1645
_see_also = ['init', 'branch', 'checkout', 'repositories']
1646
takes_args = ["location"]
1647
takes_options = [RegistryOption('format',
1648
help='Specify a format for this repository. See'
1649
' "bzr help formats" for details.',
1650
lazy_registry=('bzrlib.bzrdir', 'format_registry'),
1651
converter=lambda name: bzrdir.format_registry.make_bzrdir(name),
1652
value_switches=True, title='Repository format'),
1653
Option('no-trees',
1654
help='Branches in the repository will default to'
1655
' not having a working tree.'),
1656
]
1657
aliases = ["init-repo"]
1658
1659
def run(self, location, format=None, no_trees=False):
1660
if format is None:
1661
format = bzrdir.format_registry.make_bzrdir('default')
1662
1663
if location is None:
1664
location = '.'
1665
1666
to_transport = transport.get_transport(location)
1667
to_transport.ensure_base()
1668
1669
newdir = format.initialize_on_transport(to_transport)
1670
repo = newdir.create_repository(shared=True)
1671
repo.set_make_working_trees(not no_trees)
1672
if not is_quiet():
1673
from bzrlib.info import show_bzrdir_info
1674
show_bzrdir_info(repo.bzrdir, verbose=0, outfile=self.outf)
1675
1676
1677
class cmd_diff(Command):
1678
"""Show differences in the working tree, between revisions or branches.
1679
1680
If no arguments are given, all changes for the current tree are listed.
1681
If files are given, only the changes in those files are listed.
1682
Remote and multiple branches can be compared by using the --old and
1683
--new options. If not provided, the default for both is derived from
1684
the first argument, if any, or the current tree if no arguments are
1685
given.
1686
1687
"bzr diff -p1" is equivalent to "bzr diff --prefix old/:new/", and
1688
produces patches suitable for "patch -p1".
1689
1690
:Exit values:
1691
1 - changed
1692
2 - unrepresentable changes
1693
3 - error
1694
0 - no change
1695
1696
:Examples:
1697
Shows the difference in the working tree versus the last commit::
1698
1699
bzr diff
1700
1701
Difference between the working tree and revision 1::
1702
1703
bzr diff -r1
1704
1705
Difference between revision 2 and revision 1::
1706
1707
bzr diff -r1..2
1708
1709
Difference between revision 2 and revision 1 for branch xxx::
1710
1711
bzr diff -r1..2 xxx
1712
1713
Show just the differences for file NEWS::
1714
1715
bzr diff NEWS
1716
1717
Show the differences in working tree xxx for file NEWS::
1718
1719
bzr diff xxx/NEWS
1720
1721
Show the differences from branch xxx to this working tree:
1722
1723
bzr diff --old xxx
1724
1725
Show the differences between two branches for file NEWS::
1726
1727
bzr diff --old xxx --new yyy NEWS
1728
1729
Same as 'bzr diff' but prefix paths with old/ and new/::
1730
1731
bzr diff --prefix old/:new/
1732
"""
1733
_see_also = ['status']
1734
takes_args = ['file*']
1735
takes_options = [
1736
Option('diff-options', type=str,
1737
help='Pass these options to the external diff program.'),
1738
Option('prefix', type=str,
1739
short_name='p',
1740
help='Set prefixes added to old and new filenames, as '
1741
'two values separated by a colon. (eg "old/:new/").'),
1742
Option('old',
1743
help='Branch/tree to compare from.',
1744
type=unicode,
1745
),
1746
Option('new',
1747
help='Branch/tree to compare to.',
1748
type=unicode,
1749
),
1750
'revision',
1751
'change',
1752
Option('using',
1753
help='Use this command to compare files.',
1754
type=unicode,
1755
),
1756
]
1757
aliases = ['di', 'dif']
1758
encoding_type = 'exact'
1759
1760
@display_command
1761
def run(self, revision=None, file_list=None, diff_options=None,
1762
prefix=None, old=None, new=None, using=None):
1763
from bzrlib.diff import _get_trees_to_diff, show_diff_trees
1764
1765
if (prefix is None) or (prefix == '0'):
1766
# diff -p0 format
1767
old_label = ''
1768
new_label = ''
1769
elif prefix == '1':
1770
old_label = 'old/'
1771
new_label = 'new/'
1772
elif ':' in prefix:
1773
old_label, new_label = prefix.split(":")
1774
else:
1775
raise errors.BzrCommandError(
1776
'--prefix expects two values separated by a colon'
1777
' (eg "old/:new/")')
1778
1779
if revision and len(revision) > 2:
1780
raise errors.BzrCommandError('bzr diff --revision takes exactly'
1781
' one or two revision specifiers')
1782
1783
old_tree, new_tree, specific_files, extra_trees = \
1784
_get_trees_to_diff(file_list, revision, old, new,
1785
apply_view=True)
1786
return show_diff_trees(old_tree, new_tree, sys.stdout,
1787
specific_files=specific_files,
1788
external_diff_options=diff_options,
1789
old_label=old_label, new_label=new_label,
1790
extra_trees=extra_trees, using=using)
1791
1792
1793
class cmd_deleted(Command):
1794
"""List files deleted in the working tree.
1795
"""
1796
# TODO: Show files deleted since a previous revision, or
1797
# between two revisions.
1798
# TODO: Much more efficient way to do this: read in new
1799
# directories with readdir, rather than stating each one. Same
1800
# level of effort but possibly much less IO. (Or possibly not,
1801
# if the directories are very large...)
1802
_see_also = ['status', 'ls']
1803
takes_options = ['show-ids']
1804
1805
@display_command
1806
def run(self, show_ids=False):
1807
tree = WorkingTree.open_containing(u'.')[0]
1808
tree.lock_read()
1809
try:
1810
old = tree.basis_tree()
1811
old.lock_read()
1812
try:
1813
for path, ie in old.inventory.iter_entries():
1814
if not tree.has_id(ie.file_id):
1815
self.outf.write(path)
1816
if show_ids:
1817
self.outf.write(' ')
1818
self.outf.write(ie.file_id)
1819
self.outf.write('\n')
1820
finally:
1821
old.unlock()
1822
finally:
1823
tree.unlock()
1824
1825
1826
class cmd_modified(Command):
1827
"""List files modified in working tree.
1828
"""
1829
1830
hidden = True
1831
_see_also = ['status', 'ls']
1832
takes_options = [
1833
Option('null',
1834
help='Write an ascii NUL (\\0) separator '
1835
'between files rather than a newline.')
1836
]
1837
1838
@display_command
1839
def run(self, null=False):
1840
tree = WorkingTree.open_containing(u'.')[0]
1841
td = tree.changes_from(tree.basis_tree())
1842
for path, id, kind, text_modified, meta_modified in td.modified:
1843
if null:
1844
self.outf.write(path + '\0')
1845
else:
1846
self.outf.write(osutils.quotefn(path) + '\n')
1847
1848
1849
class cmd_added(Command):
1850
"""List files added in working tree.
1851
"""
1852
1853
hidden = True
1854
_see_also = ['status', 'ls']
1855
takes_options = [
1856
Option('null',
1857
help='Write an ascii NUL (\\0) separator '
1858
'between files rather than a newline.')
1859
]
1860
1861
@display_command
1862
def run(self, null=False):
1863
wt = WorkingTree.open_containing(u'.')[0]
1864
wt.lock_read()
1865
try:
1866
basis = wt.basis_tree()
1867
basis.lock_read()
1868
try:
1869
basis_inv = basis.inventory
1870
inv = wt.inventory
1871
for file_id in inv:
1872
if file_id in basis_inv:
1873
continue
1874
if inv.is_root(file_id) and len(basis_inv) == 0:
1875
continue
1876
path = inv.id2path(file_id)
1877
if not os.access(osutils.abspath(path), os.F_OK):
1878
continue
1879
if null:
1880
self.outf.write(path + '\0')
1881
else:
1882
self.outf.write(osutils.quotefn(path) + '\n')
1883
finally:
1884
basis.unlock()
1885
finally:
1886
wt.unlock()
1887
1888
1889
class cmd_root(Command):
1890
"""Show the tree root directory.
1891
1892
The root is the nearest enclosing directory with a .bzr control
1893
directory."""
1894
1895
takes_args = ['filename?']
1896
@display_command
1897
def run(self, filename=None):
1898
"""Print the branch root."""
1899
tree = WorkingTree.open_containing(filename)[0]
1900
self.outf.write(tree.basedir + '\n')
1901
1902
1903
def _parse_limit(limitstring):
1904
try:
1905
return int(limitstring)
1906
except ValueError:
1907
msg = "The limit argument must be an integer."
1908
raise errors.BzrCommandError(msg)
1909
1910
1911
def _parse_levels(s):
1912
try:
1913
return int(s)
1914
except ValueError:
1915
msg = "The levels argument must be an integer."
1916
raise errors.BzrCommandError(msg)
1917
1918
1919
class cmd_log(Command):
1920
"""Show historical log for a branch or subset of a branch.
1921
1922
log is bzr's default tool for exploring the history of a branch.
1923
The branch to use is taken from the first parameter. If no parameters
1924
are given, the branch containing the working directory is logged.
1925
Here are some simple examples::
1926
1927
bzr log log the current branch
1928
bzr log foo.py log a file in its branch
1929
bzr log http://server/branch log a branch on a server
1930
1931
The filtering, ordering and information shown for each revision can
1932
be controlled as explained below. By default, all revisions are
1933
shown sorted (topologically) so that newer revisions appear before
1934
older ones and descendants always appear before ancestors. If displayed,
1935
merged revisions are shown indented under the revision in which they
1936
were merged.
1937
1938
:Output control:
1939
1940
The log format controls how information about each revision is
1941
displayed. The standard log formats are called ``long``, ``short``
1942
and ``line``. The default is long. See ``bzr help log-formats``
1943
for more details on log formats.
1944
1945
The following options can be used to control what information is
1946
displayed::
1947
1948
-l N display a maximum of N revisions
1949
-n N display N levels of revisions (0 for all, 1 for collapsed)
1950
-v display a status summary (delta) for each revision
1951
-p display a diff (patch) for each revision
1952
--show-ids display revision-ids (and file-ids), not just revnos
1953
1954
Note that the default number of levels to display is a function of the
1955
log format. If the -n option is not used, the standard log formats show
1956
just the top level (mainline).
1957
1958
Status summaries are shown using status flags like A, M, etc. To see
1959
the changes explained using words like ``added`` and ``modified``
1960
instead, use the -vv option.
1961
1962
:Ordering control:
1963
1964
To display revisions from oldest to newest, use the --forward option.
1965
In most cases, using this option will have little impact on the total
1966
time taken to produce a log, though --forward does not incrementally
1967
display revisions like --reverse does when it can.
1968
1969
:Revision filtering:
1970
1971
The -r option can be used to specify what revision or range of revisions
1972
to filter against. The various forms are shown below::
1973
1974
-rX display revision X
1975
-rX.. display revision X and later
1976
-r..Y display up to and including revision Y
1977
-rX..Y display from X to Y inclusive
1978
1979
See ``bzr help revisionspec`` for details on how to specify X and Y.
1980
Some common examples are given below::
1981
1982
-r-1 show just the tip
1983
-r-10.. show the last 10 mainline revisions
1984
-rsubmit:.. show what's new on this branch
1985
-rancestor:path.. show changes since the common ancestor of this
1986
branch and the one at location path
1987
-rdate:yesterday.. show changes since yesterday
1988
1989
When logging a range of revisions using -rX..Y, log starts at
1990
revision Y and searches back in history through the primary
1991
("left-hand") parents until it finds X. When logging just the
1992
top level (using -n1), an error is reported if X is not found
1993
along the way. If multi-level logging is used (-n0), X may be
1994
a nested merge revision and the log will be truncated accordingly.
1995
1996
:Path filtering:
1997
1998
If parameters are given and the first one is not a branch, the log
1999
will be filtered to show only those revisions that changed the
2000
nominated files or directories.
2001
2002
Filenames are interpreted within their historical context. To log a
2003
deleted file, specify a revision range so that the file existed at
2004
the end or start of the range.
2005
2006
Historical context is also important when interpreting pathnames of
2007
renamed files/directories. Consider the following example:
2008
2009
* revision 1: add tutorial.txt
2010
* revision 2: modify tutorial.txt
2011
* revision 3: rename tutorial.txt to guide.txt; add tutorial.txt
2012
2013
In this case:
2014
2015
* ``bzr log guide.txt`` will log the file added in revision 1
2016
2017
* ``bzr log tutorial.txt`` will log the new file added in revision 3
2018
2019
* ``bzr log -r2 -p tutorial.txt`` will show the changes made to
2020
the original file in revision 2.
2021
2022
* ``bzr log -r2 -p guide.txt`` will display an error message as there
2023
was no file called guide.txt in revision 2.
2024
2025
Renames are always followed by log. By design, there is no need to
2026
explicitly ask for this (and no way to stop logging a file back
2027
until it was last renamed).
2028
2029
:Other filtering:
2030
2031
The --message option can be used for finding revisions that match a
2032
regular expression in a commit message.
2033
2034
:Tips & tricks:
2035
2036
GUI tools and IDEs are often better at exploring history than command
2037
line tools. You may prefer qlog or glog from the QBzr and Bzr-Gtk packages
2038
respectively for example. (TortoiseBzr uses qlog for displaying logs.) See
2039
http://bazaar-vcs.org/BzrPlugins and http://bazaar-vcs.org/IDEIntegration.
2040
2041
Web interfaces are often better at exploring history than command line
2042
tools, particularly for branches on servers. You may prefer Loggerhead
2043
or one of its alternatives. See http://bazaar-vcs.org/WebInterface.
2044
2045
You may find it useful to add the aliases below to ``bazaar.conf``::
2046
2047
[ALIASES]
2048
tip = log -r-1
2049
top = log -l10 --line
2050
show = log -v -p
2051
2052
``bzr tip`` will then show the latest revision while ``bzr top``
2053
will show the last 10 mainline revisions. To see the details of a
2054
particular revision X, ``bzr show -rX``.
2055
2056
If you are interested in looking deeper into a particular merge X,
2057
use ``bzr log -n0 -rX``.
2058
2059
``bzr log -v`` on a branch with lots of history is currently
2060
very slow. A fix for this issue is currently under development.
2061
With or without that fix, it is recommended that a revision range
2062
be given when using the -v option.
2063
2064
bzr has a generic full-text matching plugin, bzr-search, that can be
2065
used to find revisions matching user names, commit messages, etc.
2066
Among other features, this plugin can find all revisions containing
2067
a list of words but not others.
2068
2069
When exploring non-mainline history on large projects with deep
2070
history, the performance of log can be greatly improved by installing
2071
the revnocache plugin. This plugin buffers historical information
2072
trading disk space for faster speed.
2073
"""
2074
takes_args = ['file*']
2075
_see_also = ['log-formats', 'revisionspec']
2076
takes_options = [
2077
Option('forward',
2078
help='Show from oldest to newest.'),
2079
'timezone',
2080
custom_help('verbose',
2081
help='Show files changed in each revision.'),
2082
'show-ids',
2083
'revision',
2084
Option('change',
2085
type=bzrlib.option._parse_revision_str,
2086
short_name='c',
2087
help='Show just the specified revision.'
2088
' See also "help revisionspec".'),
2089
'log-format',
2090
Option('levels',
2091
short_name='n',
2092
help='Number of levels to display - 0 for all, 1 for flat.',
2093
argname='N',
2094
type=_parse_levels),
2095
Option('message',
2096
short_name='m',
2097
help='Show revisions whose message matches this '
2098
'regular expression.',
2099
type=str),
2100
Option('limit',
2101
short_name='l',
2102
help='Limit the output to the first N revisions.',
2103
argname='N',
2104
type=_parse_limit),
2105
Option('show-diff',
2106
short_name='p',
2107
help='Show changes made in each revision as a patch.'),
2108
]
2109
encoding_type = 'replace'
2110
2111
@display_command
2112
def run(self, file_list=None, timezone='original',
2113
verbose=False,
2114
show_ids=False,
2115
forward=False,
2116
revision=None,
2117
change=None,
2118
log_format=None,
2119
levels=None,
2120
message=None,
2121
limit=None,
2122
show_diff=False):
2123
from bzrlib.log import (
2124
Logger,
2125
make_log_request_dict,
2126
_get_info_for_log_files,
2127
)
2128
direction = (forward and 'forward') or 'reverse'
2129
2130
if change is not None:
2131
if len(change) > 1:
2132
raise errors.RangeInChangeOption()
2133
if revision is not None:
2134
raise errors.BzrCommandError(
2135
'--revision and --change are mutually exclusive')
2136
else:
2137
revision = change
2138
2139
file_ids = []
2140
filter_by_dir = False
2141
if file_list:
2142
# find the file ids to log and check for directory filtering
2143
b, file_info_list, rev1, rev2 = _get_info_for_log_files(revision,
2144
file_list)
2145
for relpath, file_id, kind in file_info_list:
2146
if file_id is None:
2147
raise errors.BzrCommandError(
2148
"Path unknown at end or start of revision range: %s" %
2149
relpath)
2150
# If the relpath is the top of the tree, we log everything
2151
if relpath == '':
2152
file_ids = []
2153
break
2154
else:
2155
file_ids.append(file_id)
2156
filter_by_dir = filter_by_dir or (
2157
kind in ['directory', 'tree-reference'])
2158
else:
2159
# log everything
2160
# FIXME ? log the current subdir only RBC 20060203
2161
if revision is not None \
2162
and len(revision) > 0 and revision[0].get_branch():
2163
location = revision[0].get_branch()
2164
else:
2165
location = '.'
2166
dir, relpath = bzrdir.BzrDir.open_containing(location)
2167
b = dir.open_branch()
2168
rev1, rev2 = _get_revision_range(revision, b, self.name())
2169
2170
# Decide on the type of delta & diff filtering to use
2171
# TODO: add an --all-files option to make this configurable & consistent
2172
if not verbose:
2173
delta_type = None
2174
else:
2175
delta_type = 'full'
2176
if not show_diff:
2177
diff_type = None
2178
elif file_ids:
2179
diff_type = 'partial'
2180
else:
2181
diff_type = 'full'
2182
2183
b.lock_read()
2184
try:
2185
# Build the log formatter
2186
if log_format is None:
2187
log_format = log.log_formatter_registry.get_default(b)
2188
lf = log_format(show_ids=show_ids, to_file=self.outf,
2189
show_timezone=timezone,
2190
delta_format=get_verbosity_level(),
2191
levels=levels)
2192
2193
# Choose the algorithm for doing the logging. It's annoying
2194
# having multiple code paths like this but necessary until
2195
# the underlying repository format is faster at generating
2196
# deltas or can provide everything we need from the indices.
2197
# The default algorithm - match-using-deltas - works for
2198
# multiple files and directories and is faster for small
2199
# amounts of history (200 revisions say). However, it's too
2200
# slow for logging a single file in a repository with deep
2201
# history, i.e. > 10K revisions. In the spirit of "do no
2202
# evil when adding features", we continue to use the
2203
# original algorithm - per-file-graph - for the "single
2204
# file that isn't a directory without showing a delta" case.
2205
partial_history = revision and b.repository._format.supports_chks
2206
match_using_deltas = (len(file_ids) != 1 or filter_by_dir
2207
or delta_type or partial_history)
2208
2209
# Build the LogRequest and execute it
2210
if len(file_ids) == 0:
2211
file_ids = None
2212
rqst = make_log_request_dict(
2213
direction=direction, specific_fileids=file_ids,
2214
start_revision=rev1, end_revision=rev2, limit=limit,
2215
message_search=message, delta_type=delta_type,
2216
diff_type=diff_type, _match_using_deltas=match_using_deltas)
2217
Logger(b, rqst).show(lf)
2218
finally:
2219
b.unlock()
2220
2221
2222
def _get_revision_range(revisionspec_list, branch, command_name):
2223
"""Take the input of a revision option and turn it into a revision range.
2224
2225
It returns RevisionInfo objects which can be used to obtain the rev_id's
2226
of the desired revisions. It does some user input validations.
2227
"""
2228
if revisionspec_list is None:
2229
rev1 = None
2230
rev2 = None
2231
elif len(revisionspec_list) == 1:
2232
rev1 = rev2 = revisionspec_list[0].in_history(branch)
2233
elif len(revisionspec_list) == 2:
2234
start_spec = revisionspec_list[0]
2235
end_spec = revisionspec_list[1]
2236
if end_spec.get_branch() != start_spec.get_branch():
2237
# b is taken from revision[0].get_branch(), and
2238
# show_log will use its revision_history. Having
2239
# different branches will lead to weird behaviors.
2240
raise errors.BzrCommandError(
2241
"bzr %s doesn't accept two revisions in different"
2242
" branches." % command_name)
2243
rev1 = start_spec.in_history(branch)
2244
# Avoid loading all of history when we know a missing
2245
# end of range means the last revision ...
2246
if end_spec.spec is None:
2247
last_revno, last_revision_id = branch.last_revision_info()
2248
rev2 = RevisionInfo(branch, last_revno, last_revision_id)
2249
else:
2250
rev2 = end_spec.in_history(branch)
2251
else:
2252
raise errors.BzrCommandError(
2253
'bzr %s --revision takes one or two values.' % command_name)
2254
return rev1, rev2
2255
2256
2257
def _revision_range_to_revid_range(revision_range):
2258
rev_id1 = None
2259
rev_id2 = None
2260
if revision_range[0] is not None:
2261
rev_id1 = revision_range[0].rev_id
2262
if revision_range[1] is not None:
2263
rev_id2 = revision_range[1].rev_id
2264
return rev_id1, rev_id2
2265
2266
def get_log_format(long=False, short=False, line=False, default='long'):
2267
log_format = default
2268
if long:
2269
log_format = 'long'
2270
if short:
2271
log_format = 'short'
2272
if line:
2273
log_format = 'line'
2274
return log_format
2275
2276
2277
class cmd_touching_revisions(Command):
2278
"""Return revision-ids which affected a particular file.
2279
2280
A more user-friendly interface is "bzr log FILE".
2281
"""
2282
2283
hidden = True
2284
takes_args = ["filename"]
2285
2286
@display_command
2287
def run(self, filename):
2288
tree, relpath = WorkingTree.open_containing(filename)
2289
b = tree.branch
2290
file_id = tree.path2id(relpath)
2291
for revno, revision_id, what in log.find_touching_revisions(b, file_id):
2292
self.outf.write("%6d %s\n" % (revno, what))
2293
2294
2295
class cmd_ls(Command):
2296
"""List files in a tree.
2297
"""
2298
2299
_see_also = ['status', 'cat']
2300
takes_args = ['path?']
2301
# TODO: Take a revision or remote path and list that tree instead.
2302
takes_options = [
2303
'verbose',
2304
'revision',
2305
Option('non-recursive',
2306
help='Don\'t recurse into subdirectories.'),
2307
Option('from-root',
2308
help='Print paths relative to the root of the branch.'),
2309
Option('unknown', help='Print unknown files.'),
2310
Option('versioned', help='Print versioned files.',
2311
short_name='V'),
2312
Option('ignored', help='Print ignored files.'),
2313
Option('null',
2314
help='Write an ascii NUL (\\0) separator '
2315
'between files rather than a newline.'),
2316
Option('kind',
2317
help='List entries of a particular kind: file, directory, symlink.',
2318
type=unicode),
2319
'show-ids',
2320
]
2321
@display_command
2322
def run(self, revision=None, verbose=False,
2323
non_recursive=False, from_root=False,
2324
unknown=False, versioned=False, ignored=False,
2325
null=False, kind=None, show_ids=False, path=None):
2326
2327
if kind and kind not in ('file', 'directory', 'symlink'):
2328
raise errors.BzrCommandError('invalid kind specified')
2329
2330
if verbose and null:
2331
raise errors.BzrCommandError('Cannot set both --verbose and --null')
2332
all = not (unknown or versioned or ignored)
2333
2334
selection = {'I':ignored, '?':unknown, 'V':versioned}
2335
2336
if path is None:
2337
fs_path = '.'
2338
prefix = ''
2339
else:
2340
if from_root:
2341
raise errors.BzrCommandError('cannot specify both --from-root'
2342
' and PATH')
2343
fs_path = path
2344
prefix = path
2345
tree, branch, relpath = bzrdir.BzrDir.open_containing_tree_or_branch(
2346
fs_path)
2347
if from_root:
2348
relpath = u''
2349
elif relpath:
2350
relpath += '/'
2351
if revision is not None or tree is None:
2352
tree = _get_one_revision_tree('ls', revision, branch=branch)
2353
2354
apply_view = False
2355
if isinstance(tree, WorkingTree) and tree.supports_views():
2356
view_files = tree.views.lookup_view()
2357
if view_files:
2358
apply_view = True
2359
view_str = views.view_display_str(view_files)
2360
note("Ignoring files outside view. View is %s" % view_str)
2361
2362
tree.lock_read()
2363
try:
2364
for fp, fc, fkind, fid, entry in tree.list_files(include_root=False):
2365
if fp.startswith(relpath):
2366
fp = osutils.pathjoin(prefix, fp[len(relpath):])
2367
if non_recursive and '/' in fp:
2368
continue
2369
if not all and not selection[fc]:
2370
continue
2371
if kind is not None and fkind != kind:
2372
continue
2373
if apply_view:
2374
try:
2375
views.check_path_in_view(tree, fp)
2376
except errors.FileOutsideView:
2377
continue
2378
kindch = entry.kind_character()
2379
outstring = fp + kindch
2380
if verbose:
2381
outstring = '%-8s %s' % (fc, outstring)
2382
if show_ids and fid is not None:
2383
outstring = "%-50s %s" % (outstring, fid)
2384
self.outf.write(outstring + '\n')
2385
elif null:
2386
self.outf.write(fp + '\0')
2387
if show_ids:
2388
if fid is not None:
2389
self.outf.write(fid)
2390
self.outf.write('\0')
2391
self.outf.flush()
2392
else:
2393
if fid is not None:
2394
my_id = fid
2395
else:
2396
my_id = ''
2397
if show_ids:
2398
self.outf.write('%-50s %s\n' % (outstring, my_id))
2399
else:
2400
self.outf.write(outstring + '\n')
2401
finally:
2402
tree.unlock()
2403
2404
2405
class cmd_unknowns(Command):
2406
"""List unknown files.
2407
"""
2408
2409
hidden = True
2410
_see_also = ['ls']
2411
2412
@display_command
2413
def run(self):
2414
for f in WorkingTree.open_containing(u'.')[0].unknowns():
2415
self.outf.write(osutils.quotefn(f) + '\n')
2416
2417
2418
class cmd_ignore(Command):
2419
"""Ignore specified files or patterns.
2420
2421
See ``bzr help patterns`` for details on the syntax of patterns.
2422
2423
To remove patterns from the ignore list, edit the .bzrignore file.
2424
After adding, editing or deleting that file either indirectly by
2425
using this command or directly by using an editor, be sure to commit
2426
it.
2427
2428
Note: ignore patterns containing shell wildcards must be quoted from
2429
the shell on Unix.
2430
2431
:Examples:
2432
Ignore the top level Makefile::
2433
2434
bzr ignore ./Makefile
2435
2436
Ignore class files in all directories::
2437
2438
bzr ignore "*.class"
2439
2440
Ignore .o files under the lib directory::
2441
2442
bzr ignore "lib/**/*.o"
2443
2444
Ignore .o files under the lib directory::
2445
2446
bzr ignore "RE:lib/.*\.o"
2447
2448
Ignore everything but the "debian" toplevel directory::
2449
2450
bzr ignore "RE:(?!debian/).*"
2451
"""
2452
2453
_see_also = ['status', 'ignored', 'patterns']
2454
takes_args = ['name_pattern*']
2455
takes_options = [
2456
Option('old-default-rules',
2457
help='Write out the ignore rules bzr < 0.9 always used.')
2458
]
2459
2460
def run(self, name_pattern_list=None, old_default_rules=None):
2461
from bzrlib import ignores
2462
if old_default_rules is not None:
2463
# dump the rules and exit
2464
for pattern in ignores.OLD_DEFAULTS:
2465
print pattern
2466
return
2467
if not name_pattern_list:
2468
raise errors.BzrCommandError("ignore requires at least one "
2469
"NAME_PATTERN or --old-default-rules")
2470
name_pattern_list = [globbing.normalize_pattern(p)
2471
for p in name_pattern_list]
2472
for name_pattern in name_pattern_list:
2473
if (name_pattern[0] == '/' or
2474
(len(name_pattern) > 1 and name_pattern[1] == ':')):
2475
raise errors.BzrCommandError(
2476
"NAME_PATTERN should not be an absolute path")
2477
tree, relpath = WorkingTree.open_containing(u'.')
2478
ignores.tree_ignores_add_patterns(tree, name_pattern_list)
2479
ignored = globbing.Globster(name_pattern_list)
2480
matches = []
2481
tree.lock_read()
2482
for entry in tree.list_files():
2483
id = entry[3]
2484
if id is not None:
2485
filename = entry[0]
2486
if ignored.match(filename):
2487
matches.append(filename.encode('utf-8'))
2488
tree.unlock()
2489
if len(matches) > 0:
2490
print "Warning: the following files are version controlled and" \
2491
" match your ignore pattern:\n%s" \
2492
"\nThese files will continue to be version controlled" \
2493
" unless you 'bzr remove' them." % ("\n".join(matches),)
2494
2495
2496
class cmd_ignored(Command):
2497
"""List ignored files and the patterns that matched them.
2498
2499
List all the ignored files and the ignore pattern that caused the file to
2500
be ignored.
2501
2502
Alternatively, to list just the files::
2503
2504
bzr ls --ignored
2505
"""
2506
2507
encoding_type = 'replace'
2508
_see_also = ['ignore', 'ls']
2509
2510
@display_command
2511
def run(self):
2512
tree = WorkingTree.open_containing(u'.')[0]
2513
tree.lock_read()
2514
try:
2515
for path, file_class, kind, file_id, entry in tree.list_files():
2516
if file_class != 'I':
2517
continue
2518
## XXX: Slightly inefficient since this was already calculated
2519
pat = tree.is_ignored(path)
2520
self.outf.write('%-50s %s\n' % (path, pat))
2521
finally:
2522
tree.unlock()
2523
2524
2525
class cmd_lookup_revision(Command):
2526
"""Lookup the revision-id from a revision-number
2527
2528
:Examples:
2529
bzr lookup-revision 33
2530
"""
2531
hidden = True
2532
takes_args = ['revno']
2533
2534
@display_command
2535
def run(self, revno):
2536
try:
2537
revno = int(revno)
2538
except ValueError:
2539
raise errors.BzrCommandError("not a valid revision-number: %r" % revno)
2540
2541
print WorkingTree.open_containing(u'.')[0].branch.get_rev_id(revno)
2542
2543
2544
class cmd_export(Command):
2545
"""Export current or past revision to a destination directory or archive.
2546
2547
If no revision is specified this exports the last committed revision.
2548
2549
Format may be an "exporter" name, such as tar, tgz, tbz2. If none is
2550
given, try to find the format with the extension. If no extension
2551
is found exports to a directory (equivalent to --format=dir).
2552
2553
If root is supplied, it will be used as the root directory inside
2554
container formats (tar, zip, etc). If it is not supplied it will default
2555
to the exported filename. The root option has no effect for 'dir' format.
2556
2557
If branch is omitted then the branch containing the current working
2558
directory will be used.
2559
2560
Note: Export of tree with non-ASCII filenames to zip is not supported.
2561
2562
================= =========================
2563
Supported formats Autodetected by extension
2564
================= =========================
2565
dir (none)
2566
tar .tar
2567
tbz2 .tar.bz2, .tbz2
2568
tgz .tar.gz, .tgz
2569
zip .zip
2570
================= =========================
2571
"""
2572
takes_args = ['dest', 'branch_or_subdir?']
2573
takes_options = [
2574
Option('format',
2575
help="Type of file to export to.",
2576
type=unicode),
2577
'revision',
2578
Option('filters', help='Apply content filters to export the '
2579
'convenient form.'),
2580
Option('root',
2581
type=str,
2582
help="Name of the root directory inside the exported file."),
2583
]
2584
def run(self, dest, branch_or_subdir=None, revision=None, format=None,
2585
root=None, filters=False):
2586
from bzrlib.export import export
2587
2588
if branch_or_subdir is None:
2589
tree = WorkingTree.open_containing(u'.')[0]
2590
b = tree.branch
2591
subdir = None
2592
else:
2593
b, subdir = Branch.open_containing(branch_or_subdir)
2594
tree = None
2595
2596
rev_tree = _get_one_revision_tree('export', revision, branch=b, tree=tree)
2597
try:
2598
export(rev_tree, dest, format, root, subdir, filtered=filters)
2599
except errors.NoSuchExportFormat, e:
2600
raise errors.BzrCommandError('Unsupported export format: %s' % e.format)
2601
2602
2603
class cmd_cat(Command):
2604
"""Write the contents of a file as of a given revision to standard output.
2605
2606
If no revision is nominated, the last revision is used.
2607
2608
Note: Take care to redirect standard output when using this command on a
2609
binary file.
2610
"""
2611
2612
_see_also = ['ls']
2613
takes_options = [
2614
Option('name-from-revision', help='The path name in the old tree.'),
2615
Option('filters', help='Apply content filters to display the '
2616
'convenience form.'),
2617
'revision',
2618
]
2619
takes_args = ['filename']
2620
encoding_type = 'exact'
2621
2622
@display_command
2623
def run(self, filename, revision=None, name_from_revision=False,
2624
filters=False):
2625
if revision is not None and len(revision) != 1:
2626
raise errors.BzrCommandError("bzr cat --revision takes exactly"
2627
" one revision specifier")
2628
tree, branch, relpath = \
2629
bzrdir.BzrDir.open_containing_tree_or_branch(filename)
2630
branch.lock_read()
2631
try:
2632
return self._run(tree, branch, relpath, filename, revision,
2633
name_from_revision, filters)
2634
finally:
2635
branch.unlock()
2636
2637
def _run(self, tree, b, relpath, filename, revision, name_from_revision,
2638
filtered):
2639
if tree is None:
2640
tree = b.basis_tree()
2641
rev_tree = _get_one_revision_tree('cat', revision, branch=b)
2642
2643
old_file_id = rev_tree.path2id(relpath)
2644
2645
if name_from_revision:
2646
# Try in revision if requested
2647
if old_file_id is None:
2648
raise errors.BzrCommandError(
2649
"%r is not present in revision %s" % (
2650
filename, rev_tree.get_revision_id()))
2651
else:
2652
content = rev_tree.get_file_text(old_file_id)
2653
else:
2654
cur_file_id = tree.path2id(relpath)
2655
found = False
2656
if cur_file_id is not None:
2657
# Then try with the actual file id
2658
try:
2659
content = rev_tree.get_file_text(cur_file_id)
2660
found = True
2661
except errors.NoSuchId:
2662
# The actual file id didn't exist at that time
2663
pass
2664
if not found and old_file_id is not None:
2665
# Finally try with the old file id
2666
content = rev_tree.get_file_text(old_file_id)
2667
found = True
2668
if not found:
2669
# Can't be found anywhere
2670
raise errors.BzrCommandError(
2671
"%r is not present in revision %s" % (
2672
filename, rev_tree.get_revision_id()))
2673
if filtered:
2674
from bzrlib.filters import (
2675
ContentFilterContext,
2676
filtered_output_bytes,
2677
)
2678
filters = rev_tree._content_filter_stack(relpath)
2679
chunks = content.splitlines(True)
2680
content = filtered_output_bytes(chunks, filters,
2681
ContentFilterContext(relpath, rev_tree))
2682
self.outf.writelines(content)
2683
else:
2684
self.outf.write(content)
2685
2686
2687
class cmd_local_time_offset(Command):
2688
"""Show the offset in seconds from GMT to local time."""
2689
hidden = True
2690
@display_command
2691
def run(self):
2692
print osutils.local_time_offset()
2693
2694
2695
2696
class cmd_commit(Command):
2697
"""Commit changes into a new revision.
2698
2699
If no arguments are given, the entire tree is committed.
2700
2701
If selected files are specified, only changes to those files are
2702
committed. If a directory is specified then the directory and everything
2703
within it is committed.
2704
2705
When excludes are given, they take precedence over selected files.
2706
For example, too commit only changes within foo, but not changes within
2707
foo/bar::
2708
2709
bzr commit foo -x foo/bar
2710
2711
If author of the change is not the same person as the committer, you can
2712
specify the author's name using the --author option. The name should be
2713
in the same format as a committer-id, e.g. "John Doe <jdoe@example.com>".
2714
If there is more than one author of the change you can specify the option
2715
multiple times, once for each author.
2716
2717
A selected-file commit may fail in some cases where the committed
2718
tree would be invalid. Consider::
2719
2720
bzr init foo
2721
mkdir foo/bar
2722
bzr add foo/bar
2723
bzr commit foo -m "committing foo"
2724
bzr mv foo/bar foo/baz
2725
mkdir foo/bar
2726
bzr add foo/bar
2727
bzr commit foo/bar -m "committing bar but not baz"
2728
2729
In the example above, the last commit will fail by design. This gives
2730
the user the opportunity to decide whether they want to commit the
2731
rename at the same time, separately first, or not at all. (As a general
2732
rule, when in doubt, Bazaar has a policy of Doing the Safe Thing.)
2733
2734
Note: A selected-file commit after a merge is not yet supported.
2735
"""
2736
# TODO: Run hooks on tree to-be-committed, and after commit.
2737
2738
# TODO: Strict commit that fails if there are deleted files.
2739
# (what does "deleted files" mean ??)
2740
2741
# TODO: Give better message for -s, --summary, used by tla people
2742
2743
# XXX: verbose currently does nothing
2744
2745
_see_also = ['bugs', 'uncommit']
2746
takes_args = ['selected*']
2747
takes_options = [
2748
ListOption('exclude', type=str, short_name='x',
2749
help="Do not consider changes made to a given path."),
2750
Option('message', type=unicode,
2751
short_name='m',
2752
help="Description of the new revision."),
2753
'verbose',
2754
Option('unchanged',
2755
help='Commit even if nothing has changed.'),
2756
Option('file', type=str,
2757
short_name='F',
2758
argname='msgfile',
2759
help='Take commit message from this file.'),
2760
Option('strict',
2761
help="Refuse to commit if there are unknown "
2762
"files in the working tree."),
2763
ListOption('fixes', type=str,
2764
help="Mark a bug as being fixed by this revision "
2765
"(see \"bzr help bugs\")."),
2766
ListOption('author', type=unicode,
2767
help="Set the author's name, if it's different "
2768
"from the committer."),
2769
Option('local',
2770
help="Perform a local commit in a bound "
2771
"branch. Local commits are not pushed to "
2772
"the master branch until a normal commit "
2773
"is performed."
2774
),
2775
Option('show-diff',
2776
help='When no message is supplied, show the diff along'
2777
' with the status summary in the message editor.'),
2778
]
2779
aliases = ['ci', 'checkin']
2780
2781
def _iter_bug_fix_urls(self, fixes, branch):
2782
# Configure the properties for bug fixing attributes.
2783
for fixed_bug in fixes:
2784
tokens = fixed_bug.split(':')
2785
if len(tokens) != 2:
2786
raise errors.BzrCommandError(
2787
"Invalid bug %s. Must be in the form of 'tracker:id'. "
2788
"See \"bzr help bugs\" for more information on this "
2789
"feature.\nCommit refused." % fixed_bug)
2790
tag, bug_id = tokens
2791
try:
2792
yield bugtracker.get_bug_url(tag, branch, bug_id)
2793
except errors.UnknownBugTrackerAbbreviation:
2794
raise errors.BzrCommandError(
2795
'Unrecognized bug %s. Commit refused.' % fixed_bug)
2796
except errors.MalformedBugIdentifier, e:
2797
raise errors.BzrCommandError(
2798
"%s\nCommit refused." % (str(e),))
2799
2800
def run(self, message=None, file=None, verbose=False, selected_list=None,
2801
unchanged=False, strict=False, local=False, fixes=None,
2802
author=None, show_diff=False, exclude=None):
2803
from bzrlib.errors import (
2804
PointlessCommit,
2805
ConflictsInTree,
2806
StrictCommitFailed
2807
)
2808
from bzrlib.msgeditor import (
2809
edit_commit_message_encoded,
2810
generate_commit_message_template,
2811
make_commit_message_template_encoded
2812
)
2813
2814
# TODO: Need a blackbox test for invoking the external editor; may be
2815
# slightly problematic to run this cross-platform.
2816
2817
# TODO: do more checks that the commit will succeed before
2818
# spending the user's valuable time typing a commit message.
2819
2820
properties = {}
2821
2822
tree, selected_list = tree_files(selected_list)
2823
if selected_list == ['']:
2824
# workaround - commit of root of tree should be exactly the same
2825
# as just default commit in that tree, and succeed even though
2826
# selected-file merge commit is not done yet
2827
selected_list = []
2828
2829
if fixes is None:
2830
fixes = []
2831
bug_property = bugtracker.encode_fixes_bug_urls(
2832
self._iter_bug_fix_urls(fixes, tree.branch))
2833
if bug_property:
2834
properties['bugs'] = bug_property
2835
2836
if local and not tree.branch.get_bound_location():
2837
raise errors.LocalRequiresBoundBranch()
2838
2839
def get_message(commit_obj):
2840
"""Callback to get commit message"""
2841
my_message = message
2842
if my_message is None and not file:
2843
t = make_commit_message_template_encoded(tree,
2844
selected_list, diff=show_diff,
2845
output_encoding=osutils.get_user_encoding())
2846
start_message = generate_commit_message_template(commit_obj)
2847
my_message = edit_commit_message_encoded(t,
2848
start_message=start_message)
2849
if my_message is None:
2850
raise errors.BzrCommandError("please specify a commit"
2851
" message with either --message or --file")
2852
elif my_message and file:
2853
raise errors.BzrCommandError(
2854
"please specify either --message or --file")
2855
if file:
2856
my_message = codecs.open(file, 'rt',
2857
osutils.get_user_encoding()).read()
2858
if my_message == "":
2859
raise errors.BzrCommandError("empty commit message specified")
2860
return my_message
2861
2862
try:
2863
tree.commit(message_callback=get_message,
2864
specific_files=selected_list,
2865
allow_pointless=unchanged, strict=strict, local=local,
2866
reporter=None, verbose=verbose, revprops=properties,
2867
authors=author,
2868
exclude=safe_relpath_files(tree, exclude))
2869
except PointlessCommit:
2870
# FIXME: This should really happen before the file is read in;
2871
# perhaps prepare the commit; get the message; then actually commit
2872
raise errors.BzrCommandError("no changes to commit."
2873
" use --unchanged to commit anyhow")
2874
except ConflictsInTree:
2875
raise errors.BzrCommandError('Conflicts detected in working '
2876
'tree. Use "bzr conflicts" to list, "bzr resolve FILE" to'
2877
' resolve.')
2878
except StrictCommitFailed:
2879
raise errors.BzrCommandError("Commit refused because there are"
2880
" unknown files in the working tree.")
2881
except errors.BoundBranchOutOfDate, e:
2882
raise errors.BzrCommandError(str(e) + "\n"
2883
'To commit to master branch, run update and then commit.\n'
2884
'You can also pass --local to commit to continue working '
2885
'disconnected.')
2886
2887
2888
class cmd_check(Command):
2889
"""Validate working tree structure, branch consistency and repository history.
2890
2891
This command checks various invariants about branch and repository storage
2892
to detect data corruption or bzr bugs.
2893
2894
The working tree and branch checks will only give output if a problem is
2895
detected. The output fields of the repository check are:
2896
2897
revisions: This is just the number of revisions checked. It doesn't
2898
indicate a problem.
2899
versionedfiles: This is just the number of versionedfiles checked. It
2900
doesn't indicate a problem.
2901
unreferenced ancestors: Texts that are ancestors of other texts, but
2902
are not properly referenced by the revision ancestry. This is a
2903
subtle problem that Bazaar can work around.
2904
unique file texts: This is the total number of unique file contents
2905
seen in the checked revisions. It does not indicate a problem.
2906
repeated file texts: This is the total number of repeated texts seen
2907
in the checked revisions. Texts can be repeated when their file
2908
entries are modified, but the file contents are not. It does not
2909
indicate a problem.
2910
2911
If no restrictions are specified, all Bazaar data that is found at the given
2912
location will be checked.
2913
2914
:Examples:
2915
2916
Check the tree and branch at 'foo'::
2917
2918
bzr check --tree --branch foo
2919
2920
Check only the repository at 'bar'::
2921
2922
bzr check --repo bar
2923
2924
Check everything at 'baz'::
2925
2926
bzr check baz
2927
"""
2928
2929
_see_also = ['reconcile']
2930
takes_args = ['path?']
2931
takes_options = ['verbose',
2932
Option('branch', help="Check the branch related to the"
2933
" current directory."),
2934
Option('repo', help="Check the repository related to the"
2935
" current directory."),
2936
Option('tree', help="Check the working tree related to"
2937
" the current directory.")]
2938
2939
def run(self, path=None, verbose=False, branch=False, repo=False,
2940
tree=False):
2941
from bzrlib.check import check_dwim
2942
if path is None:
2943
path = '.'
2944
if not branch and not repo and not tree:
2945
branch = repo = tree = True
2946
check_dwim(path, verbose, do_branch=branch, do_repo=repo, do_tree=tree)
2947
2948
2949
class cmd_upgrade(Command):
2950
"""Upgrade branch storage to current format.
2951
2952
The check command or bzr developers may sometimes advise you to run
2953
this command. When the default format has changed you may also be warned
2954
during other operations to upgrade.
2955
"""
2956
2957
_see_also = ['check']
2958
takes_args = ['url?']
2959
takes_options = [
2960
RegistryOption('format',
2961
help='Upgrade to a specific format. See "bzr help'
2962
' formats" for details.',
2963
lazy_registry=('bzrlib.bzrdir', 'format_registry'),
2964
converter=lambda name: bzrdir.format_registry.make_bzrdir(name),
2965
value_switches=True, title='Branch format'),
2966
]
2967
2968
def run(self, url='.', format=None):
2969
from bzrlib.upgrade import upgrade
2970
upgrade(url, format)
2971
2972
2973
class cmd_whoami(Command):
2974
"""Show or set bzr user id.
2975
2976
:Examples:
2977
Show the email of the current user::
2978
2979
bzr whoami --email
2980
2981
Set the current user::
2982
2983
bzr whoami "Frank Chu <fchu@example.com>"
2984
"""
2985
takes_options = [ Option('email',
2986
help='Display email address only.'),
2987
Option('branch',
2988
help='Set identity for the current branch instead of '
2989
'globally.'),
2990
]
2991
takes_args = ['name?']
2992
encoding_type = 'replace'
2993
2994
@display_command
2995
def run(self, email=False, branch=False, name=None):
2996
if name is None:
2997
# use branch if we're inside one; otherwise global config
2998
try:
2999
c = Branch.open_containing('.')[0].get_config()
3000
except errors.NotBranchError:
3001
c = config.GlobalConfig()
3002
if email:
3003
self.outf.write(c.user_email() + '\n')
3004
else:
3005
self.outf.write(c.username() + '\n')
3006
return
3007
3008
# display a warning if an email address isn't included in the given name.
3009
try:
3010
config.extract_email_address(name)
3011
except errors.NoEmailInUsername, e:
3012
warning('"%s" does not seem to contain an email address. '
3013
'This is allowed, but not recommended.', name)
3014
3015
# use global config unless --branch given
3016
if branch:
3017
c = Branch.open_containing('.')[0].get_config()
3018
else:
3019
c = config.GlobalConfig()
3020
c.set_user_option('email', name)
3021
3022
3023
class cmd_nick(Command):
3024
"""Print or set the branch nickname.
3025
3026
If unset, the tree root directory name is used as the nickname.
3027
To print the current nickname, execute with no argument.
3028
3029
Bound branches use the nickname of its master branch unless it is set
3030
locally.
3031
"""
3032
3033
_see_also = ['info']
3034
takes_args = ['nickname?']
3035
def run(self, nickname=None):
3036
branch = Branch.open_containing(u'.')[0]
3037
if nickname is None:
3038
self.printme(branch)
3039
else:
3040
branch.nick = nickname
3041
3042
@display_command
3043
def printme(self, branch):
3044
print branch.nick
3045
3046
3047
class cmd_alias(Command):
3048
"""Set/unset and display aliases.
3049
3050
:Examples:
3051
Show the current aliases::
3052
3053
bzr alias
3054
3055
Show the alias specified for 'll'::
3056
3057
bzr alias ll
3058
3059
Set an alias for 'll'::
3060
3061
bzr alias ll="log --line -r-10..-1"
3062
3063
To remove an alias for 'll'::
3064
3065
bzr alias --remove ll
3066
3067
"""
3068
takes_args = ['name?']
3069
takes_options = [
3070
Option('remove', help='Remove the alias.'),
3071
]
3072
3073
def run(self, name=None, remove=False):
3074
if remove:
3075
self.remove_alias(name)
3076
elif name is None:
3077
self.print_aliases()
3078
else:
3079
equal_pos = name.find('=')
3080
if equal_pos == -1:
3081
self.print_alias(name)
3082
else:
3083
self.set_alias(name[:equal_pos], name[equal_pos+1:])
3084
3085
def remove_alias(self, alias_name):
3086
if alias_name is None:
3087
raise errors.BzrCommandError(
3088
'bzr alias --remove expects an alias to remove.')
3089
# If alias is not found, print something like:
3090
# unalias: foo: not found
3091
c = config.GlobalConfig()
3092
c.unset_alias(alias_name)
3093
3094
@display_command
3095
def print_aliases(self):
3096
"""Print out the defined aliases in a similar format to bash."""
3097
aliases = config.GlobalConfig().get_aliases()
3098
for key, value in sorted(aliases.iteritems()):
3099
self.outf.write('bzr alias %s="%s"\n' % (key, value))
3100
3101
@display_command
3102
def print_alias(self, alias_name):
3103
from bzrlib.commands import get_alias
3104
alias = get_alias(alias_name)
3105
if alias is None:
3106
self.outf.write("bzr alias: %s: not found\n" % alias_name)
3107
else:
3108
self.outf.write(
3109
'bzr alias %s="%s"\n' % (alias_name, ' '.join(alias)))
3110
3111
def set_alias(self, alias_name, alias_command):
3112
"""Save the alias in the global config."""
3113
c = config.GlobalConfig()
3114
c.set_alias(alias_name, alias_command)
3115
3116
3117
class cmd_selftest(Command):
3118
"""Run internal test suite.
3119
3120
If arguments are given, they are regular expressions that say which tests
3121
should run. Tests matching any expression are run, and other tests are
3122
not run.
3123
3124
Alternatively if --first is given, matching tests are run first and then
3125
all other tests are run. This is useful if you have been working in a
3126
particular area, but want to make sure nothing else was broken.
3127
3128
If --exclude is given, tests that match that regular expression are
3129
excluded, regardless of whether they match --first or not.
3130
3131
To help catch accidential dependencies between tests, the --randomize
3132
option is useful. In most cases, the argument used is the word 'now'.
3133
Note that the seed used for the random number generator is displayed
3134
when this option is used. The seed can be explicitly passed as the
3135
argument to this option if required. This enables reproduction of the
3136
actual ordering used if and when an order sensitive problem is encountered.
3137
3138
If --list-only is given, the tests that would be run are listed. This is
3139
useful when combined with --first, --exclude and/or --randomize to
3140
understand their impact. The test harness reports "Listed nn tests in ..."
3141
instead of "Ran nn tests in ..." when list mode is enabled.
3142
3143
If the global option '--no-plugins' is given, plugins are not loaded
3144
before running the selftests. This has two effects: features provided or
3145
modified by plugins will not be tested, and tests provided by plugins will
3146
not be run.
3147
3148
Tests that need working space on disk use a common temporary directory,
3149
typically inside $TMPDIR or /tmp.
3150
3151
:Examples:
3152
Run only tests relating to 'ignore'::
3153
3154
bzr selftest ignore
3155
3156
Disable plugins and list tests as they're run::
3157
3158
bzr --no-plugins selftest -v
3159
"""
3160
# NB: this is used from the class without creating an instance, which is
3161
# why it does not have a self parameter.
3162
def get_transport_type(typestring):
3163
"""Parse and return a transport specifier."""
3164
if typestring == "sftp":
3165
from bzrlib.transport.sftp import SFTPAbsoluteServer
3166
return SFTPAbsoluteServer
3167
if typestring == "memory":
3168
from bzrlib.transport.memory import MemoryServer
3169
return MemoryServer
3170
if typestring == "fakenfs":
3171
from bzrlib.transport.fakenfs import FakeNFSServer
3172
return FakeNFSServer
3173
msg = "No known transport type %s. Supported types are: sftp\n" %\
3174
(typestring)
3175
raise errors.BzrCommandError(msg)
3176
3177
hidden = True
3178
takes_args = ['testspecs*']
3179
takes_options = ['verbose',
3180
Option('one',
3181
help='Stop when one test fails.',
3182
short_name='1',
3183
),
3184
Option('transport',
3185
help='Use a different transport by default '
3186
'throughout the test suite.',
3187
type=get_transport_type),
3188
Option('benchmark',
3189
help='Run the benchmarks rather than selftests.'),
3190
Option('lsprof-timed',
3191
help='Generate lsprof output for benchmarked'
3192
' sections of code.'),
3193
Option('cache-dir', type=str,
3194
help='Cache intermediate benchmark output in this '
3195
'directory.'),
3196
Option('first',
3197
help='Run all tests, but run specified tests first.',
3198
short_name='f',
3199
),
3200
Option('list-only',
3201
help='List the tests instead of running them.'),
3202
RegistryOption('parallel',
3203
help="Run the test suite in parallel.",
3204
lazy_registry=('bzrlib.tests', 'parallel_registry'),
3205
value_switches=False,
3206
),
3207
Option('randomize', type=str, argname="SEED",
3208
help='Randomize the order of tests using the given'
3209
' seed or "now" for the current time.'),
3210
Option('exclude', type=str, argname="PATTERN",
3211
short_name='x',
3212
help='Exclude tests that match this regular'
3213
' expression.'),
3214
Option('subunit',
3215
help='Output test progress via subunit.'),
3216
Option('strict', help='Fail on missing dependencies or '
3217
'known failures.'),
3218
Option('load-list', type=str, argname='TESTLISTFILE',
3219
help='Load a test id list from a text file.'),
3220
ListOption('debugflag', type=str, short_name='E',
3221
help='Turn on a selftest debug flag.'),
3222
ListOption('starting-with', type=str, argname='TESTID',
3223
param_name='starting_with', short_name='s',
3224
help=
3225
'Load only the tests starting with TESTID.'),
3226
]
3227
encoding_type = 'replace'
3228
3229
def __init__(self):
3230
Command.__init__(self)
3231
self.additional_selftest_args = {}
3232
3233
def run(self, testspecs_list=None, verbose=False, one=False,
3234
transport=None, benchmark=None,
3235
lsprof_timed=None, cache_dir=None,
3236
first=False, list_only=False,
3237
randomize=None, exclude=None, strict=False,
3238
load_list=None, debugflag=None, starting_with=None, subunit=False,
3239
parallel=None):
3240
from bzrlib.tests import selftest
3241
import bzrlib.benchmarks as benchmarks
3242
from bzrlib.benchmarks import tree_creator
3243
3244
# Make deprecation warnings visible, unless -Werror is set
3245
symbol_versioning.activate_deprecation_warnings(override=False)
3246
3247
if cache_dir is not None:
3248
tree_creator.TreeCreator.CACHE_ROOT = osutils.abspath(cache_dir)
3249
if not list_only:
3250
print 'testing: %s' % (osutils.realpath(sys.argv[0]),)
3251
print ' %s (%s python%s)' % (
3252
bzrlib.__path__[0],
3253
bzrlib.version_string,
3254
bzrlib._format_version_tuple(sys.version_info),
3255
)
3256
print
3257
if testspecs_list is not None:
3258
pattern = '|'.join(testspecs_list)
3259
else:
3260
pattern = ".*"
3261
if subunit:
3262
try:
3263
from bzrlib.tests import SubUnitBzrRunner
3264
except ImportError:
3265
raise errors.BzrCommandError("subunit not available. subunit "
3266
"needs to be installed to use --subunit.")
3267
self.additional_selftest_args['runner_class'] = SubUnitBzrRunner
3268
if parallel:
3269
self.additional_selftest_args.setdefault(
3270
'suite_decorators', []).append(parallel)
3271
if benchmark:
3272
test_suite_factory = benchmarks.test_suite
3273
# Unless user explicitly asks for quiet, be verbose in benchmarks
3274
verbose = not is_quiet()
3275
# TODO: should possibly lock the history file...
3276
benchfile = open(".perf_history", "at", buffering=1)
3277
else:
3278
test_suite_factory = None
3279
benchfile = None
3280
try:
3281
selftest_kwargs = {"verbose": verbose,
3282
"pattern": pattern,
3283
"stop_on_failure": one,
3284
"transport": transport,
3285
"test_suite_factory": test_suite_factory,
3286
"lsprof_timed": lsprof_timed,
3287
"bench_history": benchfile,
3288
"matching_tests_first": first,
3289
"list_only": list_only,
3290
"random_seed": randomize,
3291
"exclude_pattern": exclude,
3292
"strict": strict,
3293
"load_list": load_list,
3294
"debug_flags": debugflag,
3295
"starting_with": starting_with
3296
}
3297
selftest_kwargs.update(self.additional_selftest_args)
3298
result = selftest(**selftest_kwargs)
3299
finally:
3300
if benchfile is not None:
3301
benchfile.close()
3302
if result:
3303
note('tests passed')
3304
else:
3305
note('tests failed')
3306
return int(not result)
3307
3308
3309
class cmd_version(Command):
3310
"""Show version of bzr."""
3311
3312
encoding_type = 'replace'
3313
takes_options = [
3314
Option("short", help="Print just the version number."),
3315
]
3316
3317
@display_command
3318
def run(self, short=False):
3319
from bzrlib.version import show_version
3320
if short:
3321
self.outf.write(bzrlib.version_string + '\n')
3322
else:
3323
show_version(to_file=self.outf)
3324
3325
3326
class cmd_rocks(Command):
3327
"""Statement of optimism."""
3328
3329
hidden = True
3330
3331
@display_command
3332
def run(self):
3333
print "It sure does!"
3334
3335
3336
class cmd_find_merge_base(Command):
3337
"""Find and print a base revision for merging two branches."""
3338
# TODO: Options to specify revisions on either side, as if
3339
# merging only part of the history.
3340
takes_args = ['branch', 'other']
3341
hidden = True
3342
3343
@display_command
3344
def run(self, branch, other):
3345
from bzrlib.revision import ensure_null
3346
3347
branch1 = Branch.open_containing(branch)[0]
3348
branch2 = Branch.open_containing(other)[0]
3349
branch1.lock_read()
3350
try:
3351
branch2.lock_read()
3352
try:
3353
last1 = ensure_null(branch1.last_revision())
3354
last2 = ensure_null(branch2.last_revision())
3355
3356
graph = branch1.repository.get_graph(branch2.repository)
3357
base_rev_id = graph.find_unique_lca(last1, last2)
3358
3359
print 'merge base is revision %s' % base_rev_id
3360
finally:
3361
branch2.unlock()
3362
finally:
3363
branch1.unlock()
3364
3365
3366
class cmd_merge(Command):
3367
"""Perform a three-way merge.
3368
3369
The source of the merge can be specified either in the form of a branch,
3370
or in the form of a path to a file containing a merge directive generated
3371
with bzr send. If neither is specified, the default is the upstream branch
3372
or the branch most recently merged using --remember.
3373
3374
When merging a branch, by default the tip will be merged. To pick a different
3375
revision, pass --revision. If you specify two values, the first will be used as
3376
BASE and the second one as OTHER. Merging individual revisions, or a subset of
3377
available revisions, like this is commonly referred to as "cherrypicking".
3378
3379
Revision numbers are always relative to the branch being merged.
3380
3381
By default, bzr will try to merge in all new work from the other
3382
branch, automatically determining an appropriate base. If this
3383
fails, you may need to give an explicit base.
3384
3385
Merge will do its best to combine the changes in two branches, but there
3386
are some kinds of problems only a human can fix. When it encounters those,
3387
it will mark a conflict. A conflict means that you need to fix something,
3388
before you should commit.
3389
3390
Use bzr resolve when you have fixed a problem. See also bzr conflicts.
3391
3392
If there is no default branch set, the first merge will set it. After
3393
that, you can omit the branch to use the default. To change the
3394
default, use --remember. The value will only be saved if the remote
3395
location can be accessed.
3396
3397
The results of the merge are placed into the destination working
3398
directory, where they can be reviewed (with bzr diff), tested, and then
3399
committed to record the result of the merge.
3400
3401
merge refuses to run if there are any uncommitted changes, unless
3402
--force is given.
3403
3404
:Examples:
3405
To merge the latest revision from bzr.dev::
3406
3407
bzr merge ../bzr.dev
3408
3409
To merge changes up to and including revision 82 from bzr.dev::
3410
3411
bzr merge -r 82 ../bzr.dev
3412
3413
To merge the changes introduced by 82, without previous changes::
3414
3415
bzr merge -r 81..82 ../bzr.dev
3416
3417
To apply a merge directive contained in /tmp/merge:
3418
3419
bzr merge /tmp/merge
3420
"""
3421
3422
encoding_type = 'exact'
3423
_see_also = ['update', 'remerge', 'status-flags', 'send']
3424
takes_args = ['location?']
3425
takes_options = [
3426
'change',
3427
'revision',
3428
Option('force',
3429
help='Merge even if the destination tree has uncommitted changes.'),
3430
'merge-type',
3431
'reprocess',
3432
'remember',
3433
Option('show-base', help="Show base revision text in "
3434
"conflicts."),
3435
Option('uncommitted', help='Apply uncommitted changes'
3436
' from a working copy, instead of branch changes.'),
3437
Option('pull', help='If the destination is already'
3438
' completely merged into the source, pull from the'
3439
' source rather than merging. When this happens,'
3440
' you do not need to commit the result.'),
3441
Option('directory',
3442
help='Branch to merge into, '
3443
'rather than the one containing the working directory.',
3444
short_name='d',
3445
type=unicode,
3446
),
3447
Option('preview', help='Instead of merging, show a diff of the merge.')
3448
]
3449
3450
def run(self, location=None, revision=None, force=False,
3451
merge_type=None, show_base=False, reprocess=None, remember=False,
3452
uncommitted=False, pull=False,
3453
directory=None,
3454
preview=False,
3455
):
3456
if merge_type is None:
3457
merge_type = _mod_merge.Merge3Merger
3458
3459
if directory is None: directory = u'.'
3460
possible_transports = []
3461
merger = None
3462
allow_pending = True
3463
verified = 'inapplicable'
3464
tree = WorkingTree.open_containing(directory)[0]
3465
3466
# die as quickly as possible if there are uncommitted changes
3467
try:
3468
basis_tree = tree.revision_tree(tree.last_revision())
3469
except errors.NoSuchRevision:
3470
basis_tree = tree.basis_tree()
3471
if not force:
3472
changes = tree.changes_from(basis_tree)
3473
if changes.has_changed():
3474
raise errors.UncommittedChanges(tree)
3475
3476
view_info = _get_view_info_for_change_reporter(tree)
3477
change_reporter = delta._ChangeReporter(
3478
unversioned_filter=tree.is_ignored, view_info=view_info)
3479
cleanups = []
3480
try:
3481
pb = ui.ui_factory.nested_progress_bar()
3482
cleanups.append(pb.finished)
3483
tree.lock_write()
3484
cleanups.append(tree.unlock)
3485
if location is not None:
3486
try:
3487
mergeable = bundle.read_mergeable_from_url(location,
3488
possible_transports=possible_transports)
3489
except errors.NotABundle:
3490
mergeable = None
3491
else:
3492
if uncommitted:
3493
raise errors.BzrCommandError('Cannot use --uncommitted'
3494
' with bundles or merge directives.')
3495
3496
if revision is not None:
3497
raise errors.BzrCommandError(
3498
'Cannot use -r with merge directives or bundles')
3499
merger, verified = _mod_merge.Merger.from_mergeable(tree,
3500
mergeable, pb)
3501
3502
if merger is None and uncommitted:
3503
if revision is not None and len(revision) > 0:
3504
raise errors.BzrCommandError('Cannot use --uncommitted and'
3505
' --revision at the same time.')
3506
location = self._select_branch_location(tree, location)[0]
3507
other_tree, other_path = WorkingTree.open_containing(location)
3508
merger = _mod_merge.Merger.from_uncommitted(tree, other_tree,
3509
pb)
3510
allow_pending = False
3511
if other_path != '':
3512
merger.interesting_files = [other_path]
3513
3514
if merger is None:
3515
merger, allow_pending = self._get_merger_from_branch(tree,
3516
location, revision, remember, possible_transports, pb)
3517
3518
merger.merge_type = merge_type
3519
merger.reprocess = reprocess
3520
merger.show_base = show_base
3521
self.sanity_check_merger(merger)
3522
if (merger.base_rev_id == merger.other_rev_id and
3523
merger.other_rev_id is not None):
3524
note('Nothing to do.')
3525
return 0
3526
if pull:
3527
if merger.interesting_files is not None:
3528
raise errors.BzrCommandError('Cannot pull individual files')
3529
if (merger.base_rev_id == tree.last_revision()):
3530
result = tree.pull(merger.other_branch, False,
3531
merger.other_rev_id)
3532
result.report(self.outf)
3533
return 0
3534
merger.check_basis(False)
3535
if preview:
3536
return self._do_preview(merger)
3537
else:
3538
return self._do_merge(merger, change_reporter, allow_pending,
3539
verified)
3540
finally:
3541
for cleanup in reversed(cleanups):
3542
cleanup()
3543
3544
def _do_preview(self, merger):
3545
from bzrlib.diff import show_diff_trees
3546
tree_merger = merger.make_merger()
3547
tt = tree_merger.make_preview_transform()
3548
try:
3549
result_tree = tt.get_preview_tree()
3550
show_diff_trees(merger.this_tree, result_tree, self.outf,
3551
old_label='', new_label='')
3552
finally:
3553
tt.finalize()
3554
3555
def _do_merge(self, merger, change_reporter, allow_pending, verified):
3556
merger.change_reporter = change_reporter
3557
conflict_count = merger.do_merge()
3558
if allow_pending:
3559
merger.set_pending()
3560
if verified == 'failed':
3561
warning('Preview patch does not match changes')
3562
if conflict_count != 0:
3563
return 1
3564
else:
3565
return 0
3566
3567
def sanity_check_merger(self, merger):
3568
if (merger.show_base and
3569
not merger.merge_type is _mod_merge.Merge3Merger):
3570
raise errors.BzrCommandError("Show-base is not supported for this"
3571
" merge type. %s" % merger.merge_type)
3572
if merger.reprocess is None:
3573
if merger.show_base:
3574
merger.reprocess = False
3575
else:
3576
# Use reprocess if the merger supports it
3577
merger.reprocess = merger.merge_type.supports_reprocess
3578
if merger.reprocess and not merger.merge_type.supports_reprocess:
3579
raise errors.BzrCommandError("Conflict reduction is not supported"
3580
" for merge type %s." %
3581
merger.merge_type)
3582
if merger.reprocess and merger.show_base:
3583
raise errors.BzrCommandError("Cannot do conflict reduction and"
3584
" show base.")
3585
3586
def _get_merger_from_branch(self, tree, location, revision, remember,
3587
possible_transports, pb):
3588
"""Produce a merger from a location, assuming it refers to a branch."""
3589
from bzrlib.tag import _merge_tags_if_possible
3590
# find the branch locations
3591
other_loc, user_location = self._select_branch_location(tree, location,
3592
revision, -1)
3593
if revision is not None and len(revision) == 2:
3594
base_loc, _unused = self._select_branch_location(tree,
3595
location, revision, 0)
3596
else:
3597
base_loc = other_loc
3598
# Open the branches
3599
other_branch, other_path = Branch.open_containing(other_loc,
3600
possible_transports)
3601
if base_loc == other_loc:
3602
base_branch = other_branch
3603
else:
3604
base_branch, base_path = Branch.open_containing(base_loc,
3605
possible_transports)
3606
# Find the revision ids
3607
if revision is None or len(revision) < 1 or revision[-1] is None:
3608
other_revision_id = _mod_revision.ensure_null(
3609
other_branch.last_revision())
3610
else:
3611
other_revision_id = revision[-1].as_revision_id(other_branch)
3612
if (revision is not None and len(revision) == 2
3613
and revision[0] is not None):
3614
base_revision_id = revision[0].as_revision_id(base_branch)
3615
else:
3616
base_revision_id = None
3617
# Remember where we merge from
3618
if ((remember or tree.branch.get_submit_branch() is None) and
3619
user_location is not None):
3620
tree.branch.set_submit_branch(other_branch.base)
3621
_merge_tags_if_possible(other_branch, tree.branch)
3622
merger = _mod_merge.Merger.from_revision_ids(pb, tree,
3623
other_revision_id, base_revision_id, other_branch, base_branch)
3624
if other_path != '':
3625
allow_pending = False
3626
merger.interesting_files = [other_path]
3627
else:
3628
allow_pending = True
3629
return merger, allow_pending
3630
3631
def _select_branch_location(self, tree, user_location, revision=None,
3632
index=None):
3633
"""Select a branch location, according to possible inputs.
3634
3635
If provided, branches from ``revision`` are preferred. (Both
3636
``revision`` and ``index`` must be supplied.)
3637
3638
Otherwise, the ``location`` parameter is used. If it is None, then the
3639
``submit`` or ``parent`` location is used, and a note is printed.
3640
3641
:param tree: The working tree to select a branch for merging into
3642
:param location: The location entered by the user
3643
:param revision: The revision parameter to the command
3644
:param index: The index to use for the revision parameter. Negative
3645
indices are permitted.
3646
:return: (selected_location, user_location). The default location
3647
will be the user-entered location.
3648
"""
3649
if (revision is not None and index is not None
3650
and revision[index] is not None):
3651
branch = revision[index].get_branch()
3652
if branch is not None:
3653
return branch, branch
3654
if user_location is None:
3655
location = self._get_remembered(tree, 'Merging from')
3656
else:
3657
location = user_location
3658
return location, user_location
3659
3660
def _get_remembered(self, tree, verb_string):
3661
"""Use tree.branch's parent if none was supplied.
3662
3663
Report if the remembered location was used.
3664
"""
3665
stored_location = tree.branch.get_submit_branch()
3666
stored_location_type = "submit"
3667
if stored_location is None:
3668
stored_location = tree.branch.get_parent()
3669
stored_location_type = "parent"
3670
mutter("%s", stored_location)
3671
if stored_location is None:
3672
raise errors.BzrCommandError("No location specified or remembered")
3673
display_url = urlutils.unescape_for_display(stored_location, 'utf-8')
3674
note(u"%s remembered %s location %s", verb_string,
3675
stored_location_type, display_url)
3676
return stored_location
3677
3678
3679
class cmd_remerge(Command):
3680
"""Redo a merge.
3681
3682
Use this if you want to try a different merge technique while resolving
3683
conflicts. Some merge techniques are better than others, and remerge
3684
lets you try different ones on different files.
3685
3686
The options for remerge have the same meaning and defaults as the ones for
3687
merge. The difference is that remerge can (only) be run when there is a
3688
pending merge, and it lets you specify particular files.
3689
3690
:Examples:
3691
Re-do the merge of all conflicted files, and show the base text in
3692
conflict regions, in addition to the usual THIS and OTHER texts::
3693
3694
bzr remerge --show-base
3695
3696
Re-do the merge of "foobar", using the weave merge algorithm, with
3697
additional processing to reduce the size of conflict regions::
3698
3699
bzr remerge --merge-type weave --reprocess foobar
3700
"""
3701
takes_args = ['file*']
3702
takes_options = [
3703
'merge-type',
3704
'reprocess',
3705
Option('show-base',
3706
help="Show base revision text in conflicts."),
3707
]
3708
3709
def run(self, file_list=None, merge_type=None, show_base=False,
3710
reprocess=False):
3711
if merge_type is None:
3712
merge_type = _mod_merge.Merge3Merger
3713
tree, file_list = tree_files(file_list)
3714
tree.lock_write()
3715
try:
3716
parents = tree.get_parent_ids()
3717
if len(parents) != 2:
3718
raise errors.BzrCommandError("Sorry, remerge only works after normal"
3719
" merges. Not cherrypicking or"
3720
" multi-merges.")
3721
repository = tree.branch.repository
3722
interesting_ids = None
3723
new_conflicts = []
3724
conflicts = tree.conflicts()
3725
if file_list is not None:
3726
interesting_ids = set()
3727
for filename in file_list:
3728
file_id = tree.path2id(filename)
3729
if file_id is None:
3730
raise errors.NotVersionedError(filename)
3731
interesting_ids.add(file_id)
3732
if tree.kind(file_id) != "directory":
3733
continue
3734
3735
for name, ie in tree.inventory.iter_entries(file_id):
3736
interesting_ids.add(ie.file_id)
3737
new_conflicts = conflicts.select_conflicts(tree, file_list)[0]
3738
else:
3739
# Remerge only supports resolving contents conflicts
3740
allowed_conflicts = ('text conflict', 'contents conflict')
3741
restore_files = [c.path for c in conflicts
3742
if c.typestring in allowed_conflicts]
3743
_mod_merge.transform_tree(tree, tree.basis_tree(), interesting_ids)
3744
tree.set_conflicts(ConflictList(new_conflicts))
3745
if file_list is not None:
3746
restore_files = file_list
3747
for filename in restore_files:
3748
try:
3749
restore(tree.abspath(filename))
3750
except errors.NotConflicted:
3751
pass
3752
# Disable pending merges, because the file texts we are remerging
3753
# have not had those merges performed. If we use the wrong parents
3754
# list, we imply that the working tree text has seen and rejected
3755
# all the changes from the other tree, when in fact those changes
3756
# have not yet been seen.
3757
pb = ui.ui_factory.nested_progress_bar()
3758
tree.set_parent_ids(parents[:1])
3759
try:
3760
merger = _mod_merge.Merger.from_revision_ids(pb,
3761
tree, parents[1])
3762
merger.interesting_ids = interesting_ids
3763
merger.merge_type = merge_type
3764
merger.show_base = show_base
3765
merger.reprocess = reprocess
3766
conflicts = merger.do_merge()
3767
finally:
3768
tree.set_parent_ids(parents)
3769
pb.finished()
3770
finally:
3771
tree.unlock()
3772
if conflicts > 0:
3773
return 1
3774
else:
3775
return 0
3776
3777
3778
class cmd_revert(Command):
3779
"""Revert files to a previous revision.
3780
3781
Giving a list of files will revert only those files. Otherwise, all files
3782
will be reverted. If the revision is not specified with '--revision', the
3783
last committed revision is used.
3784
3785
To remove only some changes, without reverting to a prior version, use
3786
merge instead. For example, "merge . --revision -2..-3" will remove the
3787
changes introduced by -2, without affecting the changes introduced by -1.
3788
Or to remove certain changes on a hunk-by-hunk basis, see the Shelf plugin.
3789
3790
By default, any files that have been manually changed will be backed up
3791
first. (Files changed only by merge are not backed up.) Backup files have
3792
'.~#~' appended to their name, where # is a number.
3793
3794
When you provide files, you can use their current pathname or the pathname
3795
from the target revision. So you can use revert to "undelete" a file by
3796
name. If you name a directory, all the contents of that directory will be
3797
reverted.
3798
3799
Any files that have been newly added since that revision will be deleted,
3800
with a backup kept if appropriate. Directories containing unknown files
3801
will not be deleted.
3802
3803
The working tree contains a list of pending merged revisions, which will
3804
be included as parents in the next commit. Normally, revert clears that
3805
list as well as reverting the files. If any files are specified, revert
3806
leaves the pending merge list alone and reverts only the files. Use "bzr
3807
revert ." in the tree root to revert all files but keep the merge record,
3808
and "bzr revert --forget-merges" to clear the pending merge list without
3809
reverting any files.
3810
"""
3811
3812
_see_also = ['cat', 'export']
3813
takes_options = [
3814
'revision',
3815
Option('no-backup', "Do not save backups of reverted files."),
3816
Option('forget-merges',
3817
'Remove pending merge marker, without changing any files.'),
3818
]
3819
takes_args = ['file*']
3820
3821
def run(self, revision=None, no_backup=False, file_list=None,
3822
forget_merges=None):
3823
tree, file_list = tree_files(file_list)
3824
tree.lock_write()
3825
try:
3826
if forget_merges:
3827
tree.set_parent_ids(tree.get_parent_ids()[:1])
3828
else:
3829
self._revert_tree_to_revision(tree, revision, file_list, no_backup)
3830
finally:
3831
tree.unlock()
3832
3833
@staticmethod
3834
def _revert_tree_to_revision(tree, revision, file_list, no_backup):
3835
rev_tree = _get_one_revision_tree('revert', revision, tree=tree)
3836
pb = ui.ui_factory.nested_progress_bar()
3837
try:
3838
tree.revert(file_list, rev_tree, not no_backup, pb,
3839
report_changes=True)
3840
finally:
3841
pb.finished()
3842
3843
3844
class cmd_assert_fail(Command):
3845
"""Test reporting of assertion failures"""
3846
# intended just for use in testing
3847
3848
hidden = True
3849
3850
def run(self):
3851
raise AssertionError("always fails")
3852
3853
3854
class cmd_help(Command):
3855
"""Show help on a command or other topic.
3856
"""
3857
3858
_see_also = ['topics']
3859
takes_options = [
3860
Option('long', 'Show help on all commands.'),
3861
]
3862
takes_args = ['topic?']
3863
aliases = ['?', '--help', '-?', '-h']
3864
3865
@display_command
3866
def run(self, topic=None, long=False):
3867
import bzrlib.help
3868
if topic is None and long:
3869
topic = "commands"
3870
bzrlib.help.help(topic)
3871
3872
3873
class cmd_shell_complete(Command):
3874
"""Show appropriate completions for context.
3875
3876
For a list of all available commands, say 'bzr shell-complete'.
3877
"""
3878
takes_args = ['context?']
3879
aliases = ['s-c']
3880
hidden = True
3881
3882
@display_command
3883
def run(self, context=None):
3884
import shellcomplete
3885
shellcomplete.shellcomplete(context)
3886
3887
3888
class cmd_missing(Command):
3889
"""Show unmerged/unpulled revisions between two branches.
3890
3891
OTHER_BRANCH may be local or remote.
3892
3893
To filter on a range of revisions, you can use the command -r begin..end
3894
-r revision requests a specific revision, -r ..end or -r begin.. are
3895
also valid.
3896
3897
:Examples:
3898
3899
Determine the missing revisions between this and the branch at the
3900
remembered pull location::
3901
3902
bzr missing
3903
3904
Determine the missing revisions between this and another branch::
3905
3906
bzr missing http://server/branch
3907
3908
Determine the missing revisions up to a specific revision on the other
3909
branch::
3910
3911
bzr missing -r ..-10
3912
3913
Determine the missing revisions up to a specific revision on this
3914
branch::
3915
3916
bzr missing --my-revision ..-10
3917
"""
3918
3919
_see_also = ['merge', 'pull']
3920
takes_args = ['other_branch?']
3921
takes_options = [
3922
Option('reverse', 'Reverse the order of revisions.'),
3923
Option('mine-only',
3924
'Display changes in the local branch only.'),
3925
Option('this' , 'Same as --mine-only.'),
3926
Option('theirs-only',
3927
'Display changes in the remote branch only.'),
3928
Option('other', 'Same as --theirs-only.'),
3929
'log-format',
3930
'show-ids',
3931
'verbose',
3932
custom_help('revision',
3933
help='Filter on other branch revisions (inclusive). '
3934
'See "help revisionspec" for details.'),
3935
Option('my-revision',
3936
type=_parse_revision_str,
3937
help='Filter on local branch revisions (inclusive). '
3938
'See "help revisionspec" for details.'),
3939
Option('include-merges',
3940
'Show all revisions in addition to the mainline ones.'),
3941
]
3942
encoding_type = 'replace'
3943
3944
@display_command
3945
def run(self, other_branch=None, reverse=False, mine_only=False,
3946
theirs_only=False,
3947
log_format=None, long=False, short=False, line=False,
3948
show_ids=False, verbose=False, this=False, other=False,
3949
include_merges=False, revision=None, my_revision=None):
3950
from bzrlib.missing import find_unmerged, iter_log_revisions
3951
def message(s):
3952
if not is_quiet():
3953
self.outf.write(s)
3954
3955
if this:
3956
mine_only = this
3957
if other:
3958
theirs_only = other
3959
# TODO: We should probably check that we don't have mine-only and
3960
# theirs-only set, but it gets complicated because we also have
3961
# this and other which could be used.
3962
restrict = 'all'
3963
if mine_only:
3964
restrict = 'local'
3965
elif theirs_only:
3966
restrict = 'remote'
3967
3968
local_branch = Branch.open_containing(u".")[0]
3969
parent = local_branch.get_parent()
3970
if other_branch is None:
3971
other_branch = parent
3972
if other_branch is None:
3973
raise errors.BzrCommandError("No peer location known"
3974
" or specified.")
3975
display_url = urlutils.unescape_for_display(parent,
3976
self.outf.encoding)
3977
message("Using saved parent location: "
3978
+ display_url + "\n")
3979
3980
remote_branch = Branch.open(other_branch)
3981
if remote_branch.base == local_branch.base:
3982
remote_branch = local_branch
3983
3984
local_revid_range = _revision_range_to_revid_range(
3985
_get_revision_range(my_revision, local_branch,
3986
self.name()))
3987
3988
remote_revid_range = _revision_range_to_revid_range(
3989
_get_revision_range(revision,
3990
remote_branch, self.name()))
3991
3992
local_branch.lock_read()
3993
try:
3994
remote_branch.lock_read()
3995
try:
3996
local_extra, remote_extra = find_unmerged(
3997
local_branch, remote_branch, restrict,
3998
backward=not reverse,
3999
include_merges=include_merges,
4000
local_revid_range=local_revid_range,
4001
remote_revid_range=remote_revid_range)
4002
4003
if log_format is None:
4004
registry = log.log_formatter_registry
4005
log_format = registry.get_default(local_branch)
4006
lf = log_format(to_file=self.outf,
4007
show_ids=show_ids,
4008
show_timezone='original')
4009
4010
status_code = 0
4011
if local_extra and not theirs_only:
4012
message("You have %d extra revision(s):\n" %
4013
len(local_extra))
4014
for revision in iter_log_revisions(local_extra,
4015
local_branch.repository,
4016
verbose):
4017
lf.log_revision(revision)
4018
printed_local = True
4019
status_code = 1
4020
else:
4021
printed_local = False
4022
4023
if remote_extra and not mine_only:
4024
if printed_local is True:
4025
message("\n\n\n")
4026
message("You are missing %d revision(s):\n" %
4027
len(remote_extra))
4028
for revision in iter_log_revisions(remote_extra,
4029
remote_branch.repository,
4030
verbose):
4031
lf.log_revision(revision)
4032
status_code = 1
4033
4034
if mine_only and not local_extra:
4035
# We checked local, and found nothing extra
4036
message('This branch is up to date.\n')
4037
elif theirs_only and not remote_extra:
4038
# We checked remote, and found nothing extra
4039
message('Other branch is up to date.\n')
4040
elif not (mine_only or theirs_only or local_extra or
4041
remote_extra):
4042
# We checked both branches, and neither one had extra
4043
# revisions
4044
message("Branches are up to date.\n")
4045
finally:
4046
remote_branch.unlock()
4047
finally:
4048
local_branch.unlock()
4049
if not status_code and parent is None and other_branch is not None:
4050
local_branch.lock_write()
4051
try:
4052
# handle race conditions - a parent might be set while we run.
4053
if local_branch.get_parent() is None:
4054
local_branch.set_parent(remote_branch.base)
4055
finally:
4056
local_branch.unlock()
4057
return status_code
4058
4059
4060
class cmd_pack(Command):
4061
"""Compress the data within a repository."""
4062
4063
_see_also = ['repositories']
4064
takes_args = ['branch_or_repo?']
4065
4066
def run(self, branch_or_repo='.'):
4067
dir = bzrdir.BzrDir.open_containing(branch_or_repo)[0]
4068
try:
4069
branch = dir.open_branch()
4070
repository = branch.repository
4071
except errors.NotBranchError:
4072
repository = dir.open_repository()
4073
repository.pack()
4074
4075
4076
class cmd_plugins(Command):
4077
"""List the installed plugins.
4078
4079
This command displays the list of installed plugins including
4080
version of plugin and a short description of each.
4081
4082
--verbose shows the path where each plugin is located.
4083
4084
A plugin is an external component for Bazaar that extends the
4085
revision control system, by adding or replacing code in Bazaar.
4086
Plugins can do a variety of things, including overriding commands,
4087
adding new commands, providing additional network transports and
4088
customizing log output.
4089
4090
See the Bazaar web site, http://bazaar-vcs.org, for further
4091
information on plugins including where to find them and how to
4092
install them. Instructions are also provided there on how to
4093
write new plugins using the Python programming language.
4094
"""
4095
takes_options = ['verbose']
4096
4097
@display_command
4098
def run(self, verbose=False):
4099
import bzrlib.plugin
4100
from inspect import getdoc
4101
result = []
4102
for name, plugin in bzrlib.plugin.plugins().items():
4103
version = plugin.__version__
4104
if version == 'unknown':
4105
version = ''
4106
name_ver = '%s %s' % (name, version)
4107
d = getdoc(plugin.module)
4108
if d:
4109
doc = d.split('\n')[0]
4110
else:
4111
doc = '(no description)'
4112
result.append((name_ver, doc, plugin.path()))
4113
for name_ver, doc, path in sorted(result):
4114
print name_ver
4115
print ' ', doc
4116
if verbose:
4117
print ' ', path
4118
print
4119
4120
4121
class cmd_testament(Command):
4122
"""Show testament (signing-form) of a revision."""
4123
takes_options = [
4124
'revision',
4125
Option('long', help='Produce long-format testament.'),
4126
Option('strict',
4127
help='Produce a strict-format testament.')]
4128
takes_args = ['branch?']
4129
@display_command
4130
def run(self, branch=u'.', revision=None, long=False, strict=False):
4131
from bzrlib.testament import Testament, StrictTestament
4132
if strict is True:
4133
testament_class = StrictTestament
4134
else:
4135
testament_class = Testament
4136
if branch == '.':
4137
b = Branch.open_containing(branch)[0]
4138
else:
4139
b = Branch.open(branch)
4140
b.lock_read()
4141
try:
4142
if revision is None:
4143
rev_id = b.last_revision()
4144
else:
4145
rev_id = revision[0].as_revision_id(b)
4146
t = testament_class.from_revision(b.repository, rev_id)
4147
if long:
4148
sys.stdout.writelines(t.as_text_lines())
4149
else:
4150
sys.stdout.write(t.as_short_text())
4151
finally:
4152
b.unlock()
4153
4154
4155
class cmd_annotate(Command):
4156
"""Show the origin of each line in a file.
4157
4158
This prints out the given file with an annotation on the left side
4159
indicating which revision, author and date introduced the change.
4160
4161
If the origin is the same for a run of consecutive lines, it is
4162
shown only at the top, unless the --all option is given.
4163
"""
4164
# TODO: annotate directories; showing when each file was last changed
4165
# TODO: if the working copy is modified, show annotations on that
4166
# with new uncommitted lines marked
4167
aliases = ['ann', 'blame', 'praise']
4168
takes_args = ['filename']
4169
takes_options = [Option('all', help='Show annotations on all lines.'),
4170
Option('long', help='Show commit date in annotations.'),
4171
'revision',
4172
'show-ids',
4173
]
4174
encoding_type = 'exact'
4175
4176
@display_command
4177
def run(self, filename, all=False, long=False, revision=None,
4178
show_ids=False):
4179
from bzrlib.annotate import annotate_file, annotate_file_tree
4180
wt, branch, relpath = \
4181
bzrdir.BzrDir.open_containing_tree_or_branch(filename)
4182
if wt is not None:
4183
wt.lock_read()
4184
else:
4185
branch.lock_read()
4186
try:
4187
tree = _get_one_revision_tree('annotate', revision, branch=branch)
4188
if wt is not None:
4189
file_id = wt.path2id(relpath)
4190
else:
4191
file_id = tree.path2id(relpath)
4192
if file_id is None:
4193
raise errors.NotVersionedError(filename)
4194
file_version = tree.inventory[file_id].revision
4195
if wt is not None and revision is None:
4196
# If there is a tree and we're not annotating historical
4197
# versions, annotate the working tree's content.
4198
annotate_file_tree(wt, file_id, self.outf, long, all,
4199
show_ids=show_ids)
4200
else:
4201
annotate_file(branch, file_version, file_id, long, all, self.outf,
4202
show_ids=show_ids)
4203
finally:
4204
if wt is not None:
4205
wt.unlock()
4206
else:
4207
branch.unlock()
4208
4209
4210
class cmd_re_sign(Command):
4211
"""Create a digital signature for an existing revision."""
4212
# TODO be able to replace existing ones.
4213
4214
hidden = True # is this right ?
4215
takes_args = ['revision_id*']
4216
takes_options = ['revision']
4217
4218
def run(self, revision_id_list=None, revision=None):
4219
if revision_id_list is not None and revision is not None:
4220
raise errors.BzrCommandError('You can only supply one of revision_id or --revision')
4221
if revision_id_list is None and revision is None:
4222
raise errors.BzrCommandError('You must supply either --revision or a revision_id')
4223
b = WorkingTree.open_containing(u'.')[0].branch
4224
b.lock_write()
4225
try:
4226
return self._run(b, revision_id_list, revision)
4227
finally:
4228
b.unlock()
4229
4230
def _run(self, b, revision_id_list, revision):
4231
import bzrlib.gpg as gpg
4232
gpg_strategy = gpg.GPGStrategy(b.get_config())
4233
if revision_id_list is not None:
4234
b.repository.start_write_group()
4235
try:
4236
for revision_id in revision_id_list:
4237
b.repository.sign_revision(revision_id, gpg_strategy)
4238
except:
4239
b.repository.abort_write_group()
4240
raise
4241
else:
4242
b.repository.commit_write_group()
4243
elif revision is not None:
4244
if len(revision) == 1:
4245
revno, rev_id = revision[0].in_history(b)
4246
b.repository.start_write_group()
4247
try:
4248
b.repository.sign_revision(rev_id, gpg_strategy)
4249
except:
4250
b.repository.abort_write_group()
4251
raise
4252
else:
4253
b.repository.commit_write_group()
4254
elif len(revision) == 2:
4255
# are they both on rh- if so we can walk between them
4256
# might be nice to have a range helper for arbitrary
4257
# revision paths. hmm.
4258
from_revno, from_revid = revision[0].in_history(b)
4259
to_revno, to_revid = revision[1].in_history(b)
4260
if to_revid is None:
4261
to_revno = b.revno()
4262
if from_revno is None or to_revno is None:
4263
raise errors.BzrCommandError('Cannot sign a range of non-revision-history revisions')
4264
b.repository.start_write_group()
4265
try:
4266
for revno in range(from_revno, to_revno + 1):
4267
b.repository.sign_revision(b.get_rev_id(revno),
4268
gpg_strategy)
4269
except:
4270
b.repository.abort_write_group()
4271
raise
4272
else:
4273
b.repository.commit_write_group()
4274
else:
4275
raise errors.BzrCommandError('Please supply either one revision, or a range.')
4276
4277
4278
class cmd_bind(Command):
4279
"""Convert the current branch into a checkout of the supplied branch.
4280
4281
Once converted into a checkout, commits must succeed on the master branch
4282
before they will be applied to the local branch.
4283
4284
Bound branches use the nickname of its master branch unless it is set
4285
locally, in which case binding will update the the local nickname to be
4286
that of the master.
4287
"""
4288
4289
_see_also = ['checkouts', 'unbind']
4290
takes_args = ['location?']
4291
takes_options = []
4292
4293
def run(self, location=None):
4294
b, relpath = Branch.open_containing(u'.')
4295
if location is None:
4296
try:
4297
location = b.get_old_bound_location()
4298
except errors.UpgradeRequired:
4299
raise errors.BzrCommandError('No location supplied. '
4300
'This format does not remember old locations.')
4301
else:
4302
if location is None:
4303
raise errors.BzrCommandError('No location supplied and no '
4304
'previous location known')
4305
b_other = Branch.open(location)
4306
try:
4307
b.bind(b_other)
4308
except errors.DivergedBranches:
4309
raise errors.BzrCommandError('These branches have diverged.'
4310
' Try merging, and then bind again.')
4311
if b.get_config().has_explicit_nickname():
4312
b.nick = b_other.nick
4313
4314
4315
class cmd_unbind(Command):
4316
"""Convert the current checkout into a regular branch.
4317
4318
After unbinding, the local branch is considered independent and subsequent
4319
commits will be local only.
4320
"""
4321
4322
_see_also = ['checkouts', 'bind']
4323
takes_args = []
4324
takes_options = []
4325
4326
def run(self):
4327
b, relpath = Branch.open_containing(u'.')
4328
if not b.unbind():
4329
raise errors.BzrCommandError('Local branch is not bound')
4330
4331
4332
class cmd_uncommit(Command):
4333
"""Remove the last committed revision.
4334
4335
--verbose will print out what is being removed.
4336
--dry-run will go through all the motions, but not actually
4337
remove anything.
4338
4339
If --revision is specified, uncommit revisions to leave the branch at the
4340
specified revision. For example, "bzr uncommit -r 15" will leave the
4341
branch at revision 15.
4342
4343
Uncommit leaves the working tree ready for a new commit. The only change
4344
it may make is to restore any pending merges that were present before
4345
the commit.
4346
"""
4347
4348
# TODO: jam 20060108 Add an option to allow uncommit to remove
4349
# unreferenced information in 'branch-as-repository' branches.
4350
# TODO: jam 20060108 Add the ability for uncommit to remove unreferenced
4351
# information in shared branches as well.
4352
_see_also = ['commit']
4353
takes_options = ['verbose', 'revision',
4354
Option('dry-run', help='Don\'t actually make changes.'),
4355
Option('force', help='Say yes to all questions.'),
4356
Option('local',
4357
help="Only remove the commits from the local branch"
4358
" when in a checkout."
4359
),
4360
]
4361
takes_args = ['location?']
4362
aliases = []
4363
encoding_type = 'replace'
4364
4365
def run(self, location=None,
4366
dry_run=False, verbose=False,
4367
revision=None, force=False, local=False):
4368
if location is None:
4369
location = u'.'
4370
control, relpath = bzrdir.BzrDir.open_containing(location)
4371
try:
4372
tree = control.open_workingtree()
4373
b = tree.branch
4374
except (errors.NoWorkingTree, errors.NotLocalUrl):
4375
tree = None
4376
b = control.open_branch()
4377
4378
if tree is not None:
4379
tree.lock_write()
4380
else:
4381
b.lock_write()
4382
try:
4383
return self._run(b, tree, dry_run, verbose, revision, force,
4384
local=local)
4385
finally:
4386
if tree is not None:
4387
tree.unlock()
4388
else:
4389
b.unlock()
4390
4391
def _run(self, b, tree, dry_run, verbose, revision, force, local=False):
4392
from bzrlib.log import log_formatter, show_log
4393
from bzrlib.uncommit import uncommit
4394
4395
last_revno, last_rev_id = b.last_revision_info()
4396
4397
rev_id = None
4398
if revision is None:
4399
revno = last_revno
4400
rev_id = last_rev_id
4401
else:
4402
# 'bzr uncommit -r 10' actually means uncommit
4403
# so that the final tree is at revno 10.
4404
# but bzrlib.uncommit.uncommit() actually uncommits
4405
# the revisions that are supplied.
4406
# So we need to offset it by one
4407
revno = revision[0].in_history(b).revno + 1
4408
if revno <= last_revno:
4409
rev_id = b.get_rev_id(revno)
4410
4411
if rev_id is None or _mod_revision.is_null(rev_id):
4412
self.outf.write('No revisions to uncommit.\n')
4413
return 1
4414
4415
lf = log_formatter('short',
4416
to_file=self.outf,
4417
show_timezone='original')
4418
4419
show_log(b,
4420
lf,
4421
verbose=False,
4422
direction='forward',
4423
start_revision=revno,
4424
end_revision=last_revno)
4425
4426
if dry_run:
4427
print 'Dry-run, pretending to remove the above revisions.'
4428
if not force:
4429
val = raw_input('Press <enter> to continue')
4430
else:
4431
print 'The above revision(s) will be removed.'
4432
if not force:
4433
val = raw_input('Are you sure [y/N]? ')
4434
if val.lower() not in ('y', 'yes'):
4435
print 'Canceled'
4436
return 0
4437
4438
mutter('Uncommitting from {%s} to {%s}',
4439
last_rev_id, rev_id)
4440
uncommit(b, tree=tree, dry_run=dry_run, verbose=verbose,
4441
revno=revno, local=local)
4442
note('You can restore the old tip by running:\n'
4443
' bzr pull . -r revid:%s', last_rev_id)
4444
4445
4446
class cmd_break_lock(Command):
4447
"""Break a dead lock on a repository, branch or working directory.
4448
4449
CAUTION: Locks should only be broken when you are sure that the process
4450
holding the lock has been stopped.
4451
4452
You can get information on what locks are open via the 'bzr info' command.
4453
4454
:Examples:
4455
bzr break-lock
4456
"""
4457
takes_args = ['location?']
4458
4459
def run(self, location=None, show=False):
4460
if location is None:
4461
location = u'.'
4462
control, relpath = bzrdir.BzrDir.open_containing(location)
4463
try:
4464
control.break_lock()
4465
except NotImplementedError:
4466
pass
4467
4468
4469
class cmd_wait_until_signalled(Command):
4470
"""Test helper for test_start_and_stop_bzr_subprocess_send_signal.
4471
4472
This just prints a line to signal when it is ready, then blocks on stdin.
4473
"""
4474
4475
hidden = True
4476
4477
def run(self):
4478
sys.stdout.write("running\n")
4479
sys.stdout.flush()
4480
sys.stdin.readline()
4481
4482
4483
class cmd_serve(Command):
4484
"""Run the bzr server."""
4485
4486
aliases = ['server']
4487
4488
takes_options = [
4489
Option('inet',
4490
help='Serve on stdin/out for use from inetd or sshd.'),
4491
Option('port',
4492
help='Listen for connections on nominated port of the form '
4493
'[hostname:]portnumber. Passing 0 as the port number will '
4494
'result in a dynamically allocated port. The default port is '
4495
'4155.',
4496
type=str),
4497
Option('directory',
4498
help='Serve contents of this directory.',
4499
type=unicode),
4500
Option('allow-writes',
4501
help='By default the server is a readonly server. Supplying '
4502
'--allow-writes enables write access to the contents of '
4503
'the served directory and below.'
4504
),
4505
]
4506
4507
def run_smart_server(self, smart_server):
4508
"""Run 'smart_server' forever, with no UI output at all."""
4509
# For the duration of this server, no UI output is permitted. note
4510
# that this may cause problems with blackbox tests. This should be
4511
# changed with care though, as we dont want to use bandwidth sending
4512
# progress over stderr to smart server clients!
4513
from bzrlib import lockdir
4514
old_factory = ui.ui_factory
4515
old_lockdir_timeout = lockdir._DEFAULT_TIMEOUT_SECONDS
4516
try:
4517
ui.ui_factory = ui.SilentUIFactory()
4518
lockdir._DEFAULT_TIMEOUT_SECONDS = 0
4519
smart_server.serve()
4520
finally:
4521
ui.ui_factory = old_factory
4522
lockdir._DEFAULT_TIMEOUT_SECONDS = old_lockdir_timeout
4523
4524
def get_host_and_port(self, port):
4525
"""Return the host and port to run the smart server on.
4526
4527
If 'port' is None, the default host (`medium.BZR_DEFAULT_INTERFACE`)
4528
and port (`medium.BZR_DEFAULT_PORT`) will be used.
4529
4530
If 'port' has a colon in it, the string before the colon will be
4531
interpreted as the host.
4532
4533
:param port: A string of the port to run the server on.
4534
:return: A tuple of (host, port), where 'host' is a host name or IP,
4535
and port is an integer TCP/IP port.
4536
"""
4537
from bzrlib.smart import medium
4538
host = medium.BZR_DEFAULT_INTERFACE
4539
if port is None:
4540
port = medium.BZR_DEFAULT_PORT
4541
else:
4542
if ':' in port:
4543
host, port = port.split(':')
4544
port = int(port)
4545
return host, port
4546
4547
def get_smart_server(self, transport, inet, port):
4548
"""Construct a smart server.
4549
4550
:param transport: The base transport from which branches will be
4551
served.
4552
:param inet: If True, serve over stdin and stdout. Used for running
4553
from inet.
4554
:param port: The port to listen on. By default, it's `
4555
medium.BZR_DEFAULT_PORT`. See `get_host_and_port` for more
4556
information.
4557
:return: A smart server.
4558
"""
4559
from bzrlib.smart import medium, server
4560
if inet:
4561
smart_server = medium.SmartServerPipeStreamMedium(
4562
sys.stdin, sys.stdout, transport)
4563
else:
4564
host, port = self.get_host_and_port(port)
4565
smart_server = server.SmartTCPServer(
4566
transport, host=host, port=port)
4567
note('listening on port: %s' % smart_server.port)
4568
return smart_server
4569
4570
def run(self, port=None, inet=False, directory=None, allow_writes=False):
4571
from bzrlib.transport import get_transport
4572
from bzrlib.transport.chroot import ChrootServer
4573
if directory is None:
4574
directory = os.getcwd()
4575
url = urlutils.local_path_to_url(directory)
4576
if not allow_writes:
4577
url = 'readonly+' + url
4578
chroot_server = ChrootServer(get_transport(url))
4579
chroot_server.setUp()
4580
t = get_transport(chroot_server.get_url())
4581
smart_server = self.get_smart_server(t, inet, port)
4582
self.run_smart_server(smart_server)
4583
4584
4585
class cmd_join(Command):
4586
"""Combine a subtree into its containing tree.
4587
4588
This command is for experimental use only. It requires the target tree
4589
to be in dirstate-with-subtree format, which cannot be converted into
4590
earlier formats.
4591
4592
The TREE argument should be an independent tree, inside another tree, but
4593
not part of it. (Such trees can be produced by "bzr split", but also by
4594
running "bzr branch" with the target inside a tree.)
4595
4596
The result is a combined tree, with the subtree no longer an independant
4597
part. This is marked as a merge of the subtree into the containing tree,
4598
and all history is preserved.
4599
4600
If --reference is specified, the subtree retains its independence. It can
4601
be branched by itself, and can be part of multiple projects at the same
4602
time. But operations performed in the containing tree, such as commit
4603
and merge, will recurse into the subtree.
4604
"""
4605
4606
_see_also = ['split']
4607
takes_args = ['tree']
4608
takes_options = [
4609
Option('reference', help='Join by reference.'),
4610
]
4611
hidden = True
4612
4613
def run(self, tree, reference=False):
4614
sub_tree = WorkingTree.open(tree)
4615
parent_dir = osutils.dirname(sub_tree.basedir)
4616
containing_tree = WorkingTree.open_containing(parent_dir)[0]
4617
repo = containing_tree.branch.repository
4618
if not repo.supports_rich_root():
4619
raise errors.BzrCommandError(
4620
"Can't join trees because %s doesn't support rich root data.\n"
4621
"You can use bzr upgrade on the repository."
4622
% (repo,))
4623
if reference:
4624
try:
4625
containing_tree.add_reference(sub_tree)
4626
except errors.BadReferenceTarget, e:
4627
# XXX: Would be better to just raise a nicely printable
4628
# exception from the real origin. Also below. mbp 20070306
4629
raise errors.BzrCommandError("Cannot join %s. %s" %
4630
(tree, e.reason))
4631
else:
4632
try:
4633
containing_tree.subsume(sub_tree)
4634
except errors.BadSubsumeSource, e:
4635
raise errors.BzrCommandError("Cannot join %s. %s" %
4636
(tree, e.reason))
4637
4638
4639
class cmd_split(Command):
4640
"""Split a subdirectory of a tree into a separate tree.
4641
4642
This command will produce a target tree in a format that supports
4643
rich roots, like 'rich-root' or 'rich-root-pack'. These formats cannot be
4644
converted into earlier formats like 'dirstate-tags'.
4645
4646
The TREE argument should be a subdirectory of a working tree. That
4647
subdirectory will be converted into an independent tree, with its own
4648
branch. Commits in the top-level tree will not apply to the new subtree.
4649
"""
4650
4651
# join is not un-hidden yet
4652
#_see_also = ['join']
4653
takes_args = ['tree']
4654
4655
def run(self, tree):
4656
containing_tree, subdir = WorkingTree.open_containing(tree)
4657
sub_id = containing_tree.path2id(subdir)
4658
if sub_id is None:
4659
raise errors.NotVersionedError(subdir)
4660
try:
4661
containing_tree.extract(sub_id)
4662
except errors.RootNotRich:
4663
raise errors.UpgradeRequired(containing_tree.branch.base)
4664
4665
4666
class cmd_merge_directive(Command):
4667
"""Generate a merge directive for auto-merge tools.
4668
4669
A directive requests a merge to be performed, and also provides all the
4670
information necessary to do so. This means it must either include a
4671
revision bundle, or the location of a branch containing the desired
4672
revision.
4673
4674
A submit branch (the location to merge into) must be supplied the first
4675
time the command is issued. After it has been supplied once, it will
4676
be remembered as the default.
4677
4678
A public branch is optional if a revision bundle is supplied, but required
4679
if --diff or --plain is specified. It will be remembered as the default
4680
after the first use.
4681
"""
4682
4683
takes_args = ['submit_branch?', 'public_branch?']
4684
4685
hidden = True
4686
4687
_see_also = ['send']
4688
4689
takes_options = [
4690
RegistryOption.from_kwargs('patch-type',
4691
'The type of patch to include in the directive.',
4692
title='Patch type',
4693
value_switches=True,
4694
enum_switch=False,
4695
bundle='Bazaar revision bundle (default).',
4696
diff='Normal unified diff.',
4697
plain='No patch, just directive.'),
4698
Option('sign', help='GPG-sign the directive.'), 'revision',
4699
Option('mail-to', type=str,
4700
help='Instead of printing the directive, email to this address.'),
4701
Option('message', type=str, short_name='m',
4702
help='Message to use when committing this merge.')
4703
]
4704
4705
encoding_type = 'exact'
4706
4707
def run(self, submit_branch=None, public_branch=None, patch_type='bundle',
4708
sign=False, revision=None, mail_to=None, message=None):
4709
from bzrlib.revision import ensure_null, NULL_REVISION
4710
include_patch, include_bundle = {
4711
'plain': (False, False),
4712
'diff': (True, False),
4713
'bundle': (True, True),
4714
}[patch_type]
4715
branch = Branch.open('.')
4716
stored_submit_branch = branch.get_submit_branch()
4717
if submit_branch is None:
4718
submit_branch = stored_submit_branch
4719
else:
4720
if stored_submit_branch is None:
4721
branch.set_submit_branch(submit_branch)
4722
if submit_branch is None:
4723
submit_branch = branch.get_parent()
4724
if submit_branch is None:
4725
raise errors.BzrCommandError('No submit branch specified or known')
4726
4727
stored_public_branch = branch.get_public_branch()
4728
if public_branch is None:
4729
public_branch = stored_public_branch
4730
elif stored_public_branch is None:
4731
branch.set_public_branch(public_branch)
4732
if not include_bundle and public_branch is None:
4733
raise errors.BzrCommandError('No public branch specified or'
4734
' known')
4735
base_revision_id = None
4736
if revision is not None:
4737
if len(revision) > 2:
4738
raise errors.BzrCommandError('bzr merge-directive takes '
4739
'at most two one revision identifiers')
4740
revision_id = revision[-1].as_revision_id(branch)
4741
if len(revision) == 2:
4742
base_revision_id = revision[0].as_revision_id(branch)
4743
else:
4744
revision_id = branch.last_revision()
4745
revision_id = ensure_null(revision_id)
4746
if revision_id == NULL_REVISION:
4747
raise errors.BzrCommandError('No revisions to bundle.')
4748
directive = merge_directive.MergeDirective2.from_objects(
4749
branch.repository, revision_id, time.time(),
4750
osutils.local_time_offset(), submit_branch,
4751
public_branch=public_branch, include_patch=include_patch,
4752
include_bundle=include_bundle, message=message,
4753
base_revision_id=base_revision_id)
4754
if mail_to is None:
4755
if sign:
4756
self.outf.write(directive.to_signed(branch))
4757
else:
4758
self.outf.writelines(directive.to_lines())
4759
else:
4760
message = directive.to_email(mail_to, branch, sign)
4761
s = SMTPConnection(branch.get_config())
4762
s.send_email(message)
4763
4764
4765
class cmd_send(Command):
4766
"""Mail or create a merge-directive for submitting changes.
4767
4768
A merge directive provides many things needed for requesting merges:
4769
4770
* A machine-readable description of the merge to perform
4771
4772
* An optional patch that is a preview of the changes requested
4773
4774
* An optional bundle of revision data, so that the changes can be applied
4775
directly from the merge directive, without retrieving data from a
4776
branch.
4777
4778
If --no-bundle is specified, then public_branch is needed (and must be
4779
up-to-date), so that the receiver can perform the merge using the
4780
public_branch. The public_branch is always included if known, so that
4781
people can check it later.
4782
4783
The submit branch defaults to the parent, but can be overridden. Both
4784
submit branch and public branch will be remembered if supplied.
4785
4786
If a public_branch is known for the submit_branch, that public submit
4787
branch is used in the merge instructions. This means that a local mirror
4788
can be used as your actual submit branch, once you have set public_branch
4789
for that mirror.
4790
4791
Mail is sent using your preferred mail program. This should be transparent
4792
on Windows (it uses MAPI). On Linux, it requires the xdg-email utility.
4793
If the preferred client can't be found (or used), your editor will be used.
4794
4795
To use a specific mail program, set the mail_client configuration option.
4796
(For Thunderbird 1.5, this works around some bugs.) Supported values for
4797
specific clients are "claws", "evolution", "kmail", "mutt", and
4798
"thunderbird"; generic options are "default", "editor", "emacsclient",
4799
"mapi", and "xdg-email". Plugins may also add supported clients.
4800
4801
If mail is being sent, a to address is required. This can be supplied
4802
either on the commandline, by setting the submit_to configuration
4803
option in the branch itself or the child_submit_to configuration option
4804
in the submit branch.
4805
4806
Two formats are currently supported: "4" uses revision bundle format 4 and
4807
merge directive format 2. It is significantly faster and smaller than
4808
older formats. It is compatible with Bazaar 0.19 and later. It is the
4809
default. "0.9" uses revision bundle format 0.9 and merge directive
4810
format 1. It is compatible with Bazaar 0.12 - 0.18.
4811
4812
The merge directives created by bzr send may be applied using bzr merge or
4813
bzr pull by specifying a file containing a merge directive as the location.
4814
"""
4815
4816
encoding_type = 'exact'
4817
4818
_see_also = ['merge', 'pull']
4819
4820
takes_args = ['submit_branch?', 'public_branch?']
4821
4822
takes_options = [
4823
Option('no-bundle',
4824
help='Do not include a bundle in the merge directive.'),
4825
Option('no-patch', help='Do not include a preview patch in the merge'
4826
' directive.'),
4827
Option('remember',
4828
help='Remember submit and public branch.'),
4829
Option('from',
4830
help='Branch to generate the submission from, '
4831
'rather than the one containing the working directory.',
4832
short_name='f',
4833
type=unicode),
4834
Option('output', short_name='o',
4835
help='Write merge directive to this file; '
4836
'use - for stdout.',
4837
type=unicode),
4838
Option('mail-to', help='Mail the request to this address.',
4839
type=unicode),
4840
'revision',
4841
'message',
4842
Option('body', help='Body for the email.', type=unicode),
4843
RegistryOption.from_kwargs('format',
4844
'Use the specified output format.',
4845
**{'4': 'Bundle format 4, Merge Directive 2 (default)',
4846
'0.9': 'Bundle format 0.9, Merge Directive 1',})
4847
]
4848
4849
def run(self, submit_branch=None, public_branch=None, no_bundle=False,
4850
no_patch=False, revision=None, remember=False, output=None,
4851
format='4', mail_to=None, message=None, body=None, **kwargs):
4852
return self._run(submit_branch, revision, public_branch, remember,
4853
format, no_bundle, no_patch, output,
4854
kwargs.get('from', '.'), mail_to, message, body)
4855
4856
def _run(self, submit_branch, revision, public_branch, remember, format,
4857
no_bundle, no_patch, output, from_, mail_to, message, body):
4858
from bzrlib.revision import NULL_REVISION
4859
branch = Branch.open_containing(from_)[0]
4860
if output is None:
4861
outfile = cStringIO.StringIO()
4862
elif output == '-':
4863
outfile = self.outf
4864
else:
4865
outfile = open(output, 'wb')
4866
# we may need to write data into branch's repository to calculate
4867
# the data to send.
4868
branch.lock_write()
4869
try:
4870
if output is None:
4871
config = branch.get_config()
4872
if mail_to is None:
4873
mail_to = config.get_user_option('submit_to')
4874
mail_client = config.get_mail_client()
4875
if (not getattr(mail_client, 'supports_body', False)
4876
and body is not None):
4877
raise errors.BzrCommandError(
4878
'Mail client "%s" does not support specifying body' %
4879
mail_client.__class__.__name__)
4880
if remember and submit_branch is None:
4881
raise errors.BzrCommandError(
4882
'--remember requires a branch to be specified.')
4883
stored_submit_branch = branch.get_submit_branch()
4884
remembered_submit_branch = None
4885
if submit_branch is None:
4886
submit_branch = stored_submit_branch
4887
remembered_submit_branch = "submit"
4888
else:
4889
if stored_submit_branch is None or remember:
4890
branch.set_submit_branch(submit_branch)
4891
if submit_branch is None:
4892
submit_branch = branch.get_parent()
4893
remembered_submit_branch = "parent"
4894
if submit_branch is None:
4895
raise errors.BzrCommandError('No submit branch known or'
4896
' specified')
4897
if remembered_submit_branch is not None:
4898
note('Using saved %s location "%s" to determine what '
4899
'changes to submit.', remembered_submit_branch,
4900
submit_branch)
4901
4902
if mail_to is None:
4903
submit_config = Branch.open(submit_branch).get_config()
4904
mail_to = submit_config.get_user_option("child_submit_to")
4905
4906
stored_public_branch = branch.get_public_branch()
4907
if public_branch is None:
4908
public_branch = stored_public_branch
4909
elif stored_public_branch is None or remember:
4910
branch.set_public_branch(public_branch)
4911
if no_bundle and public_branch is None:
4912
raise errors.BzrCommandError('No public branch specified or'
4913
' known')
4914
base_revision_id = None
4915
revision_id = None
4916
if revision is not None:
4917
if len(revision) > 2:
4918
raise errors.BzrCommandError('bzr send takes '
4919
'at most two one revision identifiers')
4920
revision_id = revision[-1].as_revision_id(branch)
4921
if len(revision) == 2:
4922
base_revision_id = revision[0].as_revision_id(branch)
4923
if revision_id is None:
4924
revision_id = branch.last_revision()
4925
if revision_id == NULL_REVISION:
4926
raise errors.BzrCommandError('No revisions to submit.')
4927
if format == '4':
4928
directive = merge_directive.MergeDirective2.from_objects(
4929
branch.repository, revision_id, time.time(),
4930
osutils.local_time_offset(), submit_branch,
4931
public_branch=public_branch, include_patch=not no_patch,
4932
include_bundle=not no_bundle, message=message,
4933
base_revision_id=base_revision_id)
4934
elif format == '0.9':
4935
if not no_bundle:
4936
if not no_patch:
4937
patch_type = 'bundle'
4938
else:
4939
raise errors.BzrCommandError('Format 0.9 does not'
4940
' permit bundle with no patch')
4941
else:
4942
if not no_patch:
4943
patch_type = 'diff'
4944
else:
4945
patch_type = None
4946
directive = merge_directive.MergeDirective.from_objects(
4947
branch.repository, revision_id, time.time(),
4948
osutils.local_time_offset(), submit_branch,
4949
public_branch=public_branch, patch_type=patch_type,
4950
message=message)
4951
4952
outfile.writelines(directive.to_lines())
4953
if output is None:
4954
subject = '[MERGE] '
4955
if message is not None:
4956
subject += message
4957
else:
4958
revision = branch.repository.get_revision(revision_id)
4959
subject += revision.get_summary()
4960
basename = directive.get_disk_name(branch)
4961
mail_client.compose_merge_request(mail_to, subject,
4962
outfile.getvalue(),
4963
basename, body)
4964
finally:
4965
if output != '-':
4966
outfile.close()
4967
branch.unlock()
4968
4969
4970
class cmd_bundle_revisions(cmd_send):
4971
4972
"""Create a merge-directive for submitting changes.
4973
4974
A merge directive provides many things needed for requesting merges:
4975
4976
* A machine-readable description of the merge to perform
4977
4978
* An optional patch that is a preview of the changes requested
4979
4980
* An optional bundle of revision data, so that the changes can be applied
4981
directly from the merge directive, without retrieving data from a
4982
branch.
4983
4984
If --no-bundle is specified, then public_branch is needed (and must be
4985
up-to-date), so that the receiver can perform the merge using the
4986
public_branch. The public_branch is always included if known, so that
4987
people can check it later.
4988
4989
The submit branch defaults to the parent, but can be overridden. Both
4990
submit branch and public branch will be remembered if supplied.
4991
4992
If a public_branch is known for the submit_branch, that public submit
4993
branch is used in the merge instructions. This means that a local mirror
4994
can be used as your actual submit branch, once you have set public_branch
4995
for that mirror.
4996
4997
Two formats are currently supported: "4" uses revision bundle format 4 and
4998
merge directive format 2. It is significantly faster and smaller than
4999
older formats. It is compatible with Bazaar 0.19 and later. It is the
5000
default. "0.9" uses revision bundle format 0.9 and merge directive
5001
format 1. It is compatible with Bazaar 0.12 - 0.18.
5002
"""
5003
5004
takes_options = [
5005
Option('no-bundle',
5006
help='Do not include a bundle in the merge directive.'),
5007
Option('no-patch', help='Do not include a preview patch in the merge'
5008
' directive.'),
5009
Option('remember',
5010
help='Remember submit and public branch.'),
5011
Option('from',
5012
help='Branch to generate the submission from, '
5013
'rather than the one containing the working directory.',
5014
short_name='f',
5015
type=unicode),
5016
Option('output', short_name='o', help='Write directive to this file.',
5017
type=unicode),
5018
'revision',
5019
RegistryOption.from_kwargs('format',
5020
'Use the specified output format.',
5021
**{'4': 'Bundle format 4, Merge Directive 2 (default)',
5022
'0.9': 'Bundle format 0.9, Merge Directive 1',})
5023
]
5024
aliases = ['bundle']
5025
5026
_see_also = ['send', 'merge']
5027
5028
hidden = True
5029
5030
def run(self, submit_branch=None, public_branch=None, no_bundle=False,
5031
no_patch=False, revision=None, remember=False, output=None,
5032
format='4', **kwargs):
5033
if output is None:
5034
output = '-'
5035
return self._run(submit_branch, revision, public_branch, remember,
5036
format, no_bundle, no_patch, output,
5037
kwargs.get('from', '.'), None, None, None)
5038
5039
5040
class cmd_tag(Command):
5041
"""Create, remove or modify a tag naming a revision.
5042
5043
Tags give human-meaningful names to revisions. Commands that take a -r
5044
(--revision) option can be given -rtag:X, where X is any previously
5045
created tag.
5046
5047
Tags are stored in the branch. Tags are copied from one branch to another
5048
along when you branch, push, pull or merge.
5049
5050
It is an error to give a tag name that already exists unless you pass
5051
--force, in which case the tag is moved to point to the new revision.
5052
5053
To rename a tag (change the name but keep it on the same revsion), run ``bzr
5054
tag new-name -r tag:old-name`` and then ``bzr tag --delete oldname``.
5055
"""
5056
5057
_see_also = ['commit', 'tags']
5058
takes_args = ['tag_name']
5059
takes_options = [
5060
Option('delete',
5061
help='Delete this tag rather than placing it.',
5062
),
5063
Option('directory',
5064
help='Branch in which to place the tag.',
5065
short_name='d',
5066
type=unicode,
5067
),
5068
Option('force',
5069
help='Replace existing tags.',
5070
),
5071
'revision',
5072
]
5073
5074
def run(self, tag_name,
5075
delete=None,
5076
directory='.',
5077
force=None,
5078
revision=None,
5079
):
5080
branch, relpath = Branch.open_containing(directory)
5081
branch.lock_write()
5082
try:
5083
if delete:
5084
branch.tags.delete_tag(tag_name)
5085
self.outf.write('Deleted tag %s.\n' % tag_name)
5086
else:
5087
if revision:
5088
if len(revision) != 1:
5089
raise errors.BzrCommandError(
5090
"Tags can only be placed on a single revision, "
5091
"not on a range")
5092
revision_id = revision[0].as_revision_id(branch)
5093
else:
5094
revision_id = branch.last_revision()
5095
if (not force) and branch.tags.has_tag(tag_name):
5096
raise errors.TagAlreadyExists(tag_name)
5097
branch.tags.set_tag(tag_name, revision_id)
5098
self.outf.write('Created tag %s.\n' % tag_name)
5099
finally:
5100
branch.unlock()
5101
5102
5103
class cmd_tags(Command):
5104
"""List tags.
5105
5106
This command shows a table of tag names and the revisions they reference.
5107
"""
5108
5109
_see_also = ['tag']
5110
takes_options = [
5111
Option('directory',
5112
help='Branch whose tags should be displayed.',
5113
short_name='d',
5114
type=unicode,
5115
),
5116
RegistryOption.from_kwargs('sort',
5117
'Sort tags by different criteria.', title='Sorting',
5118
alpha='Sort tags lexicographically (default).',
5119
time='Sort tags chronologically.',
5120
),
5121
'show-ids',
5122
'revision',
5123
]
5124
5125
@display_command
5126
def run(self,
5127
directory='.',
5128
sort='alpha',
5129
show_ids=False,
5130
revision=None,
5131
):
5132
branch, relpath = Branch.open_containing(directory)
5133
5134
tags = branch.tags.get_tag_dict().items()
5135
if not tags:
5136
return
5137
5138
if revision:
5139
branch.lock_read()
5140
try:
5141
graph = branch.repository.get_graph()
5142
rev1, rev2 = _get_revision_range(revision, branch, self.name())
5143
revid1, revid2 = rev1.rev_id, rev2.rev_id
5144
# only show revisions between revid1 and revid2 (inclusive)
5145
tags = [(tag, revid) for tag, revid in tags if
5146
graph.is_between(revid, revid1, revid2)]
5147
finally:
5148
branch.unlock()
5149
if sort == 'alpha':
5150
tags.sort()
5151
elif sort == 'time':
5152
timestamps = {}
5153
for tag, revid in tags:
5154
try:
5155
revobj = branch.repository.get_revision(revid)
5156
except errors.NoSuchRevision:
5157
timestamp = sys.maxint # place them at the end
5158
else:
5159
timestamp = revobj.timestamp
5160
timestamps[revid] = timestamp
5161
tags.sort(key=lambda x: timestamps[x[1]])
5162
if not show_ids:
5163
# [ (tag, revid), ... ] -> [ (tag, dotted_revno), ... ]
5164
revno_map = branch.get_revision_id_to_revno_map()
5165
tags = [ (tag, '.'.join(map(str, revno_map.get(revid, ('?',)))))
5166
for tag, revid in tags ]
5167
for tag, revspec in tags:
5168
self.outf.write('%-20s %s\n' % (tag, revspec))
5169
5170
5171
class cmd_reconfigure(Command):
5172
"""Reconfigure the type of a bzr directory.
5173
5174
A target configuration must be specified.
5175
5176
For checkouts, the bind-to location will be auto-detected if not specified.
5177
The order of preference is
5178
1. For a lightweight checkout, the current bound location.
5179
2. For branches that used to be checkouts, the previously-bound location.
5180
3. The push location.
5181
4. The parent location.
5182
If none of these is available, --bind-to must be specified.
5183
"""
5184
5185
_see_also = ['branches', 'checkouts', 'standalone-trees', 'working-trees']
5186
takes_args = ['location?']
5187
takes_options = [
5188
RegistryOption.from_kwargs(
5189
'target_type',
5190
title='Target type',
5191
help='The type to reconfigure the directory to.',
5192
value_switches=True, enum_switch=False,
5193
branch='Reconfigure to be an unbound branch with no working tree.',
5194
tree='Reconfigure to be an unbound branch with a working tree.',
5195
checkout='Reconfigure to be a bound branch with a working tree.',
5196
lightweight_checkout='Reconfigure to be a lightweight'
5197
' checkout (with no local history).',
5198
standalone='Reconfigure to be a standalone branch '
5199
'(i.e. stop using shared repository).',
5200
use_shared='Reconfigure to use a shared repository.',
5201
with_trees='Reconfigure repository to create '
5202
'working trees on branches by default.',
5203
with_no_trees='Reconfigure repository to not create '
5204
'working trees on branches by default.'
5205
),
5206
Option('bind-to', help='Branch to bind checkout to.', type=str),
5207
Option('force',
5208
help='Perform reconfiguration even if local changes'
5209
' will be lost.')
5210
]
5211
5212
def run(self, location=None, target_type=None, bind_to=None, force=False):
5213
directory = bzrdir.BzrDir.open(location)
5214
if target_type is None:
5215
raise errors.BzrCommandError('No target configuration specified')
5216
elif target_type == 'branch':
5217
reconfiguration = reconfigure.Reconfigure.to_branch(directory)
5218
elif target_type == 'tree':
5219
reconfiguration = reconfigure.Reconfigure.to_tree(directory)
5220
elif target_type == 'checkout':
5221
reconfiguration = reconfigure.Reconfigure.to_checkout(
5222
directory, bind_to)
5223
elif target_type == 'lightweight-checkout':
5224
reconfiguration = reconfigure.Reconfigure.to_lightweight_checkout(
5225
directory, bind_to)
5226
elif target_type == 'use-shared':
5227
reconfiguration = reconfigure.Reconfigure.to_use_shared(directory)
5228
elif target_type == 'standalone':
5229
reconfiguration = reconfigure.Reconfigure.to_standalone(directory)
5230
elif target_type == 'with-trees':
5231
reconfiguration = reconfigure.Reconfigure.set_repository_trees(
5232
directory, True)
5233
elif target_type == 'with-no-trees':
5234
reconfiguration = reconfigure.Reconfigure.set_repository_trees(
5235
directory, False)
5236
reconfiguration.apply(force)
5237
5238
5239
class cmd_switch(Command):
5240
"""Set the branch of a checkout and update.
5241
5242
For lightweight checkouts, this changes the branch being referenced.
5243
For heavyweight checkouts, this checks that there are no local commits
5244
versus the current bound branch, then it makes the local branch a mirror
5245
of the new location and binds to it.
5246
5247
In both cases, the working tree is updated and uncommitted changes
5248
are merged. The user can commit or revert these as they desire.
5249
5250
Pending merges need to be committed or reverted before using switch.
5251
5252
The path to the branch to switch to can be specified relative to the parent
5253
directory of the current branch. For example, if you are currently in a
5254
checkout of /path/to/branch, specifying 'newbranch' will find a branch at
5255
/path/to/newbranch.
5256
5257
Bound branches use the nickname of its master branch unless it is set
5258
locally, in which case switching will update the the local nickname to be
5259
that of the master.
5260
"""
5261
5262
takes_args = ['to_location']
5263
takes_options = [Option('force',
5264
help='Switch even if local commits will be lost.')
5265
]
5266
5267
def run(self, to_location, force=False):
5268
from bzrlib import switch
5269
tree_location = '.'
5270
control_dir = bzrdir.BzrDir.open_containing(tree_location)[0]
5271
branch = control_dir.open_branch()
5272
try:
5273
to_branch = Branch.open(to_location)
5274
except errors.NotBranchError:
5275
this_branch = control_dir.open_branch()
5276
# This may be a heavy checkout, where we want the master branch
5277
this_url = this_branch.get_bound_location()
5278
# If not, use a local sibling
5279
if this_url is None:
5280
this_url = this_branch.base
5281
to_branch = Branch.open(
5282
urlutils.join(this_url, '..', to_location))
5283
switch.switch(control_dir, to_branch, force)
5284
if branch.get_config().has_explicit_nickname():
5285
branch = control_dir.open_branch() #get the new branch!
5286
branch.nick = to_branch.nick
5287
note('Switched to branch: %s',
5288
urlutils.unescape_for_display(to_branch.base, 'utf-8'))
5289
5290
5291
class cmd_view(Command):
5292
"""Manage filtered views.
5293
5294
Views provide a mask over the tree so that users can focus on
5295
a subset of a tree when doing their work. After creating a view,
5296
commands that support a list of files - status, diff, commit, etc -
5297
effectively have that list of files implicitly given each time.
5298
An explicit list of files can still be given but those files
5299
must be within the current view.
5300
5301
In most cases, a view has a short life-span: it is created to make
5302
a selected change and is deleted once that change is committed.
5303
At other times, you may wish to create one or more named views
5304
and switch between them.
5305
5306
To disable the current view without deleting it, you can switch to
5307
the pseudo view called ``off``. This can be useful when you need
5308
to see the whole tree for an operation or two (e.g. merge) but
5309
want to switch back to your view after that.
5310
5311
:Examples:
5312
To define the current view::
5313
5314
bzr view file1 dir1 ...
5315
5316
To list the current view::
5317
5318
bzr view
5319
5320
To delete the current view::
5321
5322
bzr view --delete
5323
5324
To disable the current view without deleting it::
5325
5326
bzr view --switch off
5327
5328
To define a named view and switch to it::
5329
5330
bzr view --name view-name file1 dir1 ...
5331
5332
To list a named view::
5333
5334
bzr view --name view-name
5335
5336
To delete a named view::
5337
5338
bzr view --name view-name --delete
5339
5340
To switch to a named view::
5341
5342
bzr view --switch view-name
5343
5344
To list all views defined::
5345
5346
bzr view --all
5347
5348
To delete all views::
5349
5350
bzr view --delete --all
5351
"""
5352
5353
_see_also = []
5354
takes_args = ['file*']
5355
takes_options = [
5356
Option('all',
5357
help='Apply list or delete action to all views.',
5358
),
5359
Option('delete',
5360
help='Delete the view.',
5361
),
5362
Option('name',
5363
help='Name of the view to define, list or delete.',
5364
type=unicode,
5365
),
5366
Option('switch',
5367
help='Name of the view to switch to.',
5368
type=unicode,
5369
),
5370
]
5371
5372
def run(self, file_list,
5373
all=False,
5374
delete=False,
5375
name=None,
5376
switch=None,
5377
):
5378
tree, file_list = tree_files(file_list, apply_view=False)
5379
current_view, view_dict = tree.views.get_view_info()
5380
if name is None:
5381
name = current_view
5382
if delete:
5383
if file_list:
5384
raise errors.BzrCommandError(
5385
"Both --delete and a file list specified")
5386
elif switch:
5387
raise errors.BzrCommandError(
5388
"Both --delete and --switch specified")
5389
elif all:
5390
tree.views.set_view_info(None, {})
5391
self.outf.write("Deleted all views.\n")
5392
elif name is None:
5393
raise errors.BzrCommandError("No current view to delete")
5394
else:
5395
tree.views.delete_view(name)
5396
self.outf.write("Deleted '%s' view.\n" % name)
5397
elif switch:
5398
if file_list:
5399
raise errors.BzrCommandError(
5400
"Both --switch and a file list specified")
5401
elif all:
5402
raise errors.BzrCommandError(
5403
"Both --switch and --all specified")
5404
elif switch == 'off':
5405
if current_view is None:
5406
raise errors.BzrCommandError("No current view to disable")
5407
tree.views.set_view_info(None, view_dict)
5408
self.outf.write("Disabled '%s' view.\n" % (current_view))
5409
else:
5410
tree.views.set_view_info(switch, view_dict)
5411
view_str = views.view_display_str(tree.views.lookup_view())
5412
self.outf.write("Using '%s' view: %s\n" % (switch, view_str))
5413
elif all:
5414
if view_dict:
5415
self.outf.write('Views defined:\n')
5416
for view in sorted(view_dict):
5417
if view == current_view:
5418
active = "=>"
5419
else:
5420
active = " "
5421
view_str = views.view_display_str(view_dict[view])
5422
self.outf.write('%s %-20s %s\n' % (active, view, view_str))
5423
else:
5424
self.outf.write('No views defined.\n')
5425
elif file_list:
5426
if name is None:
5427
# No name given and no current view set
5428
name = 'my'
5429
elif name == 'off':
5430
raise errors.BzrCommandError(
5431
"Cannot change the 'off' pseudo view")
5432
tree.views.set_view(name, sorted(file_list))
5433
view_str = views.view_display_str(tree.views.lookup_view())
5434
self.outf.write("Using '%s' view: %s\n" % (name, view_str))
5435
else:
5436
# list the files
5437
if name is None:
5438
# No name given and no current view set
5439
self.outf.write('No current view.\n')
5440
else:
5441
view_str = views.view_display_str(tree.views.lookup_view(name))
5442
self.outf.write("'%s' view is: %s\n" % (name, view_str))
5443
5444
5445
class cmd_hooks(Command):
5446
"""Show hooks."""
5447
5448
hidden = True
5449
5450
def run(self):
5451
for hook_key in sorted(hooks.known_hooks.keys()):
5452
some_hooks = hooks.known_hooks_key_to_object(hook_key)
5453
self.outf.write("%s:\n" % type(some_hooks).__name__)
5454
for hook_name, hook_point in sorted(some_hooks.items()):
5455
self.outf.write(" %s:\n" % (hook_name,))
5456
found_hooks = list(hook_point)
5457
if found_hooks:
5458
for hook in found_hooks:
5459
self.outf.write(" %s\n" %
5460
(some_hooks.get_hook_name(hook),))
5461
else:
5462
self.outf.write(" <no hooks installed>\n")
5463
5464
5465
class cmd_shelve(Command):
5466
"""Temporarily set aside some changes from the current tree.
5467
5468
Shelve allows you to temporarily put changes you've made "on the shelf",
5469
ie. out of the way, until a later time when you can bring them back from
5470
the shelf with the 'unshelve' command. The changes are stored alongside
5471
your working tree, and so they aren't propagated along with your branch nor
5472
will they survive its deletion.
5473
5474
If shelve --list is specified, previously-shelved changes are listed.
5475
5476
Shelve is intended to help separate several sets of changes that have
5477
been inappropriately mingled. If you just want to get rid of all changes
5478
and you don't need to restore them later, use revert. If you want to
5479
shelve all text changes at once, use shelve --all.
5480
5481
If filenames are specified, only the changes to those files will be
5482
shelved. Other files will be left untouched.
5483
5484
If a revision is specified, changes since that revision will be shelved.
5485
5486
You can put multiple items on the shelf, and by default, 'unshelve' will
5487
restore the most recently shelved changes.
5488
"""
5489
5490
takes_args = ['file*']
5491
5492
takes_options = [
5493
'revision',
5494
Option('all', help='Shelve all changes.'),
5495
'message',
5496
RegistryOption('writer', 'Method to use for writing diffs.',
5497
bzrlib.option.diff_writer_registry,
5498
value_switches=True, enum_switch=False),
5499
5500
Option('list', help='List shelved changes.'),
5501
Option('destroy',
5502
help='Destroy removed changes instead of shelving them.'),
5503
]
5504
_see_also = ['unshelve']
5505
5506
def run(self, revision=None, all=False, file_list=None, message=None,
5507
writer=None, list=False, destroy=False):
5508
if list:
5509
return self.run_for_list()
5510
from bzrlib.shelf_ui import Shelver
5511
if writer is None:
5512
writer = bzrlib.option.diff_writer_registry.get()
5513
try:
5514
Shelver.from_args(writer(sys.stdout), revision, all, file_list,
5515
message, destroy=destroy).run()
5516
except errors.UserAbort:
5517
return 0
5518
5519
def run_for_list(self):
5520
tree = WorkingTree.open_containing('.')[0]
5521
tree.lock_read()
5522
try:
5523
manager = tree.get_shelf_manager()
5524
shelves = manager.active_shelves()
5525
if len(shelves) == 0:
5526
note('No shelved changes.')
5527
return 0
5528
for shelf_id in reversed(shelves):
5529
message = manager.get_metadata(shelf_id).get('message')
5530
if message is None:
5531
message = '<no message>'
5532
self.outf.write('%3d: %s\n' % (shelf_id, message))
5533
return 1
5534
finally:
5535
tree.unlock()
5536
5537
5538
class cmd_unshelve(Command):
5539
"""Restore shelved changes.
5540
5541
By default, the most recently shelved changes are restored. However if you
5542
specify a shelf by id those changes will be restored instead. This works
5543
best when the changes don't depend on each other.
5544
"""
5545
5546
takes_args = ['shelf_id?']
5547
takes_options = [
5548
RegistryOption.from_kwargs(
5549
'action', help="The action to perform.",
5550
enum_switch=False, value_switches=True,
5551
apply="Apply changes and remove from the shelf.",
5552
dry_run="Show changes, but do not apply or remove them.",
5553
delete_only="Delete changes without applying them."
5554
)
5555
]
5556
_see_also = ['shelve']
5557
5558
def run(self, shelf_id=None, action='apply'):
5559
from bzrlib.shelf_ui import Unshelver
5560
Unshelver.from_args(shelf_id, action).run()
5561
5562
5563
class cmd_clean_tree(Command):
5564
"""Remove unwanted files from working tree.
5565
5566
By default, only unknown files, not ignored files, are deleted. Versioned
5567
files are never deleted.
5568
5569
Another class is 'detritus', which includes files emitted by bzr during
5570
normal operations and selftests. (The value of these files decreases with
5571
time.)
5572
5573
If no options are specified, unknown files are deleted. Otherwise, option
5574
flags are respected, and may be combined.
5575
5576
To check what clean-tree will do, use --dry-run.
5577
"""
5578
takes_options = [Option('ignored', help='Delete all ignored files.'),
5579
Option('detritus', help='Delete conflict files, merge'
5580
' backups, and failed selftest dirs.'),
5581
Option('unknown',
5582
help='Delete files unknown to bzr (default).'),
5583
Option('dry-run', help='Show files to delete instead of'
5584
' deleting them.'),
5585
Option('force', help='Do not prompt before deleting.')]
5586
def run(self, unknown=False, ignored=False, detritus=False, dry_run=False,
5587
force=False):
5588
from bzrlib.clean_tree import clean_tree
5589
if not (unknown or ignored or detritus):
5590
unknown = True
5591
if dry_run:
5592
force = True
5593
clean_tree('.', unknown=unknown, ignored=ignored, detritus=detritus,
5594
dry_run=dry_run, no_prompt=force)
5595
5596
5597
def _create_prefix(cur_transport):
5598
needed = [cur_transport]
5599
# Recurse upwards until we can create a directory successfully
5600
while True:
5601
new_transport = cur_transport.clone('..')
5602
if new_transport.base == cur_transport.base:
5603
raise errors.BzrCommandError(
5604
"Failed to create path prefix for %s."
5605
% cur_transport.base)
5606
try:
5607
new_transport.mkdir('.')
5608
except errors.NoSuchFile:
5609
needed.append(new_transport)
5610
cur_transport = new_transport
5611
else:
5612
break
5613
# Now we only need to create child directories
5614
while needed:
5615
cur_transport = needed.pop()
5616
cur_transport.ensure_base()
5617
5618
5619
# these get imported and then picked up by the scan for cmd_*
5620
# TODO: Some more consistent way to split command definitions across files;
5621
# we do need to load at least some information about them to know of
5622
# aliases. ideally we would avoid loading the implementation until the
5623
# details were needed.
5624
from bzrlib.cmd_version_info import cmd_version_info
5625
from bzrlib.conflicts import cmd_resolve, cmd_conflicts, restore
5626
from bzrlib.bundle.commands import (
5627
cmd_bundle_info,
5628
)
5629
from bzrlib.sign_my_commits import cmd_sign_my_commits
5630
from bzrlib.weave_commands import cmd_versionedfile_list, \
5631
cmd_weave_plan_merge, cmd_weave_merge_text
Loggerhead is a web-based interface for Breezy
Version: 2.0.1