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