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