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