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