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