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