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 3968.1.1
- compare with another revision
- download diff
- download tarball
- view history from revision 3968.1.1
- Committer: Colin D Bennett
- Date: 2009-01-30 08:24:38 UTC
- mto: (3996.1.1 ianc-integration)
- mto: This revision was merged to the branch mainline in revision 3997.
- Revision ID: colin@gibibit.com-20090130082438-hl7t8y6z6feejnnc
Show all pending merge revisions in the commit message template.
Instead of showing only the merge tip revisions, show all pending merge
revisions like 'status -v' does, since it will not cause important
information to scroll off the screen as might happen in the status command.
Instead of showing only the merge tip revisions, show all pending merge
revisions like 'status -v' does, since it will not cause important
information to scroll off the screen as might happen in the status command.
- 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, 2009 Canonical Ltd
2
#
3
# This program is free software; you can redistribute it and/or modify
4
# it under the terms of the GNU General Public License as published by
5
# the Free Software Foundation; either version 2 of the License, or
6
# (at your option) any later version.
7
#
8
# This program is distributed in the hope that it will be useful,
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11
# GNU General Public License for more details.
12
#
13
# You should have received a copy of the GNU General Public License
14
# along with this program; if not, write to the Free Software
15
# Foundation, Inc., 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
Option('show-diff',
1866
short_name='p',
1867
help='Show changes made in each revision as a patch.'),
1868
]
1869
encoding_type = 'replace'
1870
1871
@display_command
1872
def run(self, location=None, timezone='original',
1873
verbose=False,
1874
show_ids=False,
1875
forward=False,
1876
revision=None,
1877
change=None,
1878
log_format=None,
1879
message=None,
1880
limit=None,
1881
show_diff=False):
1882
from bzrlib.log import show_log
1883
direction = (forward and 'forward') or 'reverse'
1884
1885
if change is not None:
1886
if len(change) > 1:
1887
raise errors.RangeInChangeOption()
1888
if revision is not None:
1889
raise errors.BzrCommandError(
1890
'--revision and --change are mutually exclusive')
1891
else:
1892
revision = change
1893
1894
# log everything
1895
file_id = None
1896
if location:
1897
# find the file id to log:
1898
1899
tree, b, fp = bzrdir.BzrDir.open_containing_tree_or_branch(
1900
location)
1901
if fp != '':
1902
if tree is None:
1903
tree = b.basis_tree()
1904
file_id = tree.path2id(fp)
1905
if file_id is None:
1906
raise errors.BzrCommandError(
1907
"Path does not have any revision history: %s" %
1908
location)
1909
else:
1910
# local dir only
1911
# FIXME ? log the current subdir only RBC 20060203
1912
if revision is not None \
1913
and len(revision) > 0 and revision[0].get_branch():
1914
location = revision[0].get_branch()
1915
else:
1916
location = '.'
1917
dir, relpath = bzrdir.BzrDir.open_containing(location)
1918
b = dir.open_branch()
1919
1920
b.lock_read()
1921
try:
1922
rev1, rev2 = _get_revision_range(revision, b, self.name())
1923
if log_format is None:
1924
log_format = log.log_formatter_registry.get_default(b)
1925
1926
lf = log_format(show_ids=show_ids, to_file=self.outf,
1927
show_timezone=timezone,
1928
delta_format=get_verbosity_level())
1929
1930
show_log(b,
1931
lf,
1932
file_id,
1933
verbose=verbose,
1934
direction=direction,
1935
start_revision=rev1,
1936
end_revision=rev2,
1937
search=message,
1938
limit=limit,
1939
show_diff=show_diff)
1940
finally:
1941
b.unlock()
1942
1943
def _get_revision_range(revisionspec_list, branch, command_name):
1944
"""Take the input of a revision option and turn it into a revision range.
1945
1946
It returns RevisionInfo objects which can be used to obtain the rev_id's
1947
of the desired revisons. It does some user input validations.
1948
"""
1949
if revisionspec_list is None:
1950
rev1 = None
1951
rev2 = None
1952
elif len(revisionspec_list) == 1:
1953
rev1 = rev2 = revisionspec_list[0].in_history(branch)
1954
elif len(revisionspec_list) == 2:
1955
if revisionspec_list[1].get_branch() != revisionspec_list[0
1956
].get_branch():
1957
# b is taken from revision[0].get_branch(), and
1958
# show_log will use its revision_history. Having
1959
# different branches will lead to weird behaviors.
1960
raise errors.BzrCommandError(
1961
"bzr %s doesn't accept two revisions in different"
1962
" branches." % command_name)
1963
rev1 = revisionspec_list[0].in_history(branch)
1964
rev2 = revisionspec_list[1].in_history(branch)
1965
else:
1966
raise errors.BzrCommandError(
1967
'bzr %s --revision takes one or two values.' % command_name)
1968
return rev1, rev2
1969
1970
def get_log_format(long=False, short=False, line=False, default='long'):
1971
log_format = default
1972
if long:
1973
log_format = 'long'
1974
if short:
1975
log_format = 'short'
1976
if line:
1977
log_format = 'line'
1978
return log_format
1979
1980
1981
class cmd_touching_revisions(Command):
1982
"""Return revision-ids which affected a particular file.
1983
1984
A more user-friendly interface is "bzr log FILE".
1985
"""
1986
1987
hidden = True
1988
takes_args = ["filename"]
1989
1990
@display_command
1991
def run(self, filename):
1992
tree, relpath = WorkingTree.open_containing(filename)
1993
b = tree.branch
1994
file_id = tree.path2id(relpath)
1995
for revno, revision_id, what in log.find_touching_revisions(b, file_id):
1996
self.outf.write("%6d %s\n" % (revno, what))
1997
1998
1999
class cmd_ls(Command):
2000
"""List files in a tree.
2001
"""
2002
2003
_see_also = ['status', 'cat']
2004
takes_args = ['path?']
2005
# TODO: Take a revision or remote path and list that tree instead.
2006
takes_options = [
2007
'verbose',
2008
'revision',
2009
Option('non-recursive',
2010
help='Don\'t recurse into subdirectories.'),
2011
Option('from-root',
2012
help='Print paths relative to the root of the branch.'),
2013
Option('unknown', help='Print unknown files.'),
2014
Option('versioned', help='Print versioned files.',
2015
short_name='V'),
2016
Option('ignored', help='Print ignored files.'),
2017
Option('null',
2018
help='Write an ascii NUL (\\0) separator '
2019
'between files rather than a newline.'),
2020
Option('kind',
2021
help='List entries of a particular kind: file, directory, symlink.',
2022
type=unicode),
2023
'show-ids',
2024
]
2025
@display_command
2026
def run(self, revision=None, verbose=False,
2027
non_recursive=False, from_root=False,
2028
unknown=False, versioned=False, ignored=False,
2029
null=False, kind=None, show_ids=False, path=None):
2030
2031
if kind and kind not in ('file', 'directory', 'symlink'):
2032
raise errors.BzrCommandError('invalid kind specified')
2033
2034
if verbose and null:
2035
raise errors.BzrCommandError('Cannot set both --verbose and --null')
2036
all = not (unknown or versioned or ignored)
2037
2038
selection = {'I':ignored, '?':unknown, 'V':versioned}
2039
2040
if path is None:
2041
fs_path = '.'
2042
prefix = ''
2043
else:
2044
if from_root:
2045
raise errors.BzrCommandError('cannot specify both --from-root'
2046
' and PATH')
2047
fs_path = path
2048
prefix = path
2049
tree, branch, relpath = bzrdir.BzrDir.open_containing_tree_or_branch(
2050
fs_path)
2051
if from_root:
2052
relpath = u''
2053
elif relpath:
2054
relpath += '/'
2055
if revision is not None or tree is None:
2056
tree = _get_one_revision_tree('ls', revision, branch=branch)
2057
2058
tree.lock_read()
2059
try:
2060
for fp, fc, fkind, fid, entry in tree.list_files(include_root=False):
2061
if fp.startswith(relpath):
2062
fp = osutils.pathjoin(prefix, fp[len(relpath):])
2063
if non_recursive and '/' in fp:
2064
continue
2065
if not all and not selection[fc]:
2066
continue
2067
if kind is not None and fkind != kind:
2068
continue
2069
kindch = entry.kind_character()
2070
outstring = fp + kindch
2071
if verbose:
2072
outstring = '%-8s %s' % (fc, outstring)
2073
if show_ids and fid is not None:
2074
outstring = "%-50s %s" % (outstring, fid)
2075
self.outf.write(outstring + '\n')
2076
elif null:
2077
self.outf.write(fp + '\0')
2078
if show_ids:
2079
if fid is not None:
2080
self.outf.write(fid)
2081
self.outf.write('\0')
2082
self.outf.flush()
2083
else:
2084
if fid is not None:
2085
my_id = fid
2086
else:
2087
my_id = ''
2088
if show_ids:
2089
self.outf.write('%-50s %s\n' % (outstring, my_id))
2090
else:
2091
self.outf.write(outstring + '\n')
2092
finally:
2093
tree.unlock()
2094
2095
2096
class cmd_unknowns(Command):
2097
"""List unknown files.
2098
"""
2099
2100
hidden = True
2101
_see_also = ['ls']
2102
2103
@display_command
2104
def run(self):
2105
for f in WorkingTree.open_containing(u'.')[0].unknowns():
2106
self.outf.write(osutils.quotefn(f) + '\n')
2107
2108
2109
class cmd_ignore(Command):
2110
"""Ignore specified files or patterns.
2111
2112
See ``bzr help patterns`` for details on the syntax of patterns.
2113
2114
To remove patterns from the ignore list, edit the .bzrignore file.
2115
After adding, editing or deleting that file either indirectly by
2116
using this command or directly by using an editor, be sure to commit
2117
it.
2118
2119
Note: ignore patterns containing shell wildcards must be quoted from
2120
the shell on Unix.
2121
2122
:Examples:
2123
Ignore the top level Makefile::
2124
2125
bzr ignore ./Makefile
2126
2127
Ignore class files in all directories::
2128
2129
bzr ignore "*.class"
2130
2131
Ignore .o files under the lib directory::
2132
2133
bzr ignore "lib/**/*.o"
2134
2135
Ignore .o files under the lib directory::
2136
2137
bzr ignore "RE:lib/.*\.o"
2138
2139
Ignore everything but the "debian" toplevel directory::
2140
2141
bzr ignore "RE:(?!debian/).*"
2142
"""
2143
2144
_see_also = ['status', 'ignored', 'patterns']
2145
takes_args = ['name_pattern*']
2146
takes_options = [
2147
Option('old-default-rules',
2148
help='Write out the ignore rules bzr < 0.9 always used.')
2149
]
2150
2151
def run(self, name_pattern_list=None, old_default_rules=None):
2152
from bzrlib import ignores
2153
if old_default_rules is not None:
2154
# dump the rules and exit
2155
for pattern in ignores.OLD_DEFAULTS:
2156
print pattern
2157
return
2158
if not name_pattern_list:
2159
raise errors.BzrCommandError("ignore requires at least one "
2160
"NAME_PATTERN or --old-default-rules")
2161
name_pattern_list = [globbing.normalize_pattern(p)
2162
for p in name_pattern_list]
2163
for name_pattern in name_pattern_list:
2164
if (name_pattern[0] == '/' or
2165
(len(name_pattern) > 1 and name_pattern[1] == ':')):
2166
raise errors.BzrCommandError(
2167
"NAME_PATTERN should not be an absolute path")
2168
tree, relpath = WorkingTree.open_containing(u'.')
2169
ignores.tree_ignores_add_patterns(tree, name_pattern_list)
2170
ignored = globbing.Globster(name_pattern_list)
2171
matches = []
2172
tree.lock_read()
2173
for entry in tree.list_files():
2174
id = entry[3]
2175
if id is not None:
2176
filename = entry[0]
2177
if ignored.match(filename):
2178
matches.append(filename.encode('utf-8'))
2179
tree.unlock()
2180
if len(matches) > 0:
2181
print "Warning: the following files are version controlled and" \
2182
" match your ignore pattern:\n%s" % ("\n".join(matches),)
2183
2184
2185
class cmd_ignored(Command):
2186
"""List ignored files and the patterns that matched them.
2187
2188
List all the ignored files and the ignore pattern that caused the file to
2189
be ignored.
2190
2191
Alternatively, to list just the files::
2192
2193
bzr ls --ignored
2194
"""
2195
2196
encoding_type = 'replace'
2197
_see_also = ['ignore', 'ls']
2198
2199
@display_command
2200
def run(self):
2201
tree = WorkingTree.open_containing(u'.')[0]
2202
tree.lock_read()
2203
try:
2204
for path, file_class, kind, file_id, entry in tree.list_files():
2205
if file_class != 'I':
2206
continue
2207
## XXX: Slightly inefficient since this was already calculated
2208
pat = tree.is_ignored(path)
2209
self.outf.write('%-50s %s\n' % (path, pat))
2210
finally:
2211
tree.unlock()
2212
2213
2214
class cmd_lookup_revision(Command):
2215
"""Lookup the revision-id from a revision-number
2216
2217
:Examples:
2218
bzr lookup-revision 33
2219
"""
2220
hidden = True
2221
takes_args = ['revno']
2222
2223
@display_command
2224
def run(self, revno):
2225
try:
2226
revno = int(revno)
2227
except ValueError:
2228
raise errors.BzrCommandError("not a valid revision-number: %r" % revno)
2229
2230
print WorkingTree.open_containing(u'.')[0].branch.get_rev_id(revno)
2231
2232
2233
class cmd_export(Command):
2234
"""Export current or past revision to a destination directory or archive.
2235
2236
If no revision is specified this exports the last committed revision.
2237
2238
Format may be an "exporter" name, such as tar, tgz, tbz2. If none is
2239
given, try to find the format with the extension. If no extension
2240
is found exports to a directory (equivalent to --format=dir).
2241
2242
If root is supplied, it will be used as the root directory inside
2243
container formats (tar, zip, etc). If it is not supplied it will default
2244
to the exported filename. The root option has no effect for 'dir' format.
2245
2246
If branch is omitted then the branch containing the current working
2247
directory will be used.
2248
2249
Note: Export of tree with non-ASCII filenames to zip is not supported.
2250
2251
================= =========================
2252
Supported formats Autodetected by extension
2253
================= =========================
2254
dir (none)
2255
tar .tar
2256
tbz2 .tar.bz2, .tbz2
2257
tgz .tar.gz, .tgz
2258
zip .zip
2259
================= =========================
2260
"""
2261
takes_args = ['dest', 'branch_or_subdir?']
2262
takes_options = [
2263
Option('format',
2264
help="Type of file to export to.",
2265
type=unicode),
2266
'revision',
2267
Option('root',
2268
type=str,
2269
help="Name of the root directory inside the exported file."),
2270
]
2271
def run(self, dest, branch_or_subdir=None, revision=None, format=None,
2272
root=None):
2273
from bzrlib.export import export
2274
2275
if branch_or_subdir is None:
2276
tree = WorkingTree.open_containing(u'.')[0]
2277
b = tree.branch
2278
subdir = None
2279
else:
2280
b, subdir = Branch.open_containing(branch_or_subdir)
2281
tree = None
2282
2283
rev_tree = _get_one_revision_tree('export', revision, branch=b, tree=tree)
2284
try:
2285
export(rev_tree, dest, format, root, subdir)
2286
except errors.NoSuchExportFormat, e:
2287
raise errors.BzrCommandError('Unsupported export format: %s' % e.format)
2288
2289
2290
class cmd_cat(Command):
2291
"""Write the contents of a file as of a given revision to standard output.
2292
2293
If no revision is nominated, the last revision is used.
2294
2295
Note: Take care to redirect standard output when using this command on a
2296
binary file.
2297
"""
2298
2299
_see_also = ['ls']
2300
takes_options = [
2301
Option('name-from-revision', help='The path name in the old tree.'),
2302
'revision',
2303
]
2304
takes_args = ['filename']
2305
encoding_type = 'exact'
2306
2307
@display_command
2308
def run(self, filename, revision=None, name_from_revision=False):
2309
if revision is not None and len(revision) != 1:
2310
raise errors.BzrCommandError("bzr cat --revision takes exactly"
2311
" one revision specifier")
2312
tree, branch, relpath = \
2313
bzrdir.BzrDir.open_containing_tree_or_branch(filename)
2314
branch.lock_read()
2315
try:
2316
return self._run(tree, branch, relpath, filename, revision,
2317
name_from_revision)
2318
finally:
2319
branch.unlock()
2320
2321
def _run(self, tree, b, relpath, filename, revision, name_from_revision):
2322
if tree is None:
2323
tree = b.basis_tree()
2324
rev_tree = _get_one_revision_tree('cat', revision, branch=b)
2325
2326
cur_file_id = tree.path2id(relpath)
2327
old_file_id = rev_tree.path2id(relpath)
2328
2329
if name_from_revision:
2330
if old_file_id is None:
2331
raise errors.BzrCommandError(
2332
"%r is not present in revision %s" % (
2333
filename, rev_tree.get_revision_id()))
2334
else:
2335
content = rev_tree.get_file_text(old_file_id)
2336
elif cur_file_id is not None:
2337
content = rev_tree.get_file_text(cur_file_id)
2338
elif old_file_id is not None:
2339
content = rev_tree.get_file_text(old_file_id)
2340
else:
2341
raise errors.BzrCommandError(
2342
"%r is not present in revision %s" % (
2343
filename, rev_tree.get_revision_id()))
2344
self.outf.write(content)
2345
2346
2347
class cmd_local_time_offset(Command):
2348
"""Show the offset in seconds from GMT to local time."""
2349
hidden = True
2350
@display_command
2351
def run(self):
2352
print osutils.local_time_offset()
2353
2354
2355
2356
class cmd_commit(Command):
2357
"""Commit changes into a new revision.
2358
2359
If no arguments are given, the entire tree is committed.
2360
2361
If selected files are specified, only changes to those files are
2362
committed. If a directory is specified then the directory and everything
2363
within it is committed.
2364
2365
When excludes are given, they take precedence over selected files.
2366
For example, too commit only changes within foo, but not changes within
2367
foo/bar::
2368
2369
bzr commit foo -x foo/bar
2370
2371
If author of the change is not the same person as the committer, you can
2372
specify the author's name using the --author option. The name should be
2373
in the same format as a committer-id, e.g. "John Doe <jdoe@example.com>".
2374
2375
A selected-file commit may fail in some cases where the committed
2376
tree would be invalid. Consider::
2377
2378
bzr init foo
2379
mkdir foo/bar
2380
bzr add foo/bar
2381
bzr commit foo -m "committing foo"
2382
bzr mv foo/bar foo/baz
2383
mkdir foo/bar
2384
bzr add foo/bar
2385
bzr commit foo/bar -m "committing bar but not baz"
2386
2387
In the example above, the last commit will fail by design. This gives
2388
the user the opportunity to decide whether they want to commit the
2389
rename at the same time, separately first, or not at all. (As a general
2390
rule, when in doubt, Bazaar has a policy of Doing the Safe Thing.)
2391
2392
Note: A selected-file commit after a merge is not yet supported.
2393
"""
2394
# TODO: Run hooks on tree to-be-committed, and after commit.
2395
2396
# TODO: Strict commit that fails if there are deleted files.
2397
# (what does "deleted files" mean ??)
2398
2399
# TODO: Give better message for -s, --summary, used by tla people
2400
2401
# XXX: verbose currently does nothing
2402
2403
_see_also = ['bugs', 'uncommit']
2404
takes_args = ['selected*']
2405
takes_options = [
2406
ListOption('exclude', type=str, short_name='x',
2407
help="Do not consider changes made to a given path."),
2408
Option('message', type=unicode,
2409
short_name='m',
2410
help="Description of the new revision."),
2411
'verbose',
2412
Option('unchanged',
2413
help='Commit even if nothing has changed.'),
2414
Option('file', type=str,
2415
short_name='F',
2416
argname='msgfile',
2417
help='Take commit message from this file.'),
2418
Option('strict',
2419
help="Refuse to commit if there are unknown "
2420
"files in the working tree."),
2421
ListOption('fixes', type=str,
2422
help="Mark a bug as being fixed by this revision."),
2423
Option('author', type=unicode,
2424
help="Set the author's name, if it's different "
2425
"from the committer."),
2426
Option('local',
2427
help="Perform a local commit in a bound "
2428
"branch. Local commits are not pushed to "
2429
"the master branch until a normal commit "
2430
"is performed."
2431
),
2432
Option('show-diff',
2433
help='When no message is supplied, show the diff along'
2434
' with the status summary in the message editor.'),
2435
]
2436
aliases = ['ci', 'checkin']
2437
2438
def _get_bug_fix_properties(self, fixes, branch):
2439
properties = []
2440
# Configure the properties for bug fixing attributes.
2441
for fixed_bug in fixes:
2442
tokens = fixed_bug.split(':')
2443
if len(tokens) != 2:
2444
raise errors.BzrCommandError(
2445
"Invalid bug %s. Must be in the form of 'tag:id'. "
2446
"Commit refused." % fixed_bug)
2447
tag, bug_id = tokens
2448
try:
2449
bug_url = bugtracker.get_bug_url(tag, branch, bug_id)
2450
except errors.UnknownBugTrackerAbbreviation:
2451
raise errors.BzrCommandError(
2452
'Unrecognized bug %s. Commit refused.' % fixed_bug)
2453
except errors.MalformedBugIdentifier:
2454
raise errors.BzrCommandError(
2455
"Invalid bug identifier for %s. Commit refused."
2456
% fixed_bug)
2457
properties.append('%s fixed' % bug_url)
2458
return '\n'.join(properties)
2459
2460
def run(self, message=None, file=None, verbose=False, selected_list=None,
2461
unchanged=False, strict=False, local=False, fixes=None,
2462
author=None, show_diff=False, exclude=None):
2463
from bzrlib.errors import (
2464
PointlessCommit,
2465
ConflictsInTree,
2466
StrictCommitFailed
2467
)
2468
from bzrlib.msgeditor import (
2469
edit_commit_message_encoded,
2470
generate_commit_message_template,
2471
make_commit_message_template_encoded
2472
)
2473
2474
# TODO: Need a blackbox test for invoking the external editor; may be
2475
# slightly problematic to run this cross-platform.
2476
2477
# TODO: do more checks that the commit will succeed before
2478
# spending the user's valuable time typing a commit message.
2479
2480
properties = {}
2481
2482
tree, selected_list = tree_files(selected_list)
2483
if selected_list == ['']:
2484
# workaround - commit of root of tree should be exactly the same
2485
# as just default commit in that tree, and succeed even though
2486
# selected-file merge commit is not done yet
2487
selected_list = []
2488
2489
if fixes is None:
2490
fixes = []
2491
bug_property = self._get_bug_fix_properties(fixes, tree.branch)
2492
if bug_property:
2493
properties['bugs'] = bug_property
2494
2495
if local and not tree.branch.get_bound_location():
2496
raise errors.LocalRequiresBoundBranch()
2497
2498
def get_message(commit_obj):
2499
"""Callback to get commit message"""
2500
my_message = message
2501
if my_message is None and not file:
2502
t = make_commit_message_template_encoded(tree,
2503
selected_list, diff=show_diff,
2504
output_encoding=osutils.get_user_encoding())
2505
start_message = generate_commit_message_template(commit_obj)
2506
my_message = edit_commit_message_encoded(t,
2507
start_message=start_message)
2508
if my_message is None:
2509
raise errors.BzrCommandError("please specify a commit"
2510
" message with either --message or --file")
2511
elif my_message and file:
2512
raise errors.BzrCommandError(
2513
"please specify either --message or --file")
2514
if file:
2515
my_message = codecs.open(file, 'rt',
2516
osutils.get_user_encoding()).read()
2517
if my_message == "":
2518
raise errors.BzrCommandError("empty commit message specified")
2519
return my_message
2520
2521
try:
2522
tree.commit(message_callback=get_message,
2523
specific_files=selected_list,
2524
allow_pointless=unchanged, strict=strict, local=local,
2525
reporter=None, verbose=verbose, revprops=properties,
2526
author=author,
2527
exclude=safe_relpath_files(tree, exclude))
2528
except PointlessCommit:
2529
# FIXME: This should really happen before the file is read in;
2530
# perhaps prepare the commit; get the message; then actually commit
2531
raise errors.BzrCommandError("no changes to commit."
2532
" use --unchanged to commit anyhow")
2533
except ConflictsInTree:
2534
raise errors.BzrCommandError('Conflicts detected in working '
2535
'tree. Use "bzr conflicts" to list, "bzr resolve FILE" to'
2536
' resolve.')
2537
except StrictCommitFailed:
2538
raise errors.BzrCommandError("Commit refused because there are"
2539
" unknown files in the working tree.")
2540
except errors.BoundBranchOutOfDate, e:
2541
raise errors.BzrCommandError(str(e) + "\n"
2542
'To commit to master branch, run update and then commit.\n'
2543
'You can also pass --local to commit to continue working '
2544
'disconnected.')
2545
2546
2547
class cmd_check(Command):
2548
"""Validate working tree structure, branch consistency and repository history.
2549
2550
This command checks various invariants about branch and repository storage
2551
to detect data corruption or bzr bugs.
2552
2553
The working tree and branch checks will only give output if a problem is
2554
detected. The output fields of the repository check are:
2555
2556
revisions: This is just the number of revisions checked. It doesn't
2557
indicate a problem.
2558
versionedfiles: This is just the number of versionedfiles checked. It
2559
doesn't indicate a problem.
2560
unreferenced ancestors: Texts that are ancestors of other texts, but
2561
are not properly referenced by the revision ancestry. This is a
2562
subtle problem that Bazaar can work around.
2563
unique file texts: This is the total number of unique file contents
2564
seen in the checked revisions. It does not indicate a problem.
2565
repeated file texts: This is the total number of repeated texts seen
2566
in the checked revisions. Texts can be repeated when their file
2567
entries are modified, but the file contents are not. It does not
2568
indicate a problem.
2569
2570
If no restrictions are specified, all Bazaar data that is found at the given
2571
location will be checked.
2572
2573
:Examples:
2574
2575
Check the tree and branch at 'foo'::
2576
2577
bzr check --tree --branch foo
2578
2579
Check only the repository at 'bar'::
2580
2581
bzr check --repo bar
2582
2583
Check everything at 'baz'::
2584
2585
bzr check baz
2586
"""
2587
2588
_see_also = ['reconcile']
2589
takes_args = ['path?']
2590
takes_options = ['verbose',
2591
Option('branch', help="Check the branch related to the"
2592
" current directory."),
2593
Option('repo', help="Check the repository related to the"
2594
" current directory."),
2595
Option('tree', help="Check the working tree related to"
2596
" the current directory.")]
2597
2598
def run(self, path=None, verbose=False, branch=False, repo=False,
2599
tree=False):
2600
from bzrlib.check import check_dwim
2601
if path is None:
2602
path = '.'
2603
if not branch and not repo and not tree:
2604
branch = repo = tree = True
2605
check_dwim(path, verbose, do_branch=branch, do_repo=repo, do_tree=tree)
2606
2607
2608
class cmd_upgrade(Command):
2609
"""Upgrade branch storage to current format.
2610
2611
The check command or bzr developers may sometimes advise you to run
2612
this command. When the default format has changed you may also be warned
2613
during other operations to upgrade.
2614
"""
2615
2616
_see_also = ['check']
2617
takes_args = ['url?']
2618
takes_options = [
2619
RegistryOption('format',
2620
help='Upgrade to a specific format. See "bzr help'
2621
' formats" for details.',
2622
lazy_registry=('bzrlib.bzrdir', 'format_registry'),
2623
converter=lambda name: bzrdir.format_registry.make_bzrdir(name),
2624
value_switches=True, title='Branch format'),
2625
]
2626
2627
def run(self, url='.', format=None):
2628
from bzrlib.upgrade import upgrade
2629
if format is None:
2630
format = bzrdir.format_registry.make_bzrdir('default')
2631
upgrade(url, format)
2632
2633
2634
class cmd_whoami(Command):
2635
"""Show or set bzr user id.
2636
2637
:Examples:
2638
Show the email of the current user::
2639
2640
bzr whoami --email
2641
2642
Set the current user::
2643
2644
bzr whoami "Frank Chu <fchu@example.com>"
2645
"""
2646
takes_options = [ Option('email',
2647
help='Display email address only.'),
2648
Option('branch',
2649
help='Set identity for the current branch instead of '
2650
'globally.'),
2651
]
2652
takes_args = ['name?']
2653
encoding_type = 'replace'
2654
2655
@display_command
2656
def run(self, email=False, branch=False, name=None):
2657
if name is None:
2658
# use branch if we're inside one; otherwise global config
2659
try:
2660
c = Branch.open_containing('.')[0].get_config()
2661
except errors.NotBranchError:
2662
c = config.GlobalConfig()
2663
if email:
2664
self.outf.write(c.user_email() + '\n')
2665
else:
2666
self.outf.write(c.username() + '\n')
2667
return
2668
2669
# display a warning if an email address isn't included in the given name.
2670
try:
2671
config.extract_email_address(name)
2672
except errors.NoEmailInUsername, e:
2673
warning('"%s" does not seem to contain an email address. '
2674
'This is allowed, but not recommended.', name)
2675
2676
# use global config unless --branch given
2677
if branch:
2678
c = Branch.open_containing('.')[0].get_config()
2679
else:
2680
c = config.GlobalConfig()
2681
c.set_user_option('email', name)
2682
2683
2684
class cmd_nick(Command):
2685
"""Print or set the branch nickname.
2686
2687
If unset, the tree root directory name is used as the nickname.
2688
To print the current nickname, execute with no argument.
2689
2690
Bound branches use the nickname of its master branch unless it is set
2691
locally.
2692
"""
2693
2694
_see_also = ['info']
2695
takes_args = ['nickname?']
2696
def run(self, nickname=None):
2697
branch = Branch.open_containing(u'.')[0]
2698
if nickname is None:
2699
self.printme(branch)
2700
else:
2701
branch.nick = nickname
2702
2703
@display_command
2704
def printme(self, branch):
2705
print branch.nick
2706
2707
2708
class cmd_alias(Command):
2709
"""Set/unset and display aliases.
2710
2711
:Examples:
2712
Show the current aliases::
2713
2714
bzr alias
2715
2716
Show the alias specified for 'll'::
2717
2718
bzr alias ll
2719
2720
Set an alias for 'll'::
2721
2722
bzr alias ll="log --line -r-10..-1"
2723
2724
To remove an alias for 'll'::
2725
2726
bzr alias --remove ll
2727
2728
"""
2729
takes_args = ['name?']
2730
takes_options = [
2731
Option('remove', help='Remove the alias.'),
2732
]
2733
2734
def run(self, name=None, remove=False):
2735
if remove:
2736
self.remove_alias(name)
2737
elif name is None:
2738
self.print_aliases()
2739
else:
2740
equal_pos = name.find('=')
2741
if equal_pos == -1:
2742
self.print_alias(name)
2743
else:
2744
self.set_alias(name[:equal_pos], name[equal_pos+1:])
2745
2746
def remove_alias(self, alias_name):
2747
if alias_name is None:
2748
raise errors.BzrCommandError(
2749
'bzr alias --remove expects an alias to remove.')
2750
# If alias is not found, print something like:
2751
# unalias: foo: not found
2752
c = config.GlobalConfig()
2753
c.unset_alias(alias_name)
2754
2755
@display_command
2756
def print_aliases(self):
2757
"""Print out the defined aliases in a similar format to bash."""
2758
aliases = config.GlobalConfig().get_aliases()
2759
for key, value in sorted(aliases.iteritems()):
2760
self.outf.write('bzr alias %s="%s"\n' % (key, value))
2761
2762
@display_command
2763
def print_alias(self, alias_name):
2764
from bzrlib.commands import get_alias
2765
alias = get_alias(alias_name)
2766
if alias is None:
2767
self.outf.write("bzr alias: %s: not found\n" % alias_name)
2768
else:
2769
self.outf.write(
2770
'bzr alias %s="%s"\n' % (alias_name, ' '.join(alias)))
2771
2772
def set_alias(self, alias_name, alias_command):
2773
"""Save the alias in the global config."""
2774
c = config.GlobalConfig()
2775
c.set_alias(alias_name, alias_command)
2776
2777
2778
class cmd_selftest(Command):
2779
"""Run internal test suite.
2780
2781
If arguments are given, they are regular expressions that say which tests
2782
should run. Tests matching any expression are run, and other tests are
2783
not run.
2784
2785
Alternatively if --first is given, matching tests are run first and then
2786
all other tests are run. This is useful if you have been working in a
2787
particular area, but want to make sure nothing else was broken.
2788
2789
If --exclude is given, tests that match that regular expression are
2790
excluded, regardless of whether they match --first or not.
2791
2792
To help catch accidential dependencies between tests, the --randomize
2793
option is useful. In most cases, the argument used is the word 'now'.
2794
Note that the seed used for the random number generator is displayed
2795
when this option is used. The seed can be explicitly passed as the
2796
argument to this option if required. This enables reproduction of the
2797
actual ordering used if and when an order sensitive problem is encountered.
2798
2799
If --list-only is given, the tests that would be run are listed. This is
2800
useful when combined with --first, --exclude and/or --randomize to
2801
understand their impact. The test harness reports "Listed nn tests in ..."
2802
instead of "Ran nn tests in ..." when list mode is enabled.
2803
2804
If the global option '--no-plugins' is given, plugins are not loaded
2805
before running the selftests. This has two effects: features provided or
2806
modified by plugins will not be tested, and tests provided by plugins will
2807
not be run.
2808
2809
Tests that need working space on disk use a common temporary directory,
2810
typically inside $TMPDIR or /tmp.
2811
2812
:Examples:
2813
Run only tests relating to 'ignore'::
2814
2815
bzr selftest ignore
2816
2817
Disable plugins and list tests as they're run::
2818
2819
bzr --no-plugins selftest -v
2820
"""
2821
# NB: this is used from the class without creating an instance, which is
2822
# why it does not have a self parameter.
2823
def get_transport_type(typestring):
2824
"""Parse and return a transport specifier."""
2825
if typestring == "sftp":
2826
from bzrlib.transport.sftp import SFTPAbsoluteServer
2827
return SFTPAbsoluteServer
2828
if typestring == "memory":
2829
from bzrlib.transport.memory import MemoryServer
2830
return MemoryServer
2831
if typestring == "fakenfs":
2832
from bzrlib.transport.fakenfs import FakeNFSServer
2833
return FakeNFSServer
2834
msg = "No known transport type %s. Supported types are: sftp\n" %\
2835
(typestring)
2836
raise errors.BzrCommandError(msg)
2837
2838
hidden = True
2839
takes_args = ['testspecs*']
2840
takes_options = ['verbose',
2841
Option('one',
2842
help='Stop when one test fails.',
2843
short_name='1',
2844
),
2845
Option('transport',
2846
help='Use a different transport by default '
2847
'throughout the test suite.',
2848
type=get_transport_type),
2849
Option('benchmark',
2850
help='Run the benchmarks rather than selftests.'),
2851
Option('lsprof-timed',
2852
help='Generate lsprof output for benchmarked'
2853
' sections of code.'),
2854
Option('cache-dir', type=str,
2855
help='Cache intermediate benchmark output in this '
2856
'directory.'),
2857
Option('first',
2858
help='Run all tests, but run specified tests first.',
2859
short_name='f',
2860
),
2861
Option('list-only',
2862
help='List the tests instead of running them.'),
2863
Option('randomize', type=str, argname="SEED",
2864
help='Randomize the order of tests using the given'
2865
' seed or "now" for the current time.'),
2866
Option('exclude', type=str, argname="PATTERN",
2867
short_name='x',
2868
help='Exclude tests that match this regular'
2869
' expression.'),
2870
Option('strict', help='Fail on missing dependencies or '
2871
'known failures.'),
2872
Option('load-list', type=str, argname='TESTLISTFILE',
2873
help='Load a test id list from a text file.'),
2874
ListOption('debugflag', type=str, short_name='E',
2875
help='Turn on a selftest debug flag.'),
2876
ListOption('starting-with', type=str, argname='TESTID',
2877
param_name='starting_with', short_name='s',
2878
help=
2879
'Load only the tests starting with TESTID.'),
2880
]
2881
encoding_type = 'replace'
2882
2883
def run(self, testspecs_list=None, verbose=False, one=False,
2884
transport=None, benchmark=None,
2885
lsprof_timed=None, cache_dir=None,
2886
first=False, list_only=False,
2887
randomize=None, exclude=None, strict=False,
2888
load_list=None, debugflag=None, starting_with=None):
2889
from bzrlib.tests import selftest
2890
import bzrlib.benchmarks as benchmarks
2891
from bzrlib.benchmarks import tree_creator
2892
2893
# Make deprecation warnings visible, unless -Werror is set
2894
symbol_versioning.activate_deprecation_warnings(override=False)
2895
2896
if cache_dir is not None:
2897
tree_creator.TreeCreator.CACHE_ROOT = osutils.abspath(cache_dir)
2898
if not list_only:
2899
print 'testing: %s' % (osutils.realpath(sys.argv[0]),)
2900
print ' %s (%s python%s)' % (
2901
bzrlib.__path__[0],
2902
bzrlib.version_string,
2903
bzrlib._format_version_tuple(sys.version_info),
2904
)
2905
print
2906
if testspecs_list is not None:
2907
pattern = '|'.join(testspecs_list)
2908
else:
2909
pattern = ".*"
2910
if benchmark:
2911
test_suite_factory = benchmarks.test_suite
2912
# Unless user explicitly asks for quiet, be verbose in benchmarks
2913
verbose = not is_quiet()
2914
# TODO: should possibly lock the history file...
2915
benchfile = open(".perf_history", "at", buffering=1)
2916
else:
2917
test_suite_factory = None
2918
benchfile = None
2919
try:
2920
result = selftest(verbose=verbose,
2921
pattern=pattern,
2922
stop_on_failure=one,
2923
transport=transport,
2924
test_suite_factory=test_suite_factory,
2925
lsprof_timed=lsprof_timed,
2926
bench_history=benchfile,
2927
matching_tests_first=first,
2928
list_only=list_only,
2929
random_seed=randomize,
2930
exclude_pattern=exclude,
2931
strict=strict,
2932
load_list=load_list,
2933
debug_flags=debugflag,
2934
starting_with=starting_with,
2935
)
2936
finally:
2937
if benchfile is not None:
2938
benchfile.close()
2939
if result:
2940
note('tests passed')
2941
else:
2942
note('tests failed')
2943
return int(not result)
2944
2945
2946
class cmd_version(Command):
2947
"""Show version of bzr."""
2948
2949
encoding_type = 'replace'
2950
takes_options = [
2951
Option("short", help="Print just the version number."),
2952
]
2953
2954
@display_command
2955
def run(self, short=False):
2956
from bzrlib.version import show_version
2957
if short:
2958
self.outf.write(bzrlib.version_string + '\n')
2959
else:
2960
show_version(to_file=self.outf)
2961
2962
2963
class cmd_rocks(Command):
2964
"""Statement of optimism."""
2965
2966
hidden = True
2967
2968
@display_command
2969
def run(self):
2970
print "It sure does!"
2971
2972
2973
class cmd_find_merge_base(Command):
2974
"""Find and print a base revision for merging two branches."""
2975
# TODO: Options to specify revisions on either side, as if
2976
# merging only part of the history.
2977
takes_args = ['branch', 'other']
2978
hidden = True
2979
2980
@display_command
2981
def run(self, branch, other):
2982
from bzrlib.revision import ensure_null
2983
2984
branch1 = Branch.open_containing(branch)[0]
2985
branch2 = Branch.open_containing(other)[0]
2986
branch1.lock_read()
2987
try:
2988
branch2.lock_read()
2989
try:
2990
last1 = ensure_null(branch1.last_revision())
2991
last2 = ensure_null(branch2.last_revision())
2992
2993
graph = branch1.repository.get_graph(branch2.repository)
2994
base_rev_id = graph.find_unique_lca(last1, last2)
2995
2996
print 'merge base is revision %s' % base_rev_id
2997
finally:
2998
branch2.unlock()
2999
finally:
3000
branch1.unlock()
3001
3002
3003
class cmd_merge(Command):
3004
"""Perform a three-way merge.
3005
3006
The source of the merge can be specified either in the form of a branch,
3007
or in the form of a path to a file containing a merge directive generated
3008
with bzr send. If neither is specified, the default is the upstream branch
3009
or the branch most recently merged using --remember.
3010
3011
When merging a branch, by default the tip will be merged. To pick a different
3012
revision, pass --revision. If you specify two values, the first will be used as
3013
BASE and the second one as OTHER. Merging individual revisions, or a subset of
3014
available revisions, like this is commonly referred to as "cherrypicking".
3015
3016
Revision numbers are always relative to the branch being merged.
3017
3018
By default, bzr will try to merge in all new work from the other
3019
branch, automatically determining an appropriate base. If this
3020
fails, you may need to give an explicit base.
3021
3022
Merge will do its best to combine the changes in two branches, but there
3023
are some kinds of problems only a human can fix. When it encounters those,
3024
it will mark a conflict. A conflict means that you need to fix something,
3025
before you should commit.
3026
3027
Use bzr resolve when you have fixed a problem. See also bzr conflicts.
3028
3029
If there is no default branch set, the first merge will set it. After
3030
that, you can omit the branch to use the default. To change the
3031
default, use --remember. The value will only be saved if the remote
3032
location can be accessed.
3033
3034
The results of the merge are placed into the destination working
3035
directory, where they can be reviewed (with bzr diff), tested, and then
3036
committed to record the result of the merge.
3037
3038
merge refuses to run if there are any uncommitted changes, unless
3039
--force is given.
3040
3041
:Examples:
3042
To merge the latest revision from bzr.dev::
3043
3044
bzr merge ../bzr.dev
3045
3046
To merge changes up to and including revision 82 from bzr.dev::
3047
3048
bzr merge -r 82 ../bzr.dev
3049
3050
To merge the changes introduced by 82, without previous changes::
3051
3052
bzr merge -r 81..82 ../bzr.dev
3053
3054
To apply a merge directive contained in in /tmp/merge:
3055
3056
bzr merge /tmp/merge
3057
"""
3058
3059
encoding_type = 'exact'
3060
_see_also = ['update', 'remerge', 'status-flags']
3061
takes_args = ['location?']
3062
takes_options = [
3063
'change',
3064
'revision',
3065
Option('force',
3066
help='Merge even if the destination tree has uncommitted changes.'),
3067
'merge-type',
3068
'reprocess',
3069
'remember',
3070
Option('show-base', help="Show base revision text in "
3071
"conflicts."),
3072
Option('uncommitted', help='Apply uncommitted changes'
3073
' from a working copy, instead of branch changes.'),
3074
Option('pull', help='If the destination is already'
3075
' completely merged into the source, pull from the'
3076
' source rather than merging. When this happens,'
3077
' you do not need to commit the result.'),
3078
Option('directory',
3079
help='Branch to merge into, '
3080
'rather than the one containing the working directory.',
3081
short_name='d',
3082
type=unicode,
3083
),
3084
Option('preview', help='Instead of merging, show a diff of the merge.')
3085
]
3086
3087
def run(self, location=None, revision=None, force=False,
3088
merge_type=None, show_base=False, reprocess=None, remember=False,
3089
uncommitted=False, pull=False,
3090
directory=None,
3091
preview=False,
3092
):
3093
if merge_type is None:
3094
merge_type = _mod_merge.Merge3Merger
3095
3096
if directory is None: directory = u'.'
3097
possible_transports = []
3098
merger = None
3099
allow_pending = True
3100
verified = 'inapplicable'
3101
tree = WorkingTree.open_containing(directory)[0]
3102
change_reporter = delta._ChangeReporter(
3103
unversioned_filter=tree.is_ignored)
3104
cleanups = []
3105
try:
3106
pb = ui.ui_factory.nested_progress_bar()
3107
cleanups.append(pb.finished)
3108
tree.lock_write()
3109
cleanups.append(tree.unlock)
3110
if location is not None:
3111
try:
3112
mergeable = bundle.read_mergeable_from_url(location,
3113
possible_transports=possible_transports)
3114
except errors.NotABundle:
3115
mergeable = None
3116
else:
3117
if uncommitted:
3118
raise errors.BzrCommandError('Cannot use --uncommitted'
3119
' with bundles or merge directives.')
3120
3121
if revision is not None:
3122
raise errors.BzrCommandError(
3123
'Cannot use -r with merge directives or bundles')
3124
merger, verified = _mod_merge.Merger.from_mergeable(tree,
3125
mergeable, pb)
3126
3127
if merger is None and uncommitted:
3128
if revision is not None and len(revision) > 0:
3129
raise errors.BzrCommandError('Cannot use --uncommitted and'
3130
' --revision at the same time.')
3131
location = self._select_branch_location(tree, location)[0]
3132
other_tree, other_path = WorkingTree.open_containing(location)
3133
merger = _mod_merge.Merger.from_uncommitted(tree, other_tree,
3134
pb)
3135
allow_pending = False
3136
if other_path != '':
3137
merger.interesting_files = [other_path]
3138
3139
if merger is None:
3140
merger, allow_pending = self._get_merger_from_branch(tree,
3141
location, revision, remember, possible_transports, pb)
3142
3143
merger.merge_type = merge_type
3144
merger.reprocess = reprocess
3145
merger.show_base = show_base
3146
self.sanity_check_merger(merger)
3147
if (merger.base_rev_id == merger.other_rev_id and
3148
merger.other_rev_id is not None):
3149
note('Nothing to do.')
3150
return 0
3151
if pull:
3152
if merger.interesting_files is not None:
3153
raise errors.BzrCommandError('Cannot pull individual files')
3154
if (merger.base_rev_id == tree.last_revision()):
3155
result = tree.pull(merger.other_branch, False,
3156
merger.other_rev_id)
3157
result.report(self.outf)
3158
return 0
3159
merger.check_basis(not force)
3160
if preview:
3161
return self._do_preview(merger)
3162
else:
3163
return self._do_merge(merger, change_reporter, allow_pending,
3164
verified)
3165
finally:
3166
for cleanup in reversed(cleanups):
3167
cleanup()
3168
3169
def _do_preview(self, merger):
3170
from bzrlib.diff import show_diff_trees
3171
tree_merger = merger.make_merger()
3172
tt = tree_merger.make_preview_transform()
3173
try:
3174
result_tree = tt.get_preview_tree()
3175
show_diff_trees(merger.this_tree, result_tree, self.outf,
3176
old_label='', new_label='')
3177
finally:
3178
tt.finalize()
3179
3180
def _do_merge(self, merger, change_reporter, allow_pending, verified):
3181
merger.change_reporter = change_reporter
3182
conflict_count = merger.do_merge()
3183
if allow_pending:
3184
merger.set_pending()
3185
if verified == 'failed':
3186
warning('Preview patch does not match changes')
3187
if conflict_count != 0:
3188
return 1
3189
else:
3190
return 0
3191
3192
def sanity_check_merger(self, merger):
3193
if (merger.show_base and
3194
not merger.merge_type is _mod_merge.Merge3Merger):
3195
raise errors.BzrCommandError("Show-base is not supported for this"
3196
" merge type. %s" % merger.merge_type)
3197
if merger.reprocess is None:
3198
if merger.show_base:
3199
merger.reprocess = False
3200
else:
3201
# Use reprocess if the merger supports it
3202
merger.reprocess = merger.merge_type.supports_reprocess
3203
if merger.reprocess and not merger.merge_type.supports_reprocess:
3204
raise errors.BzrCommandError("Conflict reduction is not supported"
3205
" for merge type %s." %
3206
merger.merge_type)
3207
if merger.reprocess and merger.show_base:
3208
raise errors.BzrCommandError("Cannot do conflict reduction and"
3209
" show base.")
3210
3211
def _get_merger_from_branch(self, tree, location, revision, remember,
3212
possible_transports, pb):
3213
"""Produce a merger from a location, assuming it refers to a branch."""
3214
from bzrlib.tag import _merge_tags_if_possible
3215
# find the branch locations
3216
other_loc, user_location = self._select_branch_location(tree, location,
3217
revision, -1)
3218
if revision is not None and len(revision) == 2:
3219
base_loc, _unused = self._select_branch_location(tree,
3220
location, revision, 0)
3221
else:
3222
base_loc = other_loc
3223
# Open the branches
3224
other_branch, other_path = Branch.open_containing(other_loc,
3225
possible_transports)
3226
if base_loc == other_loc:
3227
base_branch = other_branch
3228
else:
3229
base_branch, base_path = Branch.open_containing(base_loc,
3230
possible_transports)
3231
# Find the revision ids
3232
if revision is None or len(revision) < 1 or revision[-1] is None:
3233
other_revision_id = _mod_revision.ensure_null(
3234
other_branch.last_revision())
3235
else:
3236
other_revision_id = revision[-1].as_revision_id(other_branch)
3237
if (revision is not None and len(revision) == 2
3238
and revision[0] is not None):
3239
base_revision_id = revision[0].as_revision_id(base_branch)
3240
else:
3241
base_revision_id = None
3242
# Remember where we merge from
3243
if ((remember or tree.branch.get_submit_branch() is None) and
3244
user_location is not None):
3245
tree.branch.set_submit_branch(other_branch.base)
3246
_merge_tags_if_possible(other_branch, tree.branch)
3247
merger = _mod_merge.Merger.from_revision_ids(pb, tree,
3248
other_revision_id, base_revision_id, other_branch, base_branch)
3249
if other_path != '':
3250
allow_pending = False
3251
merger.interesting_files = [other_path]
3252
else:
3253
allow_pending = True
3254
return merger, allow_pending
3255
3256
def _select_branch_location(self, tree, user_location, revision=None,
3257
index=None):
3258
"""Select a branch location, according to possible inputs.
3259
3260
If provided, branches from ``revision`` are preferred. (Both
3261
``revision`` and ``index`` must be supplied.)
3262
3263
Otherwise, the ``location`` parameter is used. If it is None, then the
3264
``submit`` or ``parent`` location is used, and a note is printed.
3265
3266
:param tree: The working tree to select a branch for merging into
3267
:param location: The location entered by the user
3268
:param revision: The revision parameter to the command
3269
:param index: The index to use for the revision parameter. Negative
3270
indices are permitted.
3271
:return: (selected_location, user_location). The default location
3272
will be the user-entered location.
3273
"""
3274
if (revision is not None and index is not None
3275
and revision[index] is not None):
3276
branch = revision[index].get_branch()
3277
if branch is not None:
3278
return branch, branch
3279
if user_location is None:
3280
location = self._get_remembered(tree, 'Merging from')
3281
else:
3282
location = user_location
3283
return location, user_location
3284
3285
def _get_remembered(self, tree, verb_string):
3286
"""Use tree.branch's parent if none was supplied.
3287
3288
Report if the remembered location was used.
3289
"""
3290
stored_location = tree.branch.get_submit_branch()
3291
stored_location_type = "submit"
3292
if stored_location is None:
3293
stored_location = tree.branch.get_parent()
3294
stored_location_type = "parent"
3295
mutter("%s", stored_location)
3296
if stored_location is None:
3297
raise errors.BzrCommandError("No location specified or remembered")
3298
display_url = urlutils.unescape_for_display(stored_location, 'utf-8')
3299
note(u"%s remembered %s location %s", verb_string,
3300
stored_location_type, display_url)
3301
return stored_location
3302
3303
3304
class cmd_remerge(Command):
3305
"""Redo a merge.
3306
3307
Use this if you want to try a different merge technique while resolving
3308
conflicts. Some merge techniques are better than others, and remerge
3309
lets you try different ones on different files.
3310
3311
The options for remerge have the same meaning and defaults as the ones for
3312
merge. The difference is that remerge can (only) be run when there is a
3313
pending merge, and it lets you specify particular files.
3314
3315
:Examples:
3316
Re-do the merge of all conflicted files, and show the base text in
3317
conflict regions, in addition to the usual THIS and OTHER texts::
3318
3319
bzr remerge --show-base
3320
3321
Re-do the merge of "foobar", using the weave merge algorithm, with
3322
additional processing to reduce the size of conflict regions::
3323
3324
bzr remerge --merge-type weave --reprocess foobar
3325
"""
3326
takes_args = ['file*']
3327
takes_options = [
3328
'merge-type',
3329
'reprocess',
3330
Option('show-base',
3331
help="Show base revision text in conflicts."),
3332
]
3333
3334
def run(self, file_list=None, merge_type=None, show_base=False,
3335
reprocess=False):
3336
if merge_type is None:
3337
merge_type = _mod_merge.Merge3Merger
3338
tree, file_list = tree_files(file_list)
3339
tree.lock_write()
3340
try:
3341
parents = tree.get_parent_ids()
3342
if len(parents) != 2:
3343
raise errors.BzrCommandError("Sorry, remerge only works after normal"
3344
" merges. Not cherrypicking or"
3345
" multi-merges.")
3346
repository = tree.branch.repository
3347
interesting_ids = None
3348
new_conflicts = []
3349
conflicts = tree.conflicts()
3350
if file_list is not None:
3351
interesting_ids = set()
3352
for filename in file_list:
3353
file_id = tree.path2id(filename)
3354
if file_id is None:
3355
raise errors.NotVersionedError(filename)
3356
interesting_ids.add(file_id)
3357
if tree.kind(file_id) != "directory":
3358
continue
3359
3360
for name, ie in tree.inventory.iter_entries(file_id):
3361
interesting_ids.add(ie.file_id)
3362
new_conflicts = conflicts.select_conflicts(tree, file_list)[0]
3363
else:
3364
# Remerge only supports resolving contents conflicts
3365
allowed_conflicts = ('text conflict', 'contents conflict')
3366
restore_files = [c.path for c in conflicts
3367
if c.typestring in allowed_conflicts]
3368
_mod_merge.transform_tree(tree, tree.basis_tree(), interesting_ids)
3369
tree.set_conflicts(ConflictList(new_conflicts))
3370
if file_list is not None:
3371
restore_files = file_list
3372
for filename in restore_files:
3373
try:
3374
restore(tree.abspath(filename))
3375
except errors.NotConflicted:
3376
pass
3377
# Disable pending merges, because the file texts we are remerging
3378
# have not had those merges performed. If we use the wrong parents
3379
# list, we imply that the working tree text has seen and rejected
3380
# all the changes from the other tree, when in fact those changes
3381
# have not yet been seen.
3382
pb = ui.ui_factory.nested_progress_bar()
3383
tree.set_parent_ids(parents[:1])
3384
try:
3385
merger = _mod_merge.Merger.from_revision_ids(pb,
3386
tree, parents[1])
3387
merger.interesting_ids = interesting_ids
3388
merger.merge_type = merge_type
3389
merger.show_base = show_base
3390
merger.reprocess = reprocess
3391
conflicts = merger.do_merge()
3392
finally:
3393
tree.set_parent_ids(parents)
3394
pb.finished()
3395
finally:
3396
tree.unlock()
3397
if conflicts > 0:
3398
return 1
3399
else:
3400
return 0
3401
3402
3403
class cmd_revert(Command):
3404
"""Revert files to a previous revision.
3405
3406
Giving a list of files will revert only those files. Otherwise, all files
3407
will be reverted. If the revision is not specified with '--revision', the
3408
last committed revision is used.
3409
3410
To remove only some changes, without reverting to a prior version, use
3411
merge instead. For example, "merge . --revision -2..-3" will remove the
3412
changes introduced by -2, without affecting the changes introduced by -1.
3413
Or to remove certain changes on a hunk-by-hunk basis, see the Shelf plugin.
3414
3415
By default, any files that have been manually changed will be backed up
3416
first. (Files changed only by merge are not backed up.) Backup files have
3417
'.~#~' appended to their name, where # is a number.
3418
3419
When you provide files, you can use their current pathname or the pathname
3420
from the target revision. So you can use revert to "undelete" a file by
3421
name. If you name a directory, all the contents of that directory will be
3422
reverted.
3423
3424
Any files that have been newly added since that revision will be deleted,
3425
with a backup kept if appropriate. Directories containing unknown files
3426
will not be deleted.
3427
3428
The working tree contains a list of pending merged revisions, which will
3429
be included as parents in the next commit. Normally, revert clears that
3430
list as well as reverting the files. If any files are specified, revert
3431
leaves the pending merge list alone and reverts only the files. Use "bzr
3432
revert ." in the tree root to revert all files but keep the merge record,
3433
and "bzr revert --forget-merges" to clear the pending merge list without
3434
reverting any files.
3435
"""
3436
3437
_see_also = ['cat', 'export']
3438
takes_options = [
3439
'revision',
3440
Option('no-backup', "Do not save backups of reverted files."),
3441
Option('forget-merges',
3442
'Remove pending merge marker, without changing any files.'),
3443
]
3444
takes_args = ['file*']
3445
3446
def run(self, revision=None, no_backup=False, file_list=None,
3447
forget_merges=None):
3448
tree, file_list = tree_files(file_list)
3449
tree.lock_write()
3450
try:
3451
if forget_merges:
3452
tree.set_parent_ids(tree.get_parent_ids()[:1])
3453
else:
3454
self._revert_tree_to_revision(tree, revision, file_list, no_backup)
3455
finally:
3456
tree.unlock()
3457
3458
@staticmethod
3459
def _revert_tree_to_revision(tree, revision, file_list, no_backup):
3460
rev_tree = _get_one_revision_tree('revert', revision, tree=tree)
3461
pb = ui.ui_factory.nested_progress_bar()
3462
try:
3463
tree.revert(file_list, rev_tree, not no_backup, pb,
3464
report_changes=True)
3465
finally:
3466
pb.finished()
3467
3468
3469
class cmd_assert_fail(Command):
3470
"""Test reporting of assertion failures"""
3471
# intended just for use in testing
3472
3473
hidden = True
3474
3475
def run(self):
3476
raise AssertionError("always fails")
3477
3478
3479
class cmd_help(Command):
3480
"""Show help on a command or other topic.
3481
"""
3482
3483
_see_also = ['topics']
3484
takes_options = [
3485
Option('long', 'Show help on all commands.'),
3486
]
3487
takes_args = ['topic?']
3488
aliases = ['?', '--help', '-?', '-h']
3489
3490
@display_command
3491
def run(self, topic=None, long=False):
3492
import bzrlib.help
3493
if topic is None and long:
3494
topic = "commands"
3495
bzrlib.help.help(topic)
3496
3497
3498
class cmd_shell_complete(Command):
3499
"""Show appropriate completions for context.
3500
3501
For a list of all available commands, say 'bzr shell-complete'.
3502
"""
3503
takes_args = ['context?']
3504
aliases = ['s-c']
3505
hidden = True
3506
3507
@display_command
3508
def run(self, context=None):
3509
import shellcomplete
3510
shellcomplete.shellcomplete(context)
3511
3512
3513
class cmd_missing(Command):
3514
"""Show unmerged/unpulled revisions between two branches.
3515
3516
OTHER_BRANCH may be local or remote.
3517
"""
3518
3519
_see_also = ['merge', 'pull']
3520
takes_args = ['other_branch?']
3521
takes_options = [
3522
Option('reverse', 'Reverse the order of revisions.'),
3523
Option('mine-only',
3524
'Display changes in the local branch only.'),
3525
Option('this' , 'Same as --mine-only.'),
3526
Option('theirs-only',
3527
'Display changes in the remote branch only.'),
3528
Option('other', 'Same as --theirs-only.'),
3529
'log-format',
3530
'show-ids',
3531
'verbose',
3532
Option('include-merges', 'Show merged revisions.'),
3533
]
3534
encoding_type = 'replace'
3535
3536
@display_command
3537
def run(self, other_branch=None, reverse=False, mine_only=False,
3538
theirs_only=False,
3539
log_format=None, long=False, short=False, line=False,
3540
show_ids=False, verbose=False, this=False, other=False,
3541
include_merges=False):
3542
from bzrlib.missing import find_unmerged, iter_log_revisions
3543
def message(s):
3544
if not is_quiet():
3545
self.outf.write(s)
3546
3547
if this:
3548
mine_only = this
3549
if other:
3550
theirs_only = other
3551
# TODO: We should probably check that we don't have mine-only and
3552
# theirs-only set, but it gets complicated because we also have
3553
# this and other which could be used.
3554
restrict = 'all'
3555
if mine_only:
3556
restrict = 'local'
3557
elif theirs_only:
3558
restrict = 'remote'
3559
3560
local_branch = Branch.open_containing(u".")[0]
3561
parent = local_branch.get_parent()
3562
if other_branch is None:
3563
other_branch = parent
3564
if other_branch is None:
3565
raise errors.BzrCommandError("No peer location known"
3566
" or specified.")
3567
display_url = urlutils.unescape_for_display(parent,
3568
self.outf.encoding)
3569
message("Using saved parent location: "
3570
+ display_url + "\n")
3571
3572
remote_branch = Branch.open(other_branch)
3573
if remote_branch.base == local_branch.base:
3574
remote_branch = local_branch
3575
local_branch.lock_read()
3576
try:
3577
remote_branch.lock_read()
3578
try:
3579
local_extra, remote_extra = find_unmerged(
3580
local_branch, remote_branch, restrict,
3581
backward=not reverse,
3582
include_merges=include_merges)
3583
3584
if log_format is None:
3585
registry = log.log_formatter_registry
3586
log_format = registry.get_default(local_branch)
3587
lf = log_format(to_file=self.outf,
3588
show_ids=show_ids,
3589
show_timezone='original')
3590
3591
status_code = 0
3592
if local_extra and not theirs_only:
3593
message("You have %d extra revision(s):\n" %
3594
len(local_extra))
3595
for revision in iter_log_revisions(local_extra,
3596
local_branch.repository,
3597
verbose):
3598
lf.log_revision(revision)
3599
printed_local = True
3600
status_code = 1
3601
else:
3602
printed_local = False
3603
3604
if remote_extra and not mine_only:
3605
if printed_local is True:
3606
message("\n\n\n")
3607
message("You are missing %d revision(s):\n" %
3608
len(remote_extra))
3609
for revision in iter_log_revisions(remote_extra,
3610
remote_branch.repository,
3611
verbose):
3612
lf.log_revision(revision)
3613
status_code = 1
3614
3615
if mine_only and not local_extra:
3616
# We checked local, and found nothing extra
3617
message('This branch is up to date.\n')
3618
elif theirs_only and not remote_extra:
3619
# We checked remote, and found nothing extra
3620
message('Other branch is up to date.\n')
3621
elif not (mine_only or theirs_only or local_extra or
3622
remote_extra):
3623
# We checked both branches, and neither one had extra
3624
# revisions
3625
message("Branches are up to date.\n")
3626
finally:
3627
remote_branch.unlock()
3628
finally:
3629
local_branch.unlock()
3630
if not status_code and parent is None and other_branch is not None:
3631
local_branch.lock_write()
3632
try:
3633
# handle race conditions - a parent might be set while we run.
3634
if local_branch.get_parent() is None:
3635
local_branch.set_parent(remote_branch.base)
3636
finally:
3637
local_branch.unlock()
3638
return status_code
3639
3640
3641
class cmd_pack(Command):
3642
"""Compress the data within a repository."""
3643
3644
_see_also = ['repositories']
3645
takes_args = ['branch_or_repo?']
3646
3647
def run(self, branch_or_repo='.'):
3648
dir = bzrdir.BzrDir.open_containing(branch_or_repo)[0]
3649
try:
3650
branch = dir.open_branch()
3651
repository = branch.repository
3652
except errors.NotBranchError:
3653
repository = dir.open_repository()
3654
repository.pack()
3655
3656
3657
class cmd_plugins(Command):
3658
"""List the installed plugins.
3659
3660
This command displays the list of installed plugins including
3661
version of plugin and a short description of each.
3662
3663
--verbose shows the path where each plugin is located.
3664
3665
A plugin is an external component for Bazaar that extends the
3666
revision control system, by adding or replacing code in Bazaar.
3667
Plugins can do a variety of things, including overriding commands,
3668
adding new commands, providing additional network transports and
3669
customizing log output.
3670
3671
See the Bazaar web site, http://bazaar-vcs.org, for further
3672
information on plugins including where to find them and how to
3673
install them. Instructions are also provided there on how to
3674
write new plugins using the Python programming language.
3675
"""
3676
takes_options = ['verbose']
3677
3678
@display_command
3679
def run(self, verbose=False):
3680
import bzrlib.plugin
3681
from inspect import getdoc
3682
result = []
3683
for name, plugin in bzrlib.plugin.plugins().items():
3684
version = plugin.__version__
3685
if version == 'unknown':
3686
version = ''
3687
name_ver = '%s %s' % (name, version)
3688
d = getdoc(plugin.module)
3689
if d:
3690
doc = d.split('\n')[0]
3691
else:
3692
doc = '(no description)'
3693
result.append((name_ver, doc, plugin.path()))
3694
for name_ver, doc, path in sorted(result):
3695
print name_ver
3696
print ' ', doc
3697
if verbose:
3698
print ' ', path
3699
print
3700
3701
3702
class cmd_testament(Command):
3703
"""Show testament (signing-form) of a revision."""
3704
takes_options = [
3705
'revision',
3706
Option('long', help='Produce long-format testament.'),
3707
Option('strict',
3708
help='Produce a strict-format testament.')]
3709
takes_args = ['branch?']
3710
@display_command
3711
def run(self, branch=u'.', revision=None, long=False, strict=False):
3712
from bzrlib.testament import Testament, StrictTestament
3713
if strict is True:
3714
testament_class = StrictTestament
3715
else:
3716
testament_class = Testament
3717
if branch == '.':
3718
b = Branch.open_containing(branch)[0]
3719
else:
3720
b = Branch.open(branch)
3721
b.lock_read()
3722
try:
3723
if revision is None:
3724
rev_id = b.last_revision()
3725
else:
3726
rev_id = revision[0].as_revision_id(b)
3727
t = testament_class.from_revision(b.repository, rev_id)
3728
if long:
3729
sys.stdout.writelines(t.as_text_lines())
3730
else:
3731
sys.stdout.write(t.as_short_text())
3732
finally:
3733
b.unlock()
3734
3735
3736
class cmd_annotate(Command):
3737
"""Show the origin of each line in a file.
3738
3739
This prints out the given file with an annotation on the left side
3740
indicating which revision, author and date introduced the change.
3741
3742
If the origin is the same for a run of consecutive lines, it is
3743
shown only at the top, unless the --all option is given.
3744
"""
3745
# TODO: annotate directories; showing when each file was last changed
3746
# TODO: if the working copy is modified, show annotations on that
3747
# with new uncommitted lines marked
3748
aliases = ['ann', 'blame', 'praise']
3749
takes_args = ['filename']
3750
takes_options = [Option('all', help='Show annotations on all lines.'),
3751
Option('long', help='Show commit date in annotations.'),
3752
'revision',
3753
'show-ids',
3754
]
3755
encoding_type = 'exact'
3756
3757
@display_command
3758
def run(self, filename, all=False, long=False, revision=None,
3759
show_ids=False):
3760
from bzrlib.annotate import annotate_file, annotate_file_tree
3761
wt, branch, relpath = \
3762
bzrdir.BzrDir.open_containing_tree_or_branch(filename)
3763
if wt is not None:
3764
wt.lock_read()
3765
else:
3766
branch.lock_read()
3767
try:
3768
tree = _get_one_revision_tree('annotate', revision, branch=branch)
3769
if wt is not None:
3770
file_id = wt.path2id(relpath)
3771
else:
3772
file_id = tree.path2id(relpath)
3773
if file_id is None:
3774
raise errors.NotVersionedError(filename)
3775
file_version = tree.inventory[file_id].revision
3776
if wt is not None and revision is None:
3777
# If there is a tree and we're not annotating historical
3778
# versions, annotate the working tree's content.
3779
annotate_file_tree(wt, file_id, self.outf, long, all,
3780
show_ids=show_ids)
3781
else:
3782
annotate_file(branch, file_version, file_id, long, all, self.outf,
3783
show_ids=show_ids)
3784
finally:
3785
if wt is not None:
3786
wt.unlock()
3787
else:
3788
branch.unlock()
3789
3790
3791
class cmd_re_sign(Command):
3792
"""Create a digital signature for an existing revision."""
3793
# TODO be able to replace existing ones.
3794
3795
hidden = True # is this right ?
3796
takes_args = ['revision_id*']
3797
takes_options = ['revision']
3798
3799
def run(self, revision_id_list=None, revision=None):
3800
if revision_id_list is not None and revision is not None:
3801
raise errors.BzrCommandError('You can only supply one of revision_id or --revision')
3802
if revision_id_list is None and revision is None:
3803
raise errors.BzrCommandError('You must supply either --revision or a revision_id')
3804
b = WorkingTree.open_containing(u'.')[0].branch
3805
b.lock_write()
3806
try:
3807
return self._run(b, revision_id_list, revision)
3808
finally:
3809
b.unlock()
3810
3811
def _run(self, b, revision_id_list, revision):
3812
import bzrlib.gpg as gpg
3813
gpg_strategy = gpg.GPGStrategy(b.get_config())
3814
if revision_id_list is not None:
3815
b.repository.start_write_group()
3816
try:
3817
for revision_id in revision_id_list:
3818
b.repository.sign_revision(revision_id, gpg_strategy)
3819
except:
3820
b.repository.abort_write_group()
3821
raise
3822
else:
3823
b.repository.commit_write_group()
3824
elif revision is not None:
3825
if len(revision) == 1:
3826
revno, rev_id = revision[0].in_history(b)
3827
b.repository.start_write_group()
3828
try:
3829
b.repository.sign_revision(rev_id, gpg_strategy)
3830
except:
3831
b.repository.abort_write_group()
3832
raise
3833
else:
3834
b.repository.commit_write_group()
3835
elif len(revision) == 2:
3836
# are they both on rh- if so we can walk between them
3837
# might be nice to have a range helper for arbitrary
3838
# revision paths. hmm.
3839
from_revno, from_revid = revision[0].in_history(b)
3840
to_revno, to_revid = revision[1].in_history(b)
3841
if to_revid is None:
3842
to_revno = b.revno()
3843
if from_revno is None or to_revno is None:
3844
raise errors.BzrCommandError('Cannot sign a range of non-revision-history revisions')
3845
b.repository.start_write_group()
3846
try:
3847
for revno in range(from_revno, to_revno + 1):
3848
b.repository.sign_revision(b.get_rev_id(revno),
3849
gpg_strategy)
3850
except:
3851
b.repository.abort_write_group()
3852
raise
3853
else:
3854
b.repository.commit_write_group()
3855
else:
3856
raise errors.BzrCommandError('Please supply either one revision, or a range.')
3857
3858
3859
class cmd_bind(Command):
3860
"""Convert the current branch into a checkout of the supplied branch.
3861
3862
Once converted into a checkout, commits must succeed on the master branch
3863
before they will be applied to the local branch.
3864
3865
Bound branches use the nickname of its master branch unless it is set
3866
locally, in which case binding will update the the local nickname to be
3867
that of the master.
3868
"""
3869
3870
_see_also = ['checkouts', 'unbind']
3871
takes_args = ['location?']
3872
takes_options = []
3873
3874
def run(self, location=None):
3875
b, relpath = Branch.open_containing(u'.')
3876
if location is None:
3877
try:
3878
location = b.get_old_bound_location()
3879
except errors.UpgradeRequired:
3880
raise errors.BzrCommandError('No location supplied. '
3881
'This format does not remember old locations.')
3882
else:
3883
if location is None:
3884
raise errors.BzrCommandError('No location supplied and no '
3885
'previous location known')
3886
b_other = Branch.open(location)
3887
try:
3888
b.bind(b_other)
3889
except errors.DivergedBranches:
3890
raise errors.BzrCommandError('These branches have diverged.'
3891
' Try merging, and then bind again.')
3892
if b.get_config().has_explicit_nickname():
3893
b.nick = b_other.nick
3894
3895
3896
class cmd_unbind(Command):
3897
"""Convert the current checkout into a regular branch.
3898
3899
After unbinding, the local branch is considered independent and subsequent
3900
commits will be local only.
3901
"""
3902
3903
_see_also = ['checkouts', 'bind']
3904
takes_args = []
3905
takes_options = []
3906
3907
def run(self):
3908
b, relpath = Branch.open_containing(u'.')
3909
if not b.unbind():
3910
raise errors.BzrCommandError('Local branch is not bound')
3911
3912
3913
class cmd_uncommit(Command):
3914
"""Remove the last committed revision.
3915
3916
--verbose will print out what is being removed.
3917
--dry-run will go through all the motions, but not actually
3918
remove anything.
3919
3920
If --revision is specified, uncommit revisions to leave the branch at the
3921
specified revision. For example, "bzr uncommit -r 15" will leave the
3922
branch at revision 15.
3923
3924
Uncommit leaves the working tree ready for a new commit. The only change
3925
it may make is to restore any pending merges that were present before
3926
the commit.
3927
"""
3928
3929
# TODO: jam 20060108 Add an option to allow uncommit to remove
3930
# unreferenced information in 'branch-as-repository' branches.
3931
# TODO: jam 20060108 Add the ability for uncommit to remove unreferenced
3932
# information in shared branches as well.
3933
_see_also = ['commit']
3934
takes_options = ['verbose', 'revision',
3935
Option('dry-run', help='Don\'t actually make changes.'),
3936
Option('force', help='Say yes to all questions.'),
3937
Option('local',
3938
help="Only remove the commits from the local branch"
3939
" when in a checkout."
3940
),
3941
]
3942
takes_args = ['location?']
3943
aliases = []
3944
encoding_type = 'replace'
3945
3946
def run(self, location=None,
3947
dry_run=False, verbose=False,
3948
revision=None, force=False, local=False):
3949
if location is None:
3950
location = u'.'
3951
control, relpath = bzrdir.BzrDir.open_containing(location)
3952
try:
3953
tree = control.open_workingtree()
3954
b = tree.branch
3955
except (errors.NoWorkingTree, errors.NotLocalUrl):
3956
tree = None
3957
b = control.open_branch()
3958
3959
if tree is not None:
3960
tree.lock_write()
3961
else:
3962
b.lock_write()
3963
try:
3964
return self._run(b, tree, dry_run, verbose, revision, force,
3965
local=local)
3966
finally:
3967
if tree is not None:
3968
tree.unlock()
3969
else:
3970
b.unlock()
3971
3972
def _run(self, b, tree, dry_run, verbose, revision, force, local=False):
3973
from bzrlib.log import log_formatter, show_log
3974
from bzrlib.uncommit import uncommit
3975
3976
last_revno, last_rev_id = b.last_revision_info()
3977
3978
rev_id = None
3979
if revision is None:
3980
revno = last_revno
3981
rev_id = last_rev_id
3982
else:
3983
# 'bzr uncommit -r 10' actually means uncommit
3984
# so that the final tree is at revno 10.
3985
# but bzrlib.uncommit.uncommit() actually uncommits
3986
# the revisions that are supplied.
3987
# So we need to offset it by one
3988
revno = revision[0].in_history(b).revno + 1
3989
if revno <= last_revno:
3990
rev_id = b.get_rev_id(revno)
3991
3992
if rev_id is None or _mod_revision.is_null(rev_id):
3993
self.outf.write('No revisions to uncommit.\n')
3994
return 1
3995
3996
lf = log_formatter('short',
3997
to_file=self.outf,
3998
show_timezone='original')
3999
4000
show_log(b,
4001
lf,
4002
verbose=False,
4003
direction='forward',
4004
start_revision=revno,
4005
end_revision=last_revno)
4006
4007
if dry_run:
4008
print 'Dry-run, pretending to remove the above revisions.'
4009
if not force:
4010
val = raw_input('Press <enter> to continue')
4011
else:
4012
print 'The above revision(s) will be removed.'
4013
if not force:
4014
val = raw_input('Are you sure [y/N]? ')
4015
if val.lower() not in ('y', 'yes'):
4016
print 'Canceled'
4017
return 0
4018
4019
mutter('Uncommitting from {%s} to {%s}',
4020
last_rev_id, rev_id)
4021
uncommit(b, tree=tree, dry_run=dry_run, verbose=verbose,
4022
revno=revno, local=local)
4023
note('You can restore the old tip by running:\n'
4024
' bzr pull . -r revid:%s', last_rev_id)
4025
4026
4027
class cmd_break_lock(Command):
4028
"""Break a dead lock on a repository, branch or working directory.
4029
4030
CAUTION: Locks should only be broken when you are sure that the process
4031
holding the lock has been stopped.
4032
4033
You can get information on what locks are open via the 'bzr info' command.
4034
4035
:Examples:
4036
bzr break-lock
4037
"""
4038
takes_args = ['location?']
4039
4040
def run(self, location=None, show=False):
4041
if location is None:
4042
location = u'.'
4043
control, relpath = bzrdir.BzrDir.open_containing(location)
4044
try:
4045
control.break_lock()
4046
except NotImplementedError:
4047
pass
4048
4049
4050
class cmd_wait_until_signalled(Command):
4051
"""Test helper for test_start_and_stop_bzr_subprocess_send_signal.
4052
4053
This just prints a line to signal when it is ready, then blocks on stdin.
4054
"""
4055
4056
hidden = True
4057
4058
def run(self):
4059
sys.stdout.write("running\n")
4060
sys.stdout.flush()
4061
sys.stdin.readline()
4062
4063
4064
class cmd_serve(Command):
4065
"""Run the bzr server."""
4066
4067
aliases = ['server']
4068
4069
takes_options = [
4070
Option('inet',
4071
help='Serve on stdin/out for use from inetd or sshd.'),
4072
Option('port',
4073
help='Listen for connections on nominated port of the form '
4074
'[hostname:]portnumber. Passing 0 as the port number will '
4075
'result in a dynamically allocated port. The default port is '
4076
'4155.',
4077
type=str),
4078
Option('directory',
4079
help='Serve contents of this directory.',
4080
type=unicode),
4081
Option('allow-writes',
4082
help='By default the server is a readonly server. Supplying '
4083
'--allow-writes enables write access to the contents of '
4084
'the served directory and below.'
4085
),
4086
]
4087
4088
def run_smart_server(self, smart_server):
4089
"""Run 'smart_server' forever, with no UI output at all."""
4090
# For the duration of this server, no UI output is permitted. note
4091
# that this may cause problems with blackbox tests. This should be
4092
# changed with care though, as we dont want to use bandwidth sending
4093
# progress over stderr to smart server clients!
4094
from bzrlib import lockdir
4095
old_factory = ui.ui_factory
4096
old_lockdir_timeout = lockdir._DEFAULT_TIMEOUT_SECONDS
4097
try:
4098
ui.ui_factory = ui.SilentUIFactory()
4099
lockdir._DEFAULT_TIMEOUT_SECONDS = 0
4100
smart_server.serve()
4101
finally:
4102
ui.ui_factory = old_factory
4103
lockdir._DEFAULT_TIMEOUT_SECONDS = old_lockdir_timeout
4104
4105
def get_host_and_port(self, port):
4106
"""Return the host and port to run the smart server on.
4107
4108
If 'port' is None, the default host (`medium.BZR_DEFAULT_INTERFACE`)
4109
and port (`medium.BZR_DEFAULT_PORT`) will be used.
4110
4111
If 'port' has a colon in it, the string before the colon will be
4112
interpreted as the host.
4113
4114
:param port: A string of the port to run the server on.
4115
:return: A tuple of (host, port), where 'host' is a host name or IP,
4116
and port is an integer TCP/IP port.
4117
"""
4118
from bzrlib.smart import medium
4119
host = medium.BZR_DEFAULT_INTERFACE
4120
if port is None:
4121
port = medium.BZR_DEFAULT_PORT
4122
else:
4123
if ':' in port:
4124
host, port = port.split(':')
4125
port = int(port)
4126
return host, port
4127
4128
def get_smart_server(self, transport, inet, port):
4129
"""Construct a smart server.
4130
4131
:param transport: The base transport from which branches will be
4132
served.
4133
:param inet: If True, serve over stdin and stdout. Used for running
4134
from inet.
4135
:param port: The port to listen on. By default, it's `
4136
medium.BZR_DEFAULT_PORT`. See `get_host_and_port` for more
4137
information.
4138
:return: A smart server.
4139
"""
4140
from bzrlib.smart import medium, server
4141
if inet:
4142
smart_server = medium.SmartServerPipeStreamMedium(
4143
sys.stdin, sys.stdout, transport)
4144
else:
4145
host, port = self.get_host_and_port(port)
4146
smart_server = server.SmartTCPServer(
4147
transport, host=host, port=port)
4148
note('listening on port: %s' % smart_server.port)
4149
return smart_server
4150
4151
def run(self, port=None, inet=False, directory=None, allow_writes=False):
4152
from bzrlib.transport import get_transport
4153
from bzrlib.transport.chroot import ChrootServer
4154
if directory is None:
4155
directory = os.getcwd()
4156
url = urlutils.local_path_to_url(directory)
4157
if not allow_writes:
4158
url = 'readonly+' + url
4159
chroot_server = ChrootServer(get_transport(url))
4160
chroot_server.setUp()
4161
t = get_transport(chroot_server.get_url())
4162
smart_server = self.get_smart_server(t, inet, port)
4163
self.run_smart_server(smart_server)
4164
4165
4166
class cmd_join(Command):
4167
"""Combine a subtree into its containing tree.
4168
4169
This command is for experimental use only. It requires the target tree
4170
to be in dirstate-with-subtree format, which cannot be converted into
4171
earlier formats.
4172
4173
The TREE argument should be an independent tree, inside another tree, but
4174
not part of it. (Such trees can be produced by "bzr split", but also by
4175
running "bzr branch" with the target inside a tree.)
4176
4177
The result is a combined tree, with the subtree no longer an independant
4178
part. This is marked as a merge of the subtree into the containing tree,
4179
and all history is preserved.
4180
4181
If --reference is specified, the subtree retains its independence. It can
4182
be branched by itself, and can be part of multiple projects at the same
4183
time. But operations performed in the containing tree, such as commit
4184
and merge, will recurse into the subtree.
4185
"""
4186
4187
_see_also = ['split']
4188
takes_args = ['tree']
4189
takes_options = [
4190
Option('reference', help='Join by reference.'),
4191
]
4192
hidden = True
4193
4194
def run(self, tree, reference=False):
4195
sub_tree = WorkingTree.open(tree)
4196
parent_dir = osutils.dirname(sub_tree.basedir)
4197
containing_tree = WorkingTree.open_containing(parent_dir)[0]
4198
repo = containing_tree.branch.repository
4199
if not repo.supports_rich_root():
4200
raise errors.BzrCommandError(
4201
"Can't join trees because %s doesn't support rich root data.\n"
4202
"You can use bzr upgrade on the repository."
4203
% (repo,))
4204
if reference:
4205
try:
4206
containing_tree.add_reference(sub_tree)
4207
except errors.BadReferenceTarget, e:
4208
# XXX: Would be better to just raise a nicely printable
4209
# exception from the real origin. Also below. mbp 20070306
4210
raise errors.BzrCommandError("Cannot join %s. %s" %
4211
(tree, e.reason))
4212
else:
4213
try:
4214
containing_tree.subsume(sub_tree)
4215
except errors.BadSubsumeSource, e:
4216
raise errors.BzrCommandError("Cannot join %s. %s" %
4217
(tree, e.reason))
4218
4219
4220
class cmd_split(Command):
4221
"""Split a subdirectory of a tree into a separate tree.
4222
4223
This command will produce a target tree in a format that supports
4224
rich roots, like 'rich-root' or 'rich-root-pack'. These formats cannot be
4225
converted into earlier formats like 'dirstate-tags'.
4226
4227
The TREE argument should be a subdirectory of a working tree. That
4228
subdirectory will be converted into an independent tree, with its own
4229
branch. Commits in the top-level tree will not apply to the new subtree.
4230
"""
4231
4232
# join is not un-hidden yet
4233
#_see_also = ['join']
4234
takes_args = ['tree']
4235
4236
def run(self, tree):
4237
containing_tree, subdir = WorkingTree.open_containing(tree)
4238
sub_id = containing_tree.path2id(subdir)
4239
if sub_id is None:
4240
raise errors.NotVersionedError(subdir)
4241
try:
4242
containing_tree.extract(sub_id)
4243
except errors.RootNotRich:
4244
raise errors.UpgradeRequired(containing_tree.branch.base)
4245
4246
4247
class cmd_merge_directive(Command):
4248
"""Generate a merge directive for auto-merge tools.
4249
4250
A directive requests a merge to be performed, and also provides all the
4251
information necessary to do so. This means it must either include a
4252
revision bundle, or the location of a branch containing the desired
4253
revision.
4254
4255
A submit branch (the location to merge into) must be supplied the first
4256
time the command is issued. After it has been supplied once, it will
4257
be remembered as the default.
4258
4259
A public branch is optional if a revision bundle is supplied, but required
4260
if --diff or --plain is specified. It will be remembered as the default
4261
after the first use.
4262
"""
4263
4264
takes_args = ['submit_branch?', 'public_branch?']
4265
4266
hidden = True
4267
4268
_see_also = ['send']
4269
4270
takes_options = [
4271
RegistryOption.from_kwargs('patch-type',
4272
'The type of patch to include in the directive.',
4273
title='Patch type',
4274
value_switches=True,
4275
enum_switch=False,
4276
bundle='Bazaar revision bundle (default).',
4277
diff='Normal unified diff.',
4278
plain='No patch, just directive.'),
4279
Option('sign', help='GPG-sign the directive.'), 'revision',
4280
Option('mail-to', type=str,
4281
help='Instead of printing the directive, email to this address.'),
4282
Option('message', type=str, short_name='m',
4283
help='Message to use when committing this merge.')
4284
]
4285
4286
encoding_type = 'exact'
4287
4288
def run(self, submit_branch=None, public_branch=None, patch_type='bundle',
4289
sign=False, revision=None, mail_to=None, message=None):
4290
from bzrlib.revision import ensure_null, NULL_REVISION
4291
include_patch, include_bundle = {
4292
'plain': (False, False),
4293
'diff': (True, False),
4294
'bundle': (True, True),
4295
}[patch_type]
4296
branch = Branch.open('.')
4297
stored_submit_branch = branch.get_submit_branch()
4298
if submit_branch is None:
4299
submit_branch = stored_submit_branch
4300
else:
4301
if stored_submit_branch is None:
4302
branch.set_submit_branch(submit_branch)
4303
if submit_branch is None:
4304
submit_branch = branch.get_parent()
4305
if submit_branch is None:
4306
raise errors.BzrCommandError('No submit branch specified or known')
4307
4308
stored_public_branch = branch.get_public_branch()
4309
if public_branch is None:
4310
public_branch = stored_public_branch
4311
elif stored_public_branch is None:
4312
branch.set_public_branch(public_branch)
4313
if not include_bundle and public_branch is None:
4314
raise errors.BzrCommandError('No public branch specified or'
4315
' known')
4316
base_revision_id = None
4317
if revision is not None:
4318
if len(revision) > 2:
4319
raise errors.BzrCommandError('bzr merge-directive takes '
4320
'at most two one revision identifiers')
4321
revision_id = revision[-1].as_revision_id(branch)
4322
if len(revision) == 2:
4323
base_revision_id = revision[0].as_revision_id(branch)
4324
else:
4325
revision_id = branch.last_revision()
4326
revision_id = ensure_null(revision_id)
4327
if revision_id == NULL_REVISION:
4328
raise errors.BzrCommandError('No revisions to bundle.')
4329
directive = merge_directive.MergeDirective2.from_objects(
4330
branch.repository, revision_id, time.time(),
4331
osutils.local_time_offset(), submit_branch,
4332
public_branch=public_branch, include_patch=include_patch,
4333
include_bundle=include_bundle, message=message,
4334
base_revision_id=base_revision_id)
4335
if mail_to is None:
4336
if sign:
4337
self.outf.write(directive.to_signed(branch))
4338
else:
4339
self.outf.writelines(directive.to_lines())
4340
else:
4341
message = directive.to_email(mail_to, branch, sign)
4342
s = SMTPConnection(branch.get_config())
4343
s.send_email(message)
4344
4345
4346
class cmd_send(Command):
4347
"""Mail or create a merge-directive for submitting changes.
4348
4349
A merge directive provides many things needed for requesting merges:
4350
4351
* A machine-readable description of the merge to perform
4352
4353
* An optional patch that is a preview of the changes requested
4354
4355
* An optional bundle of revision data, so that the changes can be applied
4356
directly from the merge directive, without retrieving data from a
4357
branch.
4358
4359
If --no-bundle is specified, then public_branch is needed (and must be
4360
up-to-date), so that the receiver can perform the merge using the
4361
public_branch. The public_branch is always included if known, so that
4362
people can check it later.
4363
4364
The submit branch defaults to the parent, but can be overridden. Both
4365
submit branch and public branch will be remembered if supplied.
4366
4367
If a public_branch is known for the submit_branch, that public submit
4368
branch is used in the merge instructions. This means that a local mirror
4369
can be used as your actual submit branch, once you have set public_branch
4370
for that mirror.
4371
4372
Mail is sent using your preferred mail program. This should be transparent
4373
on Windows (it uses MAPI). On Linux, it requires the xdg-email utility.
4374
If the preferred client can't be found (or used), your editor will be used.
4375
4376
To use a specific mail program, set the mail_client configuration option.
4377
(For Thunderbird 1.5, this works around some bugs.) Supported values for
4378
specific clients are "claws", "evolution", "kmail", "mutt", and
4379
"thunderbird"; generic options are "default", "editor", "emacsclient",
4380
"mapi", and "xdg-email". Plugins may also add supported clients.
4381
4382
If mail is being sent, a to address is required. This can be supplied
4383
either on the commandline, by setting the submit_to configuration
4384
option in the branch itself or the child_submit_to configuration option
4385
in the submit branch.
4386
4387
Two formats are currently supported: "4" uses revision bundle format 4 and
4388
merge directive format 2. It is significantly faster and smaller than
4389
older formats. It is compatible with Bazaar 0.19 and later. It is the
4390
default. "0.9" uses revision bundle format 0.9 and merge directive
4391
format 1. It is compatible with Bazaar 0.12 - 0.18.
4392
4393
Merge directives are applied using the merge command or the pull command.
4394
"""
4395
4396
encoding_type = 'exact'
4397
4398
_see_also = ['merge', 'pull']
4399
4400
takes_args = ['submit_branch?', 'public_branch?']
4401
4402
takes_options = [
4403
Option('no-bundle',
4404
help='Do not include a bundle in the merge directive.'),
4405
Option('no-patch', help='Do not include a preview patch in the merge'
4406
' directive.'),
4407
Option('remember',
4408
help='Remember submit and public branch.'),
4409
Option('from',
4410
help='Branch to generate the submission from, '
4411
'rather than the one containing the working directory.',
4412
short_name='f',
4413
type=unicode),
4414
Option('output', short_name='o',
4415
help='Write merge directive to this file; '
4416
'use - for stdout.',
4417
type=unicode),
4418
Option('mail-to', help='Mail the request to this address.',
4419
type=unicode),
4420
'revision',
4421
'message',
4422
RegistryOption.from_kwargs('format',
4423
'Use the specified output format.',
4424
**{'4': 'Bundle format 4, Merge Directive 2 (default)',
4425
'0.9': 'Bundle format 0.9, Merge Directive 1',})
4426
]
4427
4428
def run(self, submit_branch=None, public_branch=None, no_bundle=False,
4429
no_patch=False, revision=None, remember=False, output=None,
4430
format='4', mail_to=None, message=None, **kwargs):
4431
return self._run(submit_branch, revision, public_branch, remember,
4432
format, no_bundle, no_patch, output,
4433
kwargs.get('from', '.'), mail_to, message)
4434
4435
def _run(self, submit_branch, revision, public_branch, remember, format,
4436
no_bundle, no_patch, output, from_, mail_to, message):
4437
from bzrlib.revision import NULL_REVISION
4438
branch = Branch.open_containing(from_)[0]
4439
if output is None:
4440
outfile = cStringIO.StringIO()
4441
elif output == '-':
4442
outfile = self.outf
4443
else:
4444
outfile = open(output, 'wb')
4445
# we may need to write data into branch's repository to calculate
4446
# the data to send.
4447
branch.lock_write()
4448
try:
4449
if output is None:
4450
config = branch.get_config()
4451
if mail_to is None:
4452
mail_to = config.get_user_option('submit_to')
4453
mail_client = config.get_mail_client()
4454
if remember and submit_branch is None:
4455
raise errors.BzrCommandError(
4456
'--remember requires a branch to be specified.')
4457
stored_submit_branch = branch.get_submit_branch()
4458
remembered_submit_branch = None
4459
if submit_branch is None:
4460
submit_branch = stored_submit_branch
4461
remembered_submit_branch = "submit"
4462
else:
4463
if stored_submit_branch is None or remember:
4464
branch.set_submit_branch(submit_branch)
4465
if submit_branch is None:
4466
submit_branch = branch.get_parent()
4467
remembered_submit_branch = "parent"
4468
if submit_branch is None:
4469
raise errors.BzrCommandError('No submit branch known or'
4470
' specified')
4471
if remembered_submit_branch is not None:
4472
note('Using saved %s location "%s" to determine what '
4473
'changes to submit.', remembered_submit_branch,
4474
submit_branch)
4475
4476
if mail_to is None:
4477
submit_config = Branch.open(submit_branch).get_config()
4478
mail_to = submit_config.get_user_option("child_submit_to")
4479
4480
stored_public_branch = branch.get_public_branch()
4481
if public_branch is None:
4482
public_branch = stored_public_branch
4483
elif stored_public_branch is None or remember:
4484
branch.set_public_branch(public_branch)
4485
if no_bundle and public_branch is None:
4486
raise errors.BzrCommandError('No public branch specified or'
4487
' known')
4488
base_revision_id = None
4489
revision_id = None
4490
if revision is not None:
4491
if len(revision) > 2:
4492
raise errors.BzrCommandError('bzr send takes '
4493
'at most two one revision identifiers')
4494
revision_id = revision[-1].as_revision_id(branch)
4495
if len(revision) == 2:
4496
base_revision_id = revision[0].as_revision_id(branch)
4497
if revision_id is None:
4498
revision_id = branch.last_revision()
4499
if revision_id == NULL_REVISION:
4500
raise errors.BzrCommandError('No revisions to submit.')
4501
if format == '4':
4502
directive = merge_directive.MergeDirective2.from_objects(
4503
branch.repository, revision_id, time.time(),
4504
osutils.local_time_offset(), submit_branch,
4505
public_branch=public_branch, include_patch=not no_patch,
4506
include_bundle=not no_bundle, message=message,
4507
base_revision_id=base_revision_id)
4508
elif format == '0.9':
4509
if not no_bundle:
4510
if not no_patch:
4511
patch_type = 'bundle'
4512
else:
4513
raise errors.BzrCommandError('Format 0.9 does not'
4514
' permit bundle with no patch')
4515
else:
4516
if not no_patch:
4517
patch_type = 'diff'
4518
else:
4519
patch_type = None
4520
directive = merge_directive.MergeDirective.from_objects(
4521
branch.repository, revision_id, time.time(),
4522
osutils.local_time_offset(), submit_branch,
4523
public_branch=public_branch, patch_type=patch_type,
4524
message=message)
4525
4526
outfile.writelines(directive.to_lines())
4527
if output is None:
4528
subject = '[MERGE] '
4529
if message is not None:
4530
subject += message
4531
else:
4532
revision = branch.repository.get_revision(revision_id)
4533
subject += revision.get_summary()
4534
basename = directive.get_disk_name(branch)
4535
mail_client.compose_merge_request(mail_to, subject,
4536
outfile.getvalue(), basename)
4537
finally:
4538
if output != '-':
4539
outfile.close()
4540
branch.unlock()
4541
4542
4543
class cmd_bundle_revisions(cmd_send):
4544
4545
"""Create a merge-directive for submitting changes.
4546
4547
A merge directive provides many things needed for requesting merges:
4548
4549
* A machine-readable description of the merge to perform
4550
4551
* An optional patch that is a preview of the changes requested
4552
4553
* An optional bundle of revision data, so that the changes can be applied
4554
directly from the merge directive, without retrieving data from a
4555
branch.
4556
4557
If --no-bundle is specified, then public_branch is needed (and must be
4558
up-to-date), so that the receiver can perform the merge using the
4559
public_branch. The public_branch is always included if known, so that
4560
people can check it later.
4561
4562
The submit branch defaults to the parent, but can be overridden. Both
4563
submit branch and public branch will be remembered if supplied.
4564
4565
If a public_branch is known for the submit_branch, that public submit
4566
branch is used in the merge instructions. This means that a local mirror
4567
can be used as your actual submit branch, once you have set public_branch
4568
for that mirror.
4569
4570
Two formats are currently supported: "4" uses revision bundle format 4 and
4571
merge directive format 2. It is significantly faster and smaller than
4572
older formats. It is compatible with Bazaar 0.19 and later. It is the
4573
default. "0.9" uses revision bundle format 0.9 and merge directive
4574
format 1. It is compatible with Bazaar 0.12 - 0.18.
4575
"""
4576
4577
takes_options = [
4578
Option('no-bundle',
4579
help='Do not include a bundle in the merge directive.'),
4580
Option('no-patch', help='Do not include a preview patch in the merge'
4581
' directive.'),
4582
Option('remember',
4583
help='Remember submit and public branch.'),
4584
Option('from',
4585
help='Branch to generate the submission from, '
4586
'rather than the one containing the working directory.',
4587
short_name='f',
4588
type=unicode),
4589
Option('output', short_name='o', help='Write directive to this file.',
4590
type=unicode),
4591
'revision',
4592
RegistryOption.from_kwargs('format',
4593
'Use the specified output format.',
4594
**{'4': 'Bundle format 4, Merge Directive 2 (default)',
4595
'0.9': 'Bundle format 0.9, Merge Directive 1',})
4596
]
4597
aliases = ['bundle']
4598
4599
_see_also = ['send', 'merge']
4600
4601
hidden = True
4602
4603
def run(self, submit_branch=None, public_branch=None, no_bundle=False,
4604
no_patch=False, revision=None, remember=False, output=None,
4605
format='4', **kwargs):
4606
if output is None:
4607
output = '-'
4608
return self._run(submit_branch, revision, public_branch, remember,
4609
format, no_bundle, no_patch, output,
4610
kwargs.get('from', '.'), None, None)
4611
4612
4613
class cmd_tag(Command):
4614
"""Create, remove or modify a tag naming a revision.
4615
4616
Tags give human-meaningful names to revisions. Commands that take a -r
4617
(--revision) option can be given -rtag:X, where X is any previously
4618
created tag.
4619
4620
Tags are stored in the branch. Tags are copied from one branch to another
4621
along when you branch, push, pull or merge.
4622
4623
It is an error to give a tag name that already exists unless you pass
4624
--force, in which case the tag is moved to point to the new revision.
4625
4626
To rename a tag (change the name but keep it on the same revsion), run ``bzr
4627
tag new-name -r tag:old-name`` and then ``bzr tag --delete oldname``.
4628
"""
4629
4630
_see_also = ['commit', 'tags']
4631
takes_args = ['tag_name']
4632
takes_options = [
4633
Option('delete',
4634
help='Delete this tag rather than placing it.',
4635
),
4636
Option('directory',
4637
help='Branch in which to place the tag.',
4638
short_name='d',
4639
type=unicode,
4640
),
4641
Option('force',
4642
help='Replace existing tags.',
4643
),
4644
'revision',
4645
]
4646
4647
def run(self, tag_name,
4648
delete=None,
4649
directory='.',
4650
force=None,
4651
revision=None,
4652
):
4653
branch, relpath = Branch.open_containing(directory)
4654
branch.lock_write()
4655
try:
4656
if delete:
4657
branch.tags.delete_tag(tag_name)
4658
self.outf.write('Deleted tag %s.\n' % tag_name)
4659
else:
4660
if revision:
4661
if len(revision) != 1:
4662
raise errors.BzrCommandError(
4663
"Tags can only be placed on a single revision, "
4664
"not on a range")
4665
revision_id = revision[0].as_revision_id(branch)
4666
else:
4667
revision_id = branch.last_revision()
4668
if (not force) and branch.tags.has_tag(tag_name):
4669
raise errors.TagAlreadyExists(tag_name)
4670
branch.tags.set_tag(tag_name, revision_id)
4671
self.outf.write('Created tag %s.\n' % tag_name)
4672
finally:
4673
branch.unlock()
4674
4675
4676
class cmd_tags(Command):
4677
"""List tags.
4678
4679
This command shows a table of tag names and the revisions they reference.
4680
"""
4681
4682
_see_also = ['tag']
4683
takes_options = [
4684
Option('directory',
4685
help='Branch whose tags should be displayed.',
4686
short_name='d',
4687
type=unicode,
4688
),
4689
RegistryOption.from_kwargs('sort',
4690
'Sort tags by different criteria.', title='Sorting',
4691
alpha='Sort tags lexicographically (default).',
4692
time='Sort tags chronologically.',
4693
),
4694
'show-ids',
4695
'revision',
4696
]
4697
4698
@display_command
4699
def run(self,
4700
directory='.',
4701
sort='alpha',
4702
show_ids=False,
4703
revision=None,
4704
):
4705
branch, relpath = Branch.open_containing(directory)
4706
4707
tags = branch.tags.get_tag_dict().items()
4708
if not tags:
4709
return
4710
4711
if revision:
4712
branch.lock_read()
4713
try:
4714
graph = branch.repository.get_graph()
4715
rev1, rev2 = _get_revision_range(revision, branch, self.name())
4716
revid1, revid2 = rev1.rev_id, rev2.rev_id
4717
# only show revisions between revid1 and revid2 (inclusive)
4718
tags = [(tag, revid) for tag, revid in tags if
4719
(revid2 is None or
4720
graph.is_ancestor(revid, revid2)) and
4721
(revid1 is None or
4722
graph.is_ancestor(revid1, revid))]
4723
finally:
4724
branch.unlock()
4725
if sort == 'alpha':
4726
tags.sort()
4727
elif sort == 'time':
4728
timestamps = {}
4729
for tag, revid in tags:
4730
try:
4731
revobj = branch.repository.get_revision(revid)
4732
except errors.NoSuchRevision:
4733
timestamp = sys.maxint # place them at the end
4734
else:
4735
timestamp = revobj.timestamp
4736
timestamps[revid] = timestamp
4737
tags.sort(key=lambda x: timestamps[x[1]])
4738
if not show_ids:
4739
# [ (tag, revid), ... ] -> [ (tag, dotted_revno), ... ]
4740
revno_map = branch.get_revision_id_to_revno_map()
4741
tags = [ (tag, '.'.join(map(str, revno_map.get(revid, ('?',)))))
4742
for tag, revid in tags ]
4743
for tag, revspec in tags:
4744
self.outf.write('%-20s %s\n' % (tag, revspec))
4745
4746
4747
class cmd_reconfigure(Command):
4748
"""Reconfigure the type of a bzr directory.
4749
4750
A target configuration must be specified.
4751
4752
For checkouts, the bind-to location will be auto-detected if not specified.
4753
The order of preference is
4754
1. For a lightweight checkout, the current bound location.
4755
2. For branches that used to be checkouts, the previously-bound location.
4756
3. The push location.
4757
4. The parent location.
4758
If none of these is available, --bind-to must be specified.
4759
"""
4760
4761
_see_also = ['branches', 'checkouts', 'standalone-trees', 'working-trees']
4762
takes_args = ['location?']
4763
takes_options = [RegistryOption.from_kwargs('target_type',
4764
title='Target type',
4765
help='The type to reconfigure the directory to.',
4766
value_switches=True, enum_switch=False,
4767
branch='Reconfigure to be an unbound branch '
4768
'with no working tree.',
4769
tree='Reconfigure to be an unbound branch '
4770
'with a working tree.',
4771
checkout='Reconfigure to be a bound branch '
4772
'with a working tree.',
4773
lightweight_checkout='Reconfigure to be a lightweight'
4774
' checkout (with no local history).',
4775
standalone='Reconfigure to be a standalone branch '
4776
'(i.e. stop using shared repository).',
4777
use_shared='Reconfigure to use a shared repository.'),
4778
Option('bind-to', help='Branch to bind checkout to.',
4779
type=str),
4780
Option('force',
4781
help='Perform reconfiguration even if local changes'
4782
' will be lost.')
4783
]
4784
4785
def run(self, location=None, target_type=None, bind_to=None, force=False):
4786
directory = bzrdir.BzrDir.open(location)
4787
if target_type is None:
4788
raise errors.BzrCommandError('No target configuration specified')
4789
elif target_type == 'branch':
4790
reconfiguration = reconfigure.Reconfigure.to_branch(directory)
4791
elif target_type == 'tree':
4792
reconfiguration = reconfigure.Reconfigure.to_tree(directory)
4793
elif target_type == 'checkout':
4794
reconfiguration = reconfigure.Reconfigure.to_checkout(directory,
4795
bind_to)
4796
elif target_type == 'lightweight-checkout':
4797
reconfiguration = reconfigure.Reconfigure.to_lightweight_checkout(
4798
directory, bind_to)
4799
elif target_type == 'use-shared':
4800
reconfiguration = reconfigure.Reconfigure.to_use_shared(directory)
4801
elif target_type == 'standalone':
4802
reconfiguration = reconfigure.Reconfigure.to_standalone(directory)
4803
reconfiguration.apply(force)
4804
4805
4806
class cmd_switch(Command):
4807
"""Set the branch of a checkout and update.
4808
4809
For lightweight checkouts, this changes the branch being referenced.
4810
For heavyweight checkouts, this checks that there are no local commits
4811
versus the current bound branch, then it makes the local branch a mirror
4812
of the new location and binds to it.
4813
4814
In both cases, the working tree is updated and uncommitted changes
4815
are merged. The user can commit or revert these as they desire.
4816
4817
Pending merges need to be committed or reverted before using switch.
4818
4819
The path to the branch to switch to can be specified relative to the parent
4820
directory of the current branch. For example, if you are currently in a
4821
checkout of /path/to/branch, specifying 'newbranch' will find a branch at
4822
/path/to/newbranch.
4823
4824
Bound branches use the nickname of its master branch unless it is set
4825
locally, in which case switching will update the the local nickname to be
4826
that of the master.
4827
"""
4828
4829
takes_args = ['to_location']
4830
takes_options = [Option('force',
4831
help='Switch even if local commits will be lost.')
4832
]
4833
4834
def run(self, to_location, force=False):
4835
from bzrlib import switch
4836
tree_location = '.'
4837
control_dir = bzrdir.BzrDir.open_containing(tree_location)[0]
4838
branch = control_dir.open_branch()
4839
try:
4840
to_branch = Branch.open(to_location)
4841
except errors.NotBranchError:
4842
this_branch = control_dir.open_branch()
4843
# This may be a heavy checkout, where we want the master branch
4844
this_url = this_branch.get_bound_location()
4845
# If not, use a local sibling
4846
if this_url is None:
4847
this_url = this_branch.base
4848
to_branch = Branch.open(
4849
urlutils.join(this_url, '..', to_location))
4850
switch.switch(control_dir, to_branch, force)
4851
if branch.get_config().has_explicit_nickname():
4852
branch = control_dir.open_branch() #get the new branch!
4853
branch.nick = to_branch.nick
4854
note('Switched to branch: %s',
4855
urlutils.unescape_for_display(to_branch.base, 'utf-8'))
4856
4857
4858
class cmd_hooks(Command):
4859
"""Show a branch's currently registered hooks.
4860
"""
4861
4862
hidden = True
4863
takes_args = ['path?']
4864
4865
def run(self, path=None):
4866
if path is None:
4867
path = '.'
4868
branch_hooks = Branch.open(path).hooks
4869
for hook_type in branch_hooks:
4870
hooks = branch_hooks[hook_type]
4871
self.outf.write("%s:\n" % (hook_type,))
4872
if hooks:
4873
for hook in hooks:
4874
self.outf.write(" %s\n" %
4875
(branch_hooks.get_hook_name(hook),))
4876
else:
4877
self.outf.write(" <no hooks installed>\n")
4878
4879
4880
class cmd_shelve(Command):
4881
"""Temporarily set aside some changes from the current tree.
4882
4883
Shelve allows you to temporarily put changes you've made "on the shelf",
4884
ie. out of the way, until a later time when you can bring them back from
4885
the shelf with the 'unshelve' command.
4886
4887
If shelve --list is specified, previously-shelved changes are listed.
4888
4889
Shelve is intended to help separate several sets of changes that have
4890
been inappropriately mingled. If you just want to get rid of all changes
4891
and you don't need to restore them later, use revert. If you want to
4892
shelve all text changes at once, use shelve --all.
4893
4894
If filenames are specified, only the changes to those files will be
4895
shelved. Other files will be left untouched.
4896
4897
If a revision is specified, changes since that revision will be shelved.
4898
4899
You can put multiple items on the shelf, and by default, 'unshelve' will
4900
restore the most recently shelved changes.
4901
"""
4902
4903
takes_args = ['file*']
4904
4905
takes_options = [
4906
'revision',
4907
Option('all', help='Shelve all changes.'),
4908
'message',
4909
RegistryOption('writer', 'Method to use for writing diffs.',
4910
bzrlib.option.diff_writer_registry,
4911
value_switches=True, enum_switch=False),
4912
4913
Option('list', help='List shelved changes.'),
4914
]
4915
_see_also = ['unshelve']
4916
4917
def run(self, revision=None, all=False, file_list=None, message=None,
4918
writer=None, list=False):
4919
if list:
4920
return self.run_for_list()
4921
from bzrlib.shelf_ui import Shelver
4922
if writer is None:
4923
writer = bzrlib.option.diff_writer_registry.get()
4924
try:
4925
Shelver.from_args(writer(sys.stdout), revision, all, file_list,
4926
message).run()
4927
except errors.UserAbort:
4928
return 0
4929
4930
def run_for_list(self):
4931
tree = WorkingTree.open_containing('.')[0]
4932
tree.lock_read()
4933
try:
4934
manager = tree.get_shelf_manager()
4935
shelves = manager.active_shelves()
4936
if len(shelves) == 0:
4937
note('No shelved changes.')
4938
return 0
4939
for shelf_id in reversed(shelves):
4940
message = manager.get_metadata(shelf_id).get('message')
4941
if message is None:
4942
message = '<no message>'
4943
self.outf.write('%3d: %s\n' % (shelf_id, message))
4944
return 1
4945
finally:
4946
tree.unlock()
4947
4948
4949
class cmd_unshelve(Command):
4950
"""Restore shelved changes.
4951
4952
By default, the most recently shelved changes are restored. However if you
4953
specify a patch by name those changes will be restored instead. This
4954
works best when the changes don't depend on each other.
4955
"""
4956
4957
takes_args = ['shelf_id?']
4958
takes_options = [
4959
RegistryOption.from_kwargs(
4960
'action', help="The action to perform.",
4961
enum_switch=False, value_switches=True,
4962
apply="Apply changes and remove from the shelf.",
4963
dry_run="Show changes, but do not apply or remove them.",
4964
delete_only="Delete changes without applying them."
4965
)
4966
]
4967
_see_also = ['shelve']
4968
4969
def run(self, shelf_id=None, action='apply'):
4970
from bzrlib.shelf_ui import Unshelver
4971
Unshelver.from_args(shelf_id, action).run()
4972
4973
4974
def _create_prefix(cur_transport):
4975
needed = [cur_transport]
4976
# Recurse upwards until we can create a directory successfully
4977
while True:
4978
new_transport = cur_transport.clone('..')
4979
if new_transport.base == cur_transport.base:
4980
raise errors.BzrCommandError(
4981
"Failed to create path prefix for %s."
4982
% cur_transport.base)
4983
try:
4984
new_transport.mkdir('.')
4985
except errors.NoSuchFile:
4986
needed.append(new_transport)
4987
cur_transport = new_transport
4988
else:
4989
break
4990
# Now we only need to create child directories
4991
while needed:
4992
cur_transport = needed.pop()
4993
cur_transport.ensure_base()
4994
4995
4996
# these get imported and then picked up by the scan for cmd_*
4997
# TODO: Some more consistent way to split command definitions across files;
4998
# we do need to load at least some information about them to know of
4999
# aliases. ideally we would avoid loading the implementation until the
5000
# details were needed.
5001
from bzrlib.cmd_version_info import cmd_version_info
5002
from bzrlib.conflicts import cmd_resolve, cmd_conflicts, restore
5003
from bzrlib.bundle.commands import (
5004
cmd_bundle_info,
5005
)
5006
from bzrlib.sign_my_commits import cmd_sign_my_commits
5007
from bzrlib.weave_commands import cmd_versionedfile_list, \
5008
cmd_weave_plan_merge, cmd_weave_merge_text
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0